Gradle: управляя зависимостями

Управление зависимостями – одна из наиболее важных функций в арсенале систем сборки. С приходом Gradle в качестве основной системы сборки Android-проектов в части управления зависимостями произошёл существенный сдвиг, закончилась эпоха ручного копирования JAR-файлов и долгих танцев с бубном вокруг сбоящих конфигураций проекта.



В статье рассматриваются основы управления зависимостями в Gradle, приводятся углублённые практические примеры, небольшие лайфхаки и ссылки на нужные места в документации.

Репозиторий

Как известно, Gradle не имеет собственных репозиториев и в качестве источника зависимостей использует Maven- и Ivy-репозитории. При этом интерфейс для работы с репозиториями не отличается на базовом уровне, более развёрнуто об отличиях параметров вы можете узнать по ссылкам IvyArtifactRepository и MavenArtifactRepository. Стоит отметить, что в качестве url могут использоваться ‘http’, ‘https’ или ‘file’ протоколы. Порядок, в котором записаны репозитории, влияет на порядок поиска зависимости в репозиториях.

// build.gradle
repositories {
	maven {
		url "http://example.com"
	}
	ivy {
		url "http://example.com"
	}
}

Объявление зависимостей

// build.gradle
apply plugin: 'java'

repositories {
	mavenCentral()
}

dependencies {
	compile group: 'com.googlecode.jsontoken', name: 'jsontoken', version: '1.1'
	testCompile group: 'junit', name: 'junit', version: '4.+'
}

В приведённом выше примере вы видите сценарий сборки, в котором подключены две зависимости для различных конфигураций (compile и testCompile) компиляции проекта. JsonToken будет подключаться во время компиляции проекта и компиляции тестов проекта, jUnit только во время компиляции тестов проекта. Детальнее о конфигурациях компиляции — по ссылке.

Также можно увидеть, что jUnit-зависимость мы подключаем как динамическую(+), т.е. будет использоваться самая последняя из доступных версия 4.+, и нам не нужно будет следить за минорными обновлениями (рекомендую не использовать эту возможность в compile-типе компиляции приложения, т.к. могут появиться неожиданные, возможно, сложно локализуемые проблемы).

На примере с jUnit-зависимостью рассмотрим стандартный механизм Gradle по поиску необходимой зависимости:

1. Зависимость
	compile ("org.junit:junit:4.+")
2. Получение версии модуля
	group:	"org.junit"
	name:		"junit"
	version:	"4.+"
3. Получение списка возможных версий модуля
	[junit:4.1]
	…
	[junit:4.12]
4. Выбор одной версии зависимости
	[junit:4.12]
5. Получение версии зависимости
	[junit:4.12]
		dependencies { … }
		artifacts { … }
6. Присоединение артефактов зависимости к проекту
	junit-4.12.jar
	junit-4.12-source.jar
	junit-4.12-javadoc.zip

Кэш

В Gradle реализована система кэширования, которая по умолчанию хранит зависимости в течение 24 часов, но это поведение можно переопределить.

// build.gradle
configurations.all {
	resolutionStrategy.cacheChangingModulesFor 4, 'hours'
	resolutionStrategy.cacheDynamicVersionsFor 10, 'minutes'
}

После того, как время, установленное для хранения данных в кэше, вышло, система при запуске задач сначала проверит возможность обновления динамических (dynamic) и изменяемых (changing) зависимостей и при необходимости их обновит.

Gradle старается не загружать те файлы, которые были загруженны ранее, и использует для этого систему проверок, даже если URL/источники файлов будут отличаться. Gradle всегда проверяет кэш (URL, версия и имя модуля, кэш других версий Gradle, Maven-кэш), заголовки HTTP-запроса (Date, Content-Length, ETag) и SHA1-хэш, если он доступен. Если совпадений не найдено, то система загрузит файл.

Также в системе сборки присутствуют два параметра, используя которые при запуске вы можете изменить политику кэширования для конкретного выполнения задачи.

– –offline – Gradle никогда не будет пытаться обратиться в сеть для проверки обновлений зависимостей.
– –refresh-dependencies – Gradle попытается обновить все зависимости. Удобно использовать при повреждении данных, находящихся в кэше. Верифицирует кэшированные данные и при отличии обновляет их.

Более детально про кэширование зависимостей можно прочитать в Gradle User Guide.

Виды зависимостей

Существует несколько видов зависимостей в Gradle. Наиболее часто используемыми являются:

– Внешние зависимости проекта — зависимости, загружаемые из внешних репозиториев;

// build.gradle
dependencies {
	compile "com.android.support:appcompat-v7:23.1.1"
}

– Проектные зависимости — зависимость от модуля (подпроекта) в рамках одного проекта;

// build.gradle
dependencies {
	compile project(':subproject')
}

– Файловые зависимости — зависимости, подключаемые как файлы (jar/aar архивы).

build.gradle
repositories {
	flatDir {
		dirs 'aarlibs' // инициализируем папку, хранящую aar-архивы как репозиторий
	}
}
dependencies {
	compile(name:'android_library', ext:'aar') // подключаем aar-зависимость
	compile files('libs/a.jar', 'libs/b.jar')
	compile fileTree(dir: 'libs', include: '*.jar')
}

Также существуют зависимости клиентских модулей, зависимости Gradle API и локальные Groovy-зависимости. Они используются редко, поэтому в рамках данной статьи не будем их разбирать, но почитать документацию о них можно здесь.

Дерево зависимостей

Каждая внешняя или проектная зависимость может содержать собственные зависимости, которые необходимо учесть и загрузить. Таким образом, при выполнении компиляции происходит загрузка зависимостей для выбранной конфигурации и строится дерево зависимостей, человеческое представление которого можно увидеть, выполнив Gradle task ‘dependencies’ в Android Studio или команду gradle %module_name%:dependencies в консоли, находясь в корневой папке проекта. В ответ вы получите список деревьев зависимостей для каждой из доступных конфигураций.

Используя параметр configuration, указываем имя конфигурации, чтобы видеть дерево зависимостей только указанной конфигурации.

Возьмем специально подготовленные исходники репозитория, расположенного на github и попробуем получить дерево зависимостей для конкретной конфигурации (в данный момент проект находится в состоянии 0, т.е. в качестве build.gradle используется build.gradle.0):



Проанализировав дерево зависимостей, можно увидеть, что модуль app использует в качестве зависимостей две внешних зависимости (appcompat и guava), а также две проектных зависимости (first и second), которые в свою очередь используют библиотеку jsontoken версий 1.0 и 1.1 как внешнюю зависимость. Совершенно очевидно, что проект не может содержать две версии одной библиотеки в Classpath, да и нет в этом необходимости. На этом этапе Gradle включает модуль разрешения конфликтов.

Разрешение конфликтов

Gradle DSL содержит компонент, используемый для разрешения конфликтов зависимостей. Если посмотреть на зависимости библиотеки jsontoken на приведённом выше дереве зависимостей, то мы увидим их только раз. Для модуля second зависимости библиотеки jsontoken не указаны, а вывод самой зависимости содержит дополнительно ‘–> 1.1’, что говорит о том, что версия библиотеки 1.0 не используется, а автоматически была заменена на версию 1.1 с помощью Gradle-модуля разрешения конфликтов.

Для объяснения каким образом была разрешена конфликтная ситуация, также можно воспользоваться Gradle-таском dependencyInsight, например:



Стоит обратить внимание, что версия 1.1 выбирается в результате conflict resolution, также возможен выбор в результате других правил (например: selected by force или selected by rule). В статье будут приведены примеры использования правил, влияющих на стратегию разрешения зависимостей, и выполнив таск dependencyInsight вы сможете увидеть причину выбора конкретной версии библиотеки на каждом из приведённых ниже этапов. Для этого при переходе на каждый этап вы можете самостоятельно выполнить таск dependencyInsight.

При необходимости есть возможность переопределить логику работы Gradle-модуля разрешения конфликтов, например, указав Gradle падать при выявлении конфликтов во время конфигурирования проекта. (состояние 1)

// build.gradle
// …
configurations.compile.resolutionStrategy {
	failOnVersionConflict()
}

После чего даже при попытке построить дерево зависимостей Gradle таски будут прерываться по причине наличия конфликта в зависимостях приложения.



У задачи есть четыре варианта решения:

Первый вариант – удалить строки, переопределяющие стратегию разрешения конфликтов.

Второй вариант – добавить в стратегию разрешения конфликтов правило обязательного использования библиотеки jsonToken, с указанием конкретной версии (состояние 2):

// build.gradle
// …
configurations.compile.resolutionStrategy {
	force 'com.googlecode.jsontoken:jsontoken:1.1'
	failOnVersionConflict()
}

При применении этого варианта решения дерево зависимостей будет выглядеть следующим образом:



Третий вариант — добавить библиотеку jsonToken явно в качестве зависимости для проекта app и присвоить зависимости параметр force, который явно укажет, какую из версий библиотеки стоит использовать. (состояние 3)

// build.gradle
// …
dependencies {
	compile fileTree(dir: 'libs', include: ['*.jar'])
	compile 'com.android.support:appcompat-v7:23.1.1'
	compile 'com.google.guava:guava:+'
	compile project(":first")
	compile project(":second")
	compile ('com.googlecode.jsontoken:jsontoken:1.1') {
		force = true
	}
}

А дерево зависимостей станет выглядеть следующим образом:



Четвёртый вариант – исключить у одной из проектных зависимостей jsontoken из собственных зависимостей с помощью параметра exclude. (состояние 4)

// build.gradle
dependencies {
	compile fileTree(dir: 'libs', include: ['*.jar'])
	compile 'com.android.support:appcompat-v7:23.1.1'
	compile 'com.google.guava:guava:+'
	compile project(":first")
	compile(project(":second")) {
		exclude group: "com.googlecode.jsontoken", module: 'jsontoken'
	}
}

И дерево зависимостей станет выглядеть следующим образом:



Стоит отметить, что exclude не обязательно передавать оба параметра одновременно, можно использовать только один.

Но несмотря на правильный вывод дерева зависимостей, при попытке собрать приложение Gradle вернёт ошибку:



Причину ошибки можно понять из вывода сообщений выполнения задачи сборки — класс GwtCompatible с идентичным именем пакета содержится в нескольких зависимостях. И это действительно так, дело в том, что проект app в качестве зависимости использует библиотеку guava, а библиотека jsontoken использует в зависимостях устаревшую Google Collections. Google Collections входит в Guava, и их совместное использование в одном проекте невозможно.

Добиться успешной сборки проекта можно тремя вариантами:

Первый — удалить guava из зависимостей модуля app. Если используется только та часть Guava, которая содержится в Google Collections, то предложенное решение будет неплохим.

Второй — исключить Google Collections из модуля first. Добиться этого мы можем используя описанное ранее исключение или правила конфигураций. Рассмотрим оба варианта, сначала используя исключения (состояние 5)

// build.gradle
dependencies {
	compile fileTree(dir: 'libs', include: ['*.jar'])
	compile 'com.android.support:appcompat-v7:23.1.1'
	compile 'com.google.guava:guava:+'
	compile(project(":first")) {
		exclude module: 'google-collections'
	}
	compile(project(":second")) {
		exclude group: "com.googlecode.jsontoken", module: 'jsontoken'
	}
}

Пример использования правил конфигураций (состояние 6):

//build.gradle
configurations.all {
	exclude group: 'com.google.collections', module: 'google-collections'
}

dependencies {
	compile fileTree(dir: 'libs', include: ['*.jar'])
	compile 'com.android.support:appcompat-v7:23.1.1'
	compile 'com.google.guava:guava:+'
	compile project(":first")
	compile(project(":second")) {
		exclude group: "com.googlecode.jsontoken", module: 'jsontoken'
	}
}

Дерево зависимостей для обеих реализаций исключения Google Collections будет идентично.



Третий вариант — использовать функционал подмены модулей (состояние 7):

// build.gradle
dependencies {
	modules {
		module('com.google.collections:google-collections') {
			replacedBy('com.google.guava:guava')
		}
	}

	compile fileTree(dir: 'libs', include: ['*.jar'])
	compile 'com.android.support:appcompat-v7:23.1.1'
	compile 'com.google.guava:guava:+'
	compile project(":first")
	compile(project(":second")) {
		exclude group: "com.googlecode.jsontoken", module: 'jsontoken'
	}
}

Дерево зависимостей будет выглядеть следующим образом:



Нужно учесть, что если оставить предопределенную логику разрешения конфликтов, которая указывает прерывать сборку при наличии любого конфликта, то выполнение любого таска будет прерываться на этапе конфигурации. Другими словами, использование правил замены модулей является одним из правил стратегии разрешения конфликтов между зависимостями.

Также важно заметить, что последний из озвученных вариантов является самым гибким, ведь при удалении guava из списка зависимостей Gradle, Google Collections сохранится в проекте, и функционал, от него зависящий, сможет продолжить выполнение. А дерево зависимостей будет выглядеть следующим образом:



После каждого из вариантов мы достигнем успеха в виде собранного и запущенного приложения.

Но давайте рассмотрим другую ситуацию (состояние 8), у нас одна единственная сильно урезанная (для уменьшения размеров скриншотов) динамическая зависимость wiremock. Мы её используем сугубо в целях обучения, представьте вместо неё библиотеку, которую поставляет ваш коллега, он может выпустить новую версию в любой момент, и вам непременно необходимо использовать самую последнюю версию:

// build.gradle
configurations.all {
	exclude group: 'org.apache.httpcomponents', module: 'httpclient'
	exclude group: 'org.json', module: 'json'
	exclude group: 'org.eclipse.jetty'
	exclude group: 'com.fasterxml.jackson.core'
	exclude group: 'com.jayway.jsonpath'
}

dependencies {
	compile 'com.github.tomakehurst:wiremock:+'
}

Дерево зависимостей выглядит следующим образом:



Как вы можете увидеть, Gradle загружает последнюю доступную версию wiremock, которая является beta. Ситуация нормальная для debug сборок, но если мы собираемся предоставить сборку пользователям, то нам определённо необходимо использовать release-версию, чтобы быть уверенными в качестве приложения. Но при этом в связи с постоянной необходимостью использовать последнюю версию и частыми релизами нет возможности отказаться от динамического указания версии wiremock. Решением этой задачи будет написание собственных правил стратегии выбора версий зависимости:

// build.gradle
//…
configurations.all {
	//…
	resolutionStrategy {
		componentSelection {
			all { selection ->
				if (selection.candidate.version.contains('alpha')
					|| selection.candidate.version.contains('beta')) {
						selection.reject("rejecting non-final")
				}
			}
		}
	}
}

Стоит отменить, что данное правило применится ко всем зависимостям, а не только к wiremock.
После чего, запустив задачу отображения дерева зависимостей в информационном режиме, мы увидим, как отбрасываются beta-версии библиотеки, и причину, по которой они были отброшены. В конечном итоге будет выбрана стабильная версия 1.58:



Но при тестировании было обнаружено, что в версии 1.58 присутствует критичный баг, и сборка не может быть выпущена в таком состоянии. Решить эту задачу можно, написав ещё одно правило выбора версии зависимости:

// build.gradle
//…
configurations.all {
	//…
	resolutionStrategy {
		componentSelection {
			// …
			withModule('com.github.tomakehurst:wiremock') { selection ->
				if (selection.candidate.version == "1.58") {
					selection.reject("known bad version")
				}
			}
		}
	}
}

После чего версия wiremock 1.58 будет также отброшена, и начнёт использоваться версия 1.57, а дерево зависимостей будет выглядеть следующим образом:

Заключение

Несмотря на то, что статья получилась достаточно объемной, тема Dependency Management в Gradle содержит много не озвученной в рамках этой статьи информации. Глубже погрузиться в этот мир лучше всего получится с помощью официального User Guide в паре с документацией по Gradle DSL, в изучение которых придется инвестировать немало времени.

Зато в результате вы получите возможность сэкономить десятки часов, как благодаря автоматизации, так и благодаря пониманию того, что необходимо делать при проявлении различных багов. Например, в последнее время достаточно активно проявляются баги с 65К-методов и Multidex, но благодаря грамотному просмотру зависимостей и использованию exclude проблемы решаются очень быстро.

Читайте также: Gradle: 5 полезностей для разработчика