К содержимому
Войти

Java Road Map

🏗️ Maven и Gradle

Maven и Gradle решают одну задачу: скачать зависимости, скомпилировать код, прогнать тесты и собрать артефакт, который поедет в образ. На работе о сборке вспоминают, когда в рантайме вылетает NoSuchMethodError из-за транзитивной зависимости не той версии. Чтобы разобраться с этим за минуты, а не за день, нужны пять вещей: жизненный цикл, scope, правила выбора версий, BOM и устройство jar Spring Boot

🧠 Как это устроено

Maven: жизненный цикл, фазы и goals

Maven описывает проект декларативно в pom.xml: координаты, зависимости, плагины. Работу делают плагины, а их goals привязаны к фазам жизненного цикла

Встроенных жизненных цикла три: clean, default и site. Главные фазы default идут строго по порядку:

  1. validate — pom корректен
  2. compile — compiler:compile компилирует src/main/java
  3. test — surefire:test гоняет юнит-тесты
  4. package — jar:jar собирает jar в target/
  5. verify — проверки поверх артефакта: интеграционные тесты через failsafe, enforcer
  6. install — кладёт артефакт в локальный репозиторий ~/.m2/repository
  7. deploy — отправляет артефакт в удалённый репозиторий, например Nexus или Artifactory

Запуск фазы выполняет все фазы до неё: mvn package пройдёт компиляцию и тесты и соберёт jar. mvn install сделает то же и скопирует jar в ~/.m2 для соседних проектов на этой машине, mvn deploy загрузит его в удалённый репозиторий

Gradle: граф тасков и Kotlin DSL

В Gradle сборка — это программа на Kotlin DSL (build.gradle.kts) или Groovy, которая строит граф тасков. ./gradlew build выполнит compileJava, test, jar, check и всё, от чего они зависят, причём таски с неизменившимися входами пропустит (UP-TO-DATE) или возьмёт результат из кэша сборки. Поэтому на большом проекте повторная сборка Gradle заметно быстрее, зато Maven проще читать

MavenGradle
Описание сборкиXML, декларативноKotlin или Groovy DSL, код
Модельфиксированный жизненный цикл с фазамиграф тасков
Инкрементальностьслабая, обычно пересобирается модуль целикомпропуск неизменившихся тасков, кэш сборки
Конфликт версийближайшая к проекту версиясамая высокая версия

В Gradle 9 демону сборки нужна Java 17 или новее. Собирать код под более старую Java можно через toolchains: Gradle сам найдёт или скачает нужный JDK. Configuration cache Gradle 9 называет предпочтительным режимом, но по умолчанию он выключен: org.gradle.configuration-cache=true в gradle.properties. Архивы Jar и Zip с Gradle 9 по умолчанию воспроизводимы побайтово

Scope в Maven и конфигурации в Gradle

Scope решает, на каком classpath нужна зависимость и уйдёт ли она дальше к тем, кто подключит твой модуль

Maven scopeGradleКомпиляцияРантаймТестыТранзитивно
compile (по умолчанию)implementation или apiдададада
providedcompileOnlyданетданет
runtimeruntimeOnlyнетдадада, как runtime
testtestImplementationтолько тестынетданет

provided — то, что даст окружение: Servlet API в Tomcat, Lombok, который нужен только компилятору. runtime — то, что код не импортирует напрямую, но без чего не запустится: JDBC-драйвер Postgres, реализация логгера

implementation против api. Модулю обе доступны везде, разница в том, что видят его потребители. Зависимость из api попадает на их compile classpath, из implementation — только на runtime. Документация Gradle советует по умолчанию implementation, а в api класть типы из публичного контракта: параметры публичных методов, суперклассы. Конфигурация api есть только с плагином java-library, у обычного java её нет

Конфликт версий транзитивных зависимостей

Библиотеке A нужен Jackson 2.17, библиотеке B — 2.19. На classpath окажется одна версия, и выбирают её по-разному

Maven берёт ближайшую. Он строит дерево и выбирает версию, которая ближе всего к корню. Если на одной глубине их две, выигрывает объявленная первой. Так можно получить версию старше, чем нужна одной из библиотек, просто потому что путь к ней короче. Код скомпилируется, а в рантайме упадёт с NoSuchMethodError. Версия в <dependencyManagement> главнее этой логики: она применяется ко всем транзитивным вхождениям

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

Найти виновника:

  • mvn dependency:tree -Dincludes=com.fasterxml.jackson.core — дерево по группе, с -Dverbose видны и вытесненные версии
  • ./gradlew dependencies --configuration runtimeClasspath — дерево конфигурации, 1.6 -> 1.7 значит «запросили 1.6, выбрана 1.7»
  • ./gradlew dependencyInsight --dependency jackson-databind --configuration runtimeClasspath — кто и почему притащил эту версию

Чинят тремя способами: прибивают версию в dependencyManagement или через BOM, исключают лишнюю транзитивную зависимость через exclusions в Maven или exclude(group = ..., module = ...) в Gradle, либо обновляют библиотеку со старьём. Правило dependencyConvergence из maven-enforcer-plugin роняет сборку, если одна зависимость встречается в дереве в разных версиях

BOM и как Spring Boot управляет версиями

BOM (bill of materials) — pom, в котором есть только <dependencyManagement>: список согласованных версий без самих зависимостей. Подключил BOM, и зависимости пишешь без версий, а его версии действуют и на транзитивные вхождения. spring-boot-dependencies — такой BOM на сотни библиотек, проверенных командой Boot вместе: Jackson, Hibernate, драйверы, Testcontainers

В Maven подключить его можно двумя способами:

  • spring-boot-starter-parent как parent. Кроме версий даёт настройки сборки: Java 17 как уровень компиляции по умолчанию, UTF-8, флаг -parameters, фильтрацию application.yml с плейсхолдерами @..@, готовую execution repackage. Версию отдельной библиотеки переопределяешь свойством, например <slf4j.version>
  • Импорт BOM в <dependencyManagement> со <scope>import</scope> и <type>pom</type>, когда parent занят корпоративным. Даёт только версии: плагины, кодировку и repackage настраиваешь сам. Свойства не работают, переопределяешь своей записью в dependencyManagement выше импорта Boot

В Gradle тоже два пути: плагин io.spring.dependency-management со свойствами как в Maven или встроенный platform(SpringBootPlugin.BOM_COORDINATES), который, по документации Boot, скорее всего, быстрее. platform считает версии BOM рекомендацией: если в графе есть версия выше, победит она. enforcedPlatform делает их обязательными

Многомодульный проект

Корневой pom с <packaging>pom</packaging> перечисляет <modules> и отдаёт им общие dependencyManagement и pluginManagement. Maven строит реактор: сортирует модули по зависимостям и собирает по порядку, соседний модуль он видит без install. mvn -pl api -am package соберёт api и всё, от чего он зависит. В Gradle модули перечисляют в settings.gradle.kts через include("api", "core"), связывают через implementation(project(":core")), общую настройку выносят в convention-плагины, а версии — в каталог gradle/libs.versions.toml

🛠️ На практике

Минимальный build.gradle.kts сервиса на Spring Boot 4.1 с нативным BOM:

import org.springframework.boot.gradle.plugin.SpringBootPlugin

plugins {
    java
    id("org.springframework.boot") version "4.1.2"
}

java {
    toolchain { languageVersion = JavaLanguageVersion.of(21) }
}

dependencies {
    implementation(platform(SpringBootPlugin.BOM_COORDINATES))
    implementation("org.springframework.boot:spring-boot-starter-webmvc")
    compileOnly("org.projectlombok:lombok")
    annotationProcessor(platform(SpringBootPlugin.BOM_COORDINATES))
    annotationProcessor("org.projectlombok:lombok")
    runtimeOnly("org.postgresql:postgresql")

    testImplementation("org.springframework.boot:spring-boot-starter-webmvc-test")
}

platform действует только на свою конфигурацию и наследников. Тесты наследуют от implementation, а annotationProcessor — нет, поэтому для Lombok там отдельная строка с platform. Плагин io.spring.dependency-management применяет BOM ко всем конфигурациям сразу

Maven · Импорт BOM и исключение транзитивной зависимости

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>4.1.2</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.example</groupId>
    <artifactId>legacy-client</artifactId>
    <version>1.4.0</version>
    <exclusions>
      <!-- клиент тащит свой логгер, у нас уже есть logback -->
      <exclusion>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
      </exclusion>
    </exclusions>
  </dependency>
</dependencies>

<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <version>4.1.2</version>
      <executions>
        <!-- без parent repackage сам не включится -->
        <execution>
          <goals><goal>repackage</goal></goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

Wrapper

Wrapper — скрипт mvnw или gradlew в корне репозитория, который скачивает нужную версию сборщика и запускает её. Версия записана в .mvn/wrapper/maven-wrapper.properties или gradle/wrapper/gradle-wrapper.properties в поле distributionUrl. Его коммитят, чтобы все и CI собирали одной версией, а обновление сборщика проходило ревью, как любое изменение

Коммитят gradlew, gradlew.bat и обе части gradle/wrapper/, включая gradle-wrapper.jar. Maven Wrapper по умолчанию ставится в режиме only-script: jar не нужен, скрипт скачивает Maven через curl или wget. Обновить: ./gradlew wrapper --gradle-version 9.9.1 или mvn wrapper:wrapper -Dmaven=3.10.0. С distributionSha256Sum подменённый дистрибутив роняет сборку

Fat jar Spring Boot

Обычный jar содержит только классы твоего модуля, и без длинного -cp его не запустить. Fat jar Spring Boot кладёт внутрь всё:

app.jar
├── META-INF/MANIFEST.MF          Main-Class: org.springframework.boot.loader.launch.JarLauncher
│                                 Start-Class: com.example.Application
├── org/springframework/boot/loader/   загрузчик Boot
└── BOOT-INF/
    ├── classes/                  твои классы и application.yml
    ├── lib/                      зависимости как вложенные jar
    ├── classpath.idx             порядок jar на classpath
    └── layers.idx                раскладка по слоям

java -jar запускает JarLauncher. Стандартный classloader не читает jar внутри jar, поэтому Boot ставит свой и затем вызывает main из Start-Class

В Maven это делает goal spring-boot:repackage: он берёт jar после package, перепаковывает его, а исходный переименовывает в .original. В Gradle таск bootJar собирает исполняемый архив, а обычный jar продолжает работать с классификатором plain, так что в build/libs лежат два файла. Если -plain.jar мешает, например COPY build/libs/*.jar ловит оба, отключи таск jar

Слоистый jar включён по умолчанию: layers.idx делит содержимое на dependencies, spring-boot-loader, snapshot-dependencies и application. Зависимости меняются редко, код — в каждом коммите, и в образе с такими слоями пересобирается только тонкий верхний. Как разложить слои по Dockerfile, разобрано на странице «Java в контейнере»

Воспроизводимая сборка в CI

# Maven: без интерактива, без прогресс-бара загрузок, полный прогон до verify
./mvnw -B -ntp verify

# Gradle: зависимости уже в кэше, сеть не нужна
./gradlew build --offline
  • Wrapper, -B и -ntp. Версия сборщика из репозитория, без интерактивных вопросов и прогресса загрузки в логе
  • verify, а не install. verify прогоняет всё, включая интеграционные тесты и enforcer. install вдобавок пишет артефакты в ~/.m2, и если кэш общий для раннера, другая ветка подхватит твой 1.0-SNAPSHOT вместо своего
  • Кэш зависимостей: ~/.m2/repository для Maven, ~/.gradle/caches и ~/.gradle/wrapper для Gradle, ключ — хеш pom.xml или *.gradle.kts и gradle.lockfile
  • Lock-файлы Gradle. dependencyLocking { lockAllConfigurations() } и ./gradlew dependencies --write-locks записывают точные версии в gradle.lockfile. Другая версия при резолве роняет сборку
  • --offline (у Maven -o) проверяет, что всё нужное уже в кэше и сборка не ходит в сеть
  • Версии плагинов Maven прибиты в pom. Без этого Maven берёт версии по умолчанию своей сборки, и смена Maven на раннере меняет плагины

⚠️ Где ошибаются

  • Объявляют всё через compile или implementation. С драйвером на compile classpath код может случайно импортировать org.postgresql.*, а JUnit без test уезжает в продовый jar. Драйверу место в runtime/runtimeOnly, тестовым библиотекам в test/testImplementation
  • Ставят версию прямо в зависимость при подключённом BOM, чтобы «починить» конфликт. Модули одного семейства, например Jackson, разъезжаются по версиям, и в рантайме падает NoSuchMethodError. Обновляй семейство целиком через его BOM или свойство
  • Собирают в CI системным mvn. Локально Maven одной версии, в CI другой, и сборка падает только там
  • Импортируют BOM без parent и забывают execution repackage. mvn package собирает тонкий jar, и контейнер падает на старте с no main manifest attribute

🎯 Вопросы с собеседований

Maven или Gradle, в чём разница?

Maven декларативный: XML, фиксированный жизненный цикл с фазами, к которым плагины привязывают goals. Gradle — сборка как код на Kotlin или Groovy DSL, граф тасков с инкрементальностью и кэшем сборки, поэтому на больших проектах он быстрее. Конфликт версий Maven решает по ближайшей к проекту зависимости, Gradle берёт самую высокую

Что такое жизненный цикл Maven и чем package отличается от install и deploy?

Жизненный цикл default — упорядоченные фазы: validate, compile, test, package, verify, install, deploy. Запуск фазы выполняет все предыдущие. package собирает jar в target/, install вдобавок кладёт его в ~/.m2 для других проектов на этой машине, deploy — в удалённый репозиторий вроде Nexus для всех остальных

Какие scope зависимостей есть в Maven?

compile по умолчанию: нужна везде и передаётся транзитивно. provided нужна для компиляции, а в рантайме её даст окружение, как Servlet API, и дальше она не передаётся. runtime нужна только при запуске, как JDBC-драйвер. test видна только тестам. Ещё есть import для BOM и устаревший system

Как решается конфликт версий транзитивных зависимостей и как его найти?

Maven выбирает версию, ближайшую к корню дерева, а при равной глубине — объявленную первой, так что можно получить версию старее нужной. Gradle выбирает самую высокую из запрошенных. Найти: mvn dependency:tree -Dverbose или ./gradlew dependencyInsight --dependency .... Чинят версией в dependencyManagement или BOM, исключением или обновлением библиотеки. Заранее ловит правило dependencyConvergence у enforcer

Что такое BOM и как Spring Boot управляет версиями?

BOM — pom только с dependencyManagement: согласованный набор версий без самих зависимостей. Spring Boot публикует spring-boot-dependencies с версиями, которые проверены вместе. Подключают его как spring-boot-starter-parent, который заодно настраивает Java, кодировку и repackage, или импортом со scope import, если parent занят. С parent версию переопределяют свойством, с импортом — своей записью выше импорта. В Gradle — плагин io.spring.dependency-management или platform()

Чем implementation отличается от api в Gradle?

Зависимость из api попадает на compile classpath потребителей модуля, а из implementation — только на их runtime classpath. implementation предпочтительнее: потребители не завязываются на твои внутренности и не перекомпилируются при их смене. В api кладут типы из публичного контракта. api доступна с плагином java-library

Зачем нужен wrapper и зачем его коммитить?

mvnw или gradlew скачивают версию сборщика, записанную в репозитории, и запускают её. Все разработчики и CI собирают одной версией, а её обновление проходит ревью. Для защиты от подмены в properties добавляют distributionSha256Sum

Что внутри fat jar Spring Boot и чем он отличается от обычного?

Обычный jar содержит только классы модуля. В fat jar Boot классы лежат в BOOT-INF/classes, зависимости — вложенными jar в BOOT-INF/lib, а в корне загрузчик Boot. В манифесте Main-Class — это JarLauncher, а твой класс с main указан в Start-Class. Лаунчер ставит свой classloader, который умеет читать jar внутри jar. Собирают его spring-boot:repackage в Maven и bootJar в Gradle

📚 Что почитать