Введение в Java Maven

Maven — это стандартный инструмент автоматизации сборки и управления зависимостями для Java. Он превращает проект в декларативное описание — что он представляет собой, от чего зависит, как собирается — и затем выполняет сборку за вас. Вместо ручного управления JAR-файлами и флагами javac вы объявляете свои потребности в одном файле, и Maven загружает зависимости, компилирует, тестирует и упаковывает ваш код через предсказуемый, повторяемый жизненный цикл.

POM: проект как данные

Каждый проект Maven описывается файлом pom.xml (Project Object Model). Он идентифицирует проект тремя координатами — groupId, artifactId и version (вместе «GAV») — и перечисляет нужные ему библиотеки. Та же схема координат именует ваш проект и каждую зависимость, и именно так Maven находит артефакты в репозитории.

<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>
  <artifactId>shop-app</artifactId>
  <version>1.0.0</version>
  <packaging>jar</packaging>

  <properties>
    <maven.compiler.release>21</maven.compiler.release>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>6.1.0</version>
    </dependency>
  </dependencies>
</project>

Элемент <packaging> сообщает Maven, что производить (jar, war, pom). Блок <properties> хранит переиспользуемые значения — здесь релиз Java, на который нацелен компилятор.

Зависимости и транзитивный classpath

Вы перечисляете только свои прямые зависимости. Maven читает собственный POM каждой зависимости и подтягивает всё, что нужно им — транзитивные зависимости — автоматически выстраивая полный classpath. Объявление spring-web также привносит spring-core, хотя вы его не называли.

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.17.0</version>
</dependency>

У каждой зависимости есть scope (область видимости), который определяет, когда она находится в classpath. Значение по умолчанию compile делает её доступной везде; test ограничивает её тестовым кодом; provided означает, что её предоставляет среда выполнения.

Scope	В compile-classpath	В test-classpath	Упакована	Типичное применение
`compile` (по умолчанию)	Да	Да	Да	Обычные библиотеки
`provided`	Да	Да	Нет	Servlet API, предоставляется в среде выполнения
`runtime`	Нет	Да	Да	Драйверы JDBC
`test`	Нет	Да	Нет	JUnit, Mockito

Жизненный цикл сборки

Сборки Maven проходят через фиксированную последовательность фаз. Ключевые фазы стандартного жизненного цикла — это validate, compile, test, package, verify, install и deploy. Запуск фазы выполняет каждую фазу перед ней — mvn package сначала валидирует, компилирует и тестирует, затем упаковывает. Вы никогда не вызываете фазы вне порядка.

mvn compile          # скомпилировать основные исходники
mvn test             # компиляция + запуск юнит-тестов
mvn package          # компиляция + тесты + сборка JAR/WAR
mvn install          # упаковка + копирование артефакта в ваш локальный репозиторий
mvn clean package    # сначала удалить target/, затем собрать с нуля

Каждая фаза привязана к одной или нескольким целям (goals), предоставляемым плагинами (например, compiler:compile привязана к фазе compile). В плагинах живёт фактическая работа; жизненный цикл лишь упорядочивает её.

Репозитории

Maven получает артефакты из репозиториев. При сборке он сначала смотрит в ваш локальный репозиторий (~/.m2/repository), кэш на вашей машине. При промахе он загружает из удалённого репозитория — по умолчанию Maven Central — и сохраняет копию локально, чтобы следующая сборка была быстрой и офлайн. Команды часто добавляют приватный репозиторий для внутренних библиотек.

pom.xml проекта  →  локальный репо (~/.m2)  →  удалённый репо (Maven Central)
                    (попадание в кэш?)          (загрузка + кэширование)

Запускаемый пример

В исполнителе кода нет Maven в classpath, поэтому программа ниже моделирует основную механику Maven обычным кодом JDK: она хранит крошечный POM как map, разрешает транзитивное замыкание зависимостей (устраняя дубликаты общих артефактов) и проходит по жизненному циклу сборки, останавливаясь на запрошенной фазе. Формы здесь — координаты GAV, транзитивное разрешение, упорядоченные фазы — это в точности то, что делает настоящий Maven.

java— editable, runs on the server

import java.util.*;

public class Main {
    // A coordinate triple, exactly like Maven's groupId:artifactId:version.
    record Gav(String groupId, String artifactId, String version) {
        @Override public String toString() {
            return groupId + ":" + artifactId + ":" + version;
        }
        String jar() { return artifactId + "-" + version + ".jar"; }
    }

// The project model: each artifact mapped to the dependencies it declares.
    static final Map<String, List<Gav>> pom = new LinkedHashMap<>();

static void declare(Gav a, Gav... deps) { pom.put(a.toString(), List.of(deps)); }

// Build the transitive closure the way Maven resolves a classpath.
    static void resolve(Gav a, Set<String> seen, List<Gav> out) {
        for (Gav d : pom.getOrDefault(a.toString(), List.of())) {
            if (seen.add(d.toString())) {   // de-dupe: each JAR appears once
                out.add(d);
                resolve(d, seen, out);      // then pull in its own dependencies
            }
        }
    }

public static void main(String[] args) {
        Gav app     = new Gav("com.example", "shop-app", "1.0.0");
        Gav web     = new Gav("org.springframework", "spring-web", "6.1.0");
        Gav core    = new Gav("org.springframework", "spring-core", "6.1.0");
        Gav jackson = new Gav("com.fasterxml.jackson.core", "jackson-databind", "2.17.0");
        Gav annot   = new Gav("com.fasterxml.jackson.core", "jackson-annotations", "2.17.0");

declare(app, web, jackson);   // our project's direct dependencies
        declare(web, core);           // spring-web transitively needs spring-core
        declare(jackson, annot);      // jackson-databind needs jackson-annotations
        declare(core);
        declare(annot);

System.out.println("Project coordinates: " + app);
        System.out.println("Direct dependencies:");
        for (Gav d : pom.get(app.toString())) System.out.println("  - " + d);

List<Gav> classpath = new ArrayList<>();
        resolve(app, new HashSet<>(), classpath);
        System.out.println("Resolved classpath has " + classpath.size() + " JARs:");
        for (Gav g : classpath) System.out.println("  - " + g.jar());

List<String> phases = List.of("validate", "compile", "test", "package", "install");
        String goal = "package";
        System.out.println("Executing: mvn " + goal);
        for (String p : phases) {
            System.out.println("  phase " + p + " -> OK");
            if (p.equals(goal)) break;   // stop once the requested phase is reached
        }
        System.out.println("BUILD SUCCESS");
    }
}

Что вынести из запуска:

Проект и каждая зависимость именуются одним и тем же тройным GAV, поэтому Project coordinates: com.example:shop-app:1.0.0 читается ровно как строка зависимости.
Объявлены только две зависимости, но разрешённый classpath содержит четыре JAR — spring-core и jackson-annotations были подтянуты транзитивно, ровно как делает Maven.
Множество seen гарантирует, что каждый артефакт появляется один раз; это и есть дедупликация Maven, которая не даёт общей библиотеке оказаться в classpath дважды.
Executing: mvn package выполняет validate, compile и test перед package и затем останавливается — запуск фазы всегда выполняет каждую предыдущую фазу по порядку.
Сборка останавливается на package и никогда не доходит до install, отражая то, как запрошенная цель ограничивает, насколько далеко продвигается жизненный цикл.

Практика

Что происходит в Maven, когда вы запускаете 'mvn package'?

Maven выполняет каждую более раннюю фазу жизненного цикла (validate, compile, test) и затем упаковывает артефакт
Maven выполняет только фазу package и пропускает компиляцию и тесты
Maven развёртывает артефакт в удалённый репозиторий
Maven загружает JDK перед сборкой