Время на прочтение
6 мин
Количество просмотров 528K
После публикации топика о Maven в комментариях возникли вопросы о том, как начать с ним работать, с чего начать, как составлять файлы pom.xml, откуда брать плагины и т.п. Данный топик будет своего рода getting started или f.a.q.
Терминология
Как в любой системе, в Maven, есть свой набор терминов и понятий.
Вся структура проекта описывается в файле pom.xml (POM – Project Object Model), который должен находиться в корневой папке проекта. Ключевым понятием Maven является артефакт — это, по сути, любая библиотека, хранящаяся в репозитории. Это может быть какая-то зависимость или плагин.
Зависимости — это те библиотеки, которые непосредственно используются в вашем проекте для компиляции кода или его тестирования.
Плагины же используются самим Maven’ом при сборке проекта или для каких-то других целей (деплоймент, создание файлов проекта для Eclipse и др.).
В самом начале работы с Maven, пользователь непременно столкнется с таким понятием как архетип. Архетип — это некая стандартная компоновка файлов и каталогов в проектах различного рода (веб, swing-проекты и прочие). Другими словами, Maven знает, как обычно строятся проекты и в соответствии с архетипом создает структуру каталогов.
Как правило, название артефакта состоит из названия группы, собственного названия и версии. К примеру Spring будет иметь вот такое название в среде Maven: org.springframework.spring:2.5.5. Последний домен означает всегда artifactId, все, что перед ним – groupId – хорошо это запомните!
На жизненном цикле останавливаться не буду, так как он хорошо описан в вышеобозначенной статье. А теперь перейдем к практике.
Установка Maven
Последнюю версию всегда можно скачать на странице загрузки на официальном сайте. Просто распаковываем архив в любую директорию. Далее необходимо создать переменную в Path, в которой необходимо указать путь к Maven. Заходим в Win + Pause – Дополнительно – Переменные среды – в верхнем окошке нажимаем Создать, вводим имя M2_HOME и значение допустим “C:\apache-maven-2.2.1”. Далее там же создаем еще одну переменную M2 со значением %M2_HOME%\bin. Так же убеждаемся, что есть переменная JAVA_HOME с путем к JDK. Ее значение должно быть примерно таким «c:\Program Files\Java\jdk1.6.0_10\». И наконец в том же окошке создаем/модифицируем переменную Path, в нее необходимо просто написать %M2%, чтобы наша папочка с исполняемым файлом Maven была видна из командной строки. Теперь необходимо проверить работоспособность нашей установки. Для этого заходим в командную строку и вводим команду
mvn –version
Должна появиться информация о версиях Maven, jre и операционной системе, что-то вроде:
Maven version: 2.2.1 Java version: 1.6.0_10 OS name: "windows 2003" version: "5.2" arch: "x86" Family: "windows"
Maven создаст вам локальный репозиторий в вашей личной папке, например в каталоге C:\Documents and Settings\username\.m2\repository
Все, Maven готов к работе, можно приступать к созданию приложения.
Создание приложения из архетипа
На сайте Maven перечислены наиболее популярные архетипы для приложений, но вы можете легко создать свой или найти более специфичный например здесь.
Итак, допустим нас интересует веб-приложение – находим подходящий архетип, называется он maven-archetype-webapp. В командной строке, в необходимом каталоге выполняем команду Maven:
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-webapp -DarchetypeArtifactId=maven-archetype-webapp
Теперь мы можем лицезреть довольно наглядную структуру каталогов с говорящими названиями java – здесь будут ваши классы, webapp – здесь размещаются странички веб-приложения, resources – различного рода ресурсы в classpath (файлы конфигурации, например), test – юнит-тесты, соответственно и т.п.
Сборка проекта
Здесь все просто – выполняем команду
mvn package
или
mvn install
в корневом каталоге приложения, там, где находится файл pom.xml. Первая команда скомпилирует ваш проект и поместит его в папку target, а вторая еще и положит его к вам в локальный репозиторий.
Есть полезная функция, наподобие конвеера, то есть можно написать
mvn clean install
и Maven сначала очистит папку target проекта, потом соберет его и положит в репозиторий.
Минимальный набор действий для работы Maven мы изучили, теперь переходим к кастомизации и добавлению зависимостей проекта.
Зависимости и репозитории
Как правило, большинство популярных библиотек находятся в центральном репозитории, поэтому их можно прописывать сразу в раздел dependencies вашего pom-файла. Например чтобы подключить Spring Framework необходимо определить следующую зависимость:
<dependencies> ... <dependency> <groupId>org.springframework</groupId> <artifactId>spring</artifactId> <version>2.5.5</version> </dependency> </dependencies>
Версию хотя и можно не указывать и тогда Maven возьмет последний вариант, но я вам лично советую это делать, потому как у нас неоднократно бывали случаи, что проект просто в один момент переставал собираться или начинал падать в совершенно неожиданных и хорошо оттестированных местах, хотя вроде бы никто ничего не менял.
Специфические вещи обычно не находятся в центральном репозитории и тогда вам придется указать репозиторий производителя вручную. Для примера добавим зависимость JSF-фреймворка ajax-компонентов JBoss RichFaces.
С зависимостями все просто:
<dependencies> <dependency> <groupId>org.richfaces.ui</groupId> <artifactId>richfaces-ui</artifactId> <version>3.3.1.GA</version> </dependency> </dependencies>
А вот репозиторий JBoss теперь необходимо прописать ручками либо в файле settings.xml, который лежит в корне вашего локального репозитория, либо в самом файле pom.xml, в зависимости от того, нужен ли данный репозиторий во всех проектах, либо в каком-то одном конкретном, соответственно:
<!-- JBoss RichFaces Repository --> <repositories> <repository> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> <updatePolicy>never</updatePolicy> </snapshots> <id>repository.jboss.com</id> <name>Jboss Repository for Maven</name> <url> http://repository.jboss.com/maven2/ </url> <layout>default</layout> </repository> </repositories>
Как правило на сайтах крупных проектов пишут всю информацию, необходимую для встраивания их библиотеки в проект на основе Maven, но бывают случаи, когда артефакт приходится искать очень и очень долго. Здесь нам очень сильно может помочь MVNrepository.com — он вам всегда подскажет где может находиться искомая библиотечка. Но если уж и там не нашлось, то из собственного опыта могу посоветовать гуглить «<название библиотеки> pom.xml». Бывает так, что проекты уже давно закрыты и в репозитории не положены потому что разработчики уже не заботятся об их распространении. Тогда остается один единственный способ – добавить файл в репозиторий вручную командой:
mvn install:install-file -Dfile=<path-to-file> -DgroupId=<group-id> -DartifactId=<artifact-id> -Dversion=<version> -Dpackaging=<packaging>
Последний параметр чаще всего имеет значение jar.
Плагины
Так как плагины являются такими же артефактами, как и зависимости, то они описываются практически так же. Вместо раздела dependencies – plugins, dependency – plugin, repositories – pluginRepositories, repository – pluginRepository.
Плагинами Maven делает все, даже непосредственно то, для чего он затевался – сборку проекта, только этот плагин необязательно указывать в свойствах проекта, если вы не хотите добавить какие-то фичи.
Посмотрим как настроить плагин для создания проекта для Eclipse с использованием WTP ver. 2.0. В раздел plugins нашего pom.xml прописываем следующий плагин:
<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-eclipse-plugin</artifactId> <configuration> <wtpversion>2.0</wtpversion> </configuration> </plugin>
Теперь идем опять таки в командную строку и выполняем команду
mvn eclipse:eclipse
Ждем пока Maven найдет все библиотеки в репозитории или скачает их и вуаля – теперь наш Maven-проект можно открыть как проект eclipse. При этом библиотеки никуда не копируются как при классическом подходе, а остаются в репозитории и Eclipse делает на них ссылку через свои переменные.
Единого списка всех плагинов естественно не существует, на официальном сайте только есть поддерживаемые плагины непосредственно разработчиками Maven. Однако хотелось бы отметить, что названия плагинов довольно прямолинейны и сделав поиск по ключевым словам «maven tomcat plugin» вы скорее всего обнаружите первой ссылкой плагин для деплоймента проекта в Tomcat.
Собственный репозиторий
К сожалению сам не имею большого опыта настройки репозитория, но могу посоветовать как наиболее простой и распространенный Nexus. За дополнительной информацией следует обратиться на сайт данного проекта.
Однако нельзя оставить без внимания и достойных конкурентов в лице Artifactory и Archiva.
Заключение
Очень надеюсь, что цель данной статьи достигнута – минимальных знаний по Maven должно хватить на работу с не очень большими проектами. Для более серьезных целей очень советую детально изучить maven-compiler-plugin и maven-resource-plugin – они напрямую отвечают за конечную компоновку проекта. Я считаю, что самым главным моментом в обучении Maven является понимание идеологии – Maven описывает конечную структуру проекта, а не пути к ее достижению, в отличие от Ant.
Полезные ссылки
Официальная страница Maven
Документация
Центральный репозиторий
Репозиторий iBiblio
Поиск артефактов по названию
Неплохой форум по Maven
Maven: The Definitive Guide — хорошая книга по Maven
#статьи
-
0
Собираем проект на Java быстро, без регистрации и СМС.
Иллюстрация: Lip Kee / Apache Software Foundation / Wikimedia Commons / John Fowler / Maksym Ostrozhynskyy / Brett Wharton / Ben Kolde / Unsplash / Дима Руденок для Skillbox Media
Пишет о сетях, инструментах для разработчиков и языках программирования. Любит готовить, играть в инди‑игры и программировать на Python.
Если спросить у Java-разработчика, кто его лучший друг, то, скорее всего, он расскажет про Apache Maven. Это фреймворк для автоматизации сборки проектов на основе описания их структуры в файлах на языке POM (Project Object Model).
Пока что звучит сложно, но в этой статье мы разберёмся в основах работы со сборщиком проектов и заглянем в его сердце — файл pom.xml.
Что вы узнаете про Maven:
- зачем он нужен и есть ли у него аналоги;
- как его правильно установить на компьютер и можно ли обойтись без этого;
- как его настроить и собрать свой первый проект;
- зачем ему репозитории и какими они бывают.
Maven — это инструмент для автоматической сборки проектов на Java и других языках программирования. Он помогает разработчикам правильно подключить библиотеки и фреймворки, управлять их версиями, выстроить структуру проекта и составить к нему документацию.
Например, чтобы собрать приложение для управления базами данных на Java, нам понадобятся фреймворки Spring и Hibernate, библиотека JUnit для модульного тестирования и сама база данных. Всё это можно собрать в одном проекте вручную, но могут быть трудности из-за большого числа зависимостей. Здесь на помощь разработчикам приходит Maven. Он автоматически добавит эти или другие зависимости в проект и соберёт его в исполняемый файл.
Maven — не единственный сборщик проектов. Некоторые разработчики используют его аналоги — Gradle и Ant. Но именно Maven сегодня — золотой стандарт в индустрии.
Maven можно установить вручную или воспользоваться IDE с предустановленным сборщиком. Второй вариант удобнее и быстрее, но начнём мы с обычной установки в операционную систему.
Важно! Чтобы работать с Java, у вас на компьютере должен быть установлен и настроен JDK. Мы уже писали, как это сделать правильно.
Скачайте архив со сборщиком для своей операционной системы с официального сайта Apache Maven и распакуйте его. Лучше всего создать для этого отдельную папку, так как путь к ней нам понадобится позже.
Если у вас Linux, то установку можно запустить через командную строку:
sudo команда-вашего-пакетного-менеджера maven
Для удобной работы с Maven и его запуска в командной строке или терминале необходимо прописать переменные среды. На разных операционных системах этот процесс различается.
Windows
Процесс установки на Windows 7, 10 и 11 одинаков. Нажмите правой клавишей мыши на Этот компьютер и выберите пункт меню Свойства. Теперь пройдите через несколько окон: Дополнительные параметры системы → Дополнительно → Переменные среды.
В окне Переменные среды найдите переменную Path и нажмите на кнопку Изменить:
Скриншот: Skillbox Media
В открывшемся окне нажмите кнопку Создать и укажите полный адрес до папки bin из распакованного архива Maven:
Проверьте настройку переменных среды. Для этого зайдите в командную строку и введите mvn -v. Если Maven установлен, то появится информация о его версии:
Linux/Mac
Откройте в текстовом редакторе файл ~/.bashrc или ~/.bash_profile в Linux или .zshrc в macOS. Файл находится в домашней директории текущего пользователя. Если файла нет, создайте его и впишите:
export PATH="<path_to_maven>:$PATH"
Вместо path_to_maven указываем путь к файлу ~/.bashrc или ~/.bash_profile в Linux или .zshrc в macOS.
Проверьте настройку переменных среды. Для этого зайдите в терминал и запустите mvn -n. Должно появиться сообщение с версией Maven:
Для Mac в последней строке будет указано family: «mac».
Для работы с Maven мы будем использовать IntelliJ IDEA. Это удобная среда разработки, в которой сборщик проектов установлен из коробки.
Настройки Maven в IDE можно найти в правой части рабочей области после создания проекта на Java:
Начнём работу с создания шаблона проекта. Среда разработки и здесь сэкономит нам время, так как самостоятельно пропишет необходимые параметры.
Создайте новый проект:
Программа предложит выбрать Maven Archetype в качестве шаблона сборки. Кликните на него и в окне преднастроек выберите Archetype quickstart. Нажмите Create:
В окне проекта вы увидите, как Maven зашёл в репозитории и начал что-то скачивать, — это нормально:
Слева на экране показана структура проекта. Нам нужен класс App.java, в котором находится метод main. Чтобы найти его, откройте папку src, затем main и java. Внутри App.java хранится небольшой фрагмент кода:
package org.example; /** * Hello world! * */ public class App { public static void main( String[] args ) { System.out.println( "Hello World!" ); } }
Метод работает просто — он выводит в консоль сообщение Hello World!.
Теперь перейдите к файлу pom.xml. Это основной конфигурационный файл в проекте, который описывает его структуру, зависимости и настройки. Можно сказать, что это главная сила всего Maven.
Если открыть файл, то увидим такой код:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>org.example</groupId> <artifactId>maven-example</artifactId> <version>1.0-SNAPSHOT</version> <packaging>jar</packaging> <name>maven-example</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> </dependencies> </project>
Разберём, что к чему:
project — корневой элемент, содержащий всю информацию о проекте.
xmlns, xmlns:xsi, xsi:schemaLocation — это атрибуты для указания пространства имён и схемы для pom.xml. Проще говоря, здесь указано, что должно содержаться в файле и как это всё должно быть расположено.
modelVersion — версия модели POM, которую данный файл использует. У нас версия 4.0.0.
groupId, artifactId, version — это обязательные элементы для идентификации содержимого проекта.
- groupId — это идентификатор команды. В нашем случае — org.example, как и пакет с классом App. В больших компаниях идентификатор определяет группу или команду разработчиков. Например, представим, как мог бы выглядеть идентификатор компании ACME. Веб-разработчики в ней будут использовать идентификатор группы com.acme.webapps, а мобильные разработчики — com.acme.mobile.
- artifactId — это идентификатор артефакта. Артефактами Maven называет приложения, пакеты и файлы. Как и идентификатор группы, он нужен, чтобы не запутаться в проекте. По умолчанию идентификатор артефакта соответствует имени проекта, которое мы указали при его создании. У нас это maven-example.
- version — версия проекта. Меняется при обновлении проекта.
packaging — тип упаковки проекта. У нас всё упаковывается в JAR-файл.
name — имя проекта.
url — URL-адрес, связанный с проектом.
properties — здесь указываем переменные проекта. В нашем случае мы прописываем только кодировку, задавая её по умолчанию как UTF-8. Точно так же мы можем указать версии зависимостей, конфигурации плагинов, фильтры ресурсов и другие параметры. Полный список настроек доступен в документации Maven.
Работают properties так: прописываете информацию в pom.xml, потом подставляете в нужном вам месте конструкцию с названием созданной вами properties — ${имя_properties}. Это если значение нужно упомянуть в pom.xml. В классах значение properties получаем через геттеры:
String appVersion = System.getProperty("app.version");
dependencies — здесь определяются зависимости проекта — библиотеки, которые будут использоваться. В нашем указана только зависимость от JUnit версии 3.8.1. В dependencies, так же как и для всего проекта, прописываются идентификаторы groupId, artifactId и version. Только здесь они прописаны для каждой библиотеки по отдельности.
scope указывает на то, для чего библиотека используется. Мы прописали область test — JUnit будет доступен только для запуска тестов, но не будет включён в основной код проекта.
Теперь запустим наш проект. Для этого нажмите run в окне App.java:
Всё сработало как надо — появился текст Hello World!:
Поздравляем! Вы собрали первый проект в Maven.
Maven умеет не только выводить что-то в консоль. Его мощь — в библиотеках, которые можно подключить к проекту. Для этого используются репозитории.
Репозитории Maven — это хранилища, где находятся библиотеки. Что-то вроде Google Play или App Store, но для сборщика проектов. Репозитории бывают локальными и удалёнными. Последние делятся на общедоступные и сторонние.
Локальный репозиторий расположен на вашем компьютере. Там Maven хранит библиотеки, которые вы используете в своих проектах.
Когда вы загружаете библиотеку в первый раз, Maven сохраняет её в локальном репозитории. Все последующие проекты используют уже загруженную версию, что позволяет сэкономить время на её скачивании.
Общедоступный, или центральный, репозиторий — это хранилище библиотек, предоставляемых Apache Maven. Именно к нему обращается сборщик по умолчанию.
Сторонние репозитории предоставляют какие-либо организации или сообщества. Чтобы Maven искал библиотеки именно в них, необходимо это настроить.
Библиотеки могут быть в состоянии снапшота (SNAPSHOT) или релиза (release). Снапшоты — это версии библиотек в разработке. Они могут меняться внутри без изменения номера версии. Это может привести к проблемам, так как версия библиотеки остаётся прежней, но её функциональность может измениться. Релизы — стабильные версии библиотек, которые не изменяются, а выпускаются под конкретным номером. Лучше всего использовать именно их.
Настройки работы Maven с репозиториями прописаны в settings.xml. Сам файл находится в папке conf вашей директории с Maven:
Откройте settings.xml в любом текстовом редакторе. Там много кода, но нам нужна секция <mirrors>. По умолчанию она выглядит так:
<mirrors> <!-- mirror | Specifies a repository mirror site to use instead of a given repository. The repository that | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used | for inheritance and direct lookup purposes, and must be unique across the set of mirrors. | <mirror> <id>mirrorId</id> <mirrorOf>repositoryId</mirrorOf> <name>Human Readable Name for this Mirror.</name> <url>http://my.repository.com/repo/path</url> </mirror> --> <mirror> <id>maven-default-http-blocker</id> <mirrorOf>external:http:*</mirrorOf> <name>Pseudo repository to mirror external repositories initially using HTTP.</name> <url>http://0.0.0.0/</url> <blocked>true</blocked> </mirror> </mirrors>
Что тут есть:
id — уникальный идентификатор для данного зеркала. В этом случае ID установлен как maven-default-http-blocker. Такая конфигурация блокирует внешние репозитории, использующие протокол HTTP. Это полезно, когда мы хотим пользоваться только локальными репозиториями.
mirrorOf — этот элемент указывает, для каких репозиториев будет применяться зеркало. У нас прописан шаблон external:http:*, который означает, что сборщик будет блокировать все внешние репозитории, использующие протокол HTTP, без каких-либо ограничений.
name — имя и описание для зеркала.
url — URL зеркала. Здесь указан фиктивный URL http://0.0.0.0/ в качестве заглушки.
blocked — определяет, блокируется указанное зеркало или нет. У нас установлено значение true, то есть доступ к внешним репозиториям заблокирован.
Если мы хотим, чтобы Maven искал библиотеки в других репозиториях, то должны добавить в <mirrors> блок по шаблону:
<mirror> <id>external-repos</id> <url>https://repo.example.com/maven2</url> <mirrorOf>external:*</mirrorOf> </mirror>
В url впишите адрес желаемого репозитория. Теперь Maven сможет его найти.
Резюмируем всё, что мы узнали про сборщик проектов:
- Maven облегчает рутинные задачи по сборке проектов на Java и некоторых других языках программирования.
- Главная сила Maven — это pom-файлы, позволяющие точно настроить сборку проекта с учётом всех используемых библиотек и фреймворков.
- Для хранения библиотек используются репозитории. Они могут быть локальными, то есть располагаться на вашем компьютере, и удалёнными. Это позволяет гибко настроить доступ к библиотекам и использовать нужные нам версии.
Как зарабатывать больше с помощью нейросетей?
Бесплатный вебинар: 15 экспертов, 7 топ-нейросетей. Научитесь использовать ИИ в своей работе и увеличьте доход.
Узнать больше
1. Вступление
Создание программного проекта обычно состоит из таких задач, как загрузка зависимостей, размещение дополнительных jar-файлов в пути к классам, компиляция исходного кода в двоичный код, выполнение тестов, упаковка скомпилированного кода в развертываемые артефакты, такие как файлы JAR, WAR и ZIP, и развертывание этих артефактов. на сервер приложений или в хранилище.
Apache Maven
автоматизирует эти задачи, сводя к минимуму риск того, что люди совершат ошибки при сборке программного обеспечения вручную и отделит работу по компиляции и упаковке нашего кода от процесса конструирования кода.
В этом руководстве мы собираемся исследовать этот мощный инструмент для описания, создания и управления проектами программного обеспечения Java с использованием центральной части информации —
Project Object Model
(POM) — которая написана на XML.
2. Зачем использовать Maven?
Ключевые особенности Maven:
-
простая настройка проекта в соответствии с лучшими практиками:
Maven пытается
избегайте как можно большей конфигурации, предоставляя шаблоны проектов
(названный
archetypes
)
управление зависимостями: ** включает автоматическое обновление, загрузку
и проверка совместимости, а также сообщение о зависимости
замыкания (известные также как транзитивные зависимости)
изоляция между зависимостями проекта и плагинами: ** с Maven,
зависимости проекта извлекаются из репозиториев
dependency
в то время как зависимости любого плагина извлекаются из
plugin
репозитории,
приводящие к уменьшению конфликтов, когда плагины начинают
скачать дополнительные зависимости
центральная система репозитория: ** зависимости проекта могут быть загружены из
локальная файловая система или общедоступные репозитории, такие как
Maven Central
-
Чтобы узнать, как установить Maven в вашей системе, проверьте ссылку:/install-maven-on-windows-linux-mac[это руководство по Baeldung]. **
3. Объектная модель проекта
Конфигурирование проекта Maven выполняется через
Project Object Model (POM)
, представленную файлом
pom.xml
.
POM
описывает проект, управляет зависимостями и настраивает плагины для сборки программного обеспечения.
POM
также определяет отношения между модулями многомодульных проектов. Давайте посмотрим на базовую структуру типичного файла
POM
:
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>org.baeldung</groupId>
<artifactId>org.baeldung</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>org.baeldung</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
//...
</plugin>
</plugins>
</build>
</project>
Давайте внимательнее посмотрим на эти конструкции.
3.1. Идентификаторы проекта
Maven использует набор идентификаторов, также называемых координатами, чтобы однозначно идентифицировать проект и указать, как должен быть упакован артефакт проекта:
-
groupId
— уникальное базовое имя компании или группы, которая создала
проект
**
artifactId
— уникальное имя проекта
-
version
— версия проекта -
packaging
— способ упаковки (например,
WAR
/
JAR
/
ZIP
)
Первые три из них (
groupId: artifactId: version
) объединяются, чтобы сформировать уникальный идентификатор, и представляют собой механизм, с помощью которого вы указываете, какие версии внешних библиотек (например, JAR) будут использовать ваш проект.
3.2. зависимости
Эти внешние библиотеки, которые использует проект, называются зависимостями.
Функция управления зависимостями в Maven обеспечивает автоматическую загрузку этих библиотек из центрального хранилища, поэтому вам не нужно хранить их локально.
Это ключевая особенность Maven и обеспечивает следующие преимущества:
-
** использует меньше памяти за счет значительного сокращения количества скачиваний
отключить удаленные репозитории
делает проверку проекта быстрее
-
** обеспечивает эффективную платформу для обмена двоичными артефактами внутри
вашей организации и за ее пределами без необходимости каждый раз создавать артефакт из источника **
Чтобы объявить зависимость от внешней библиотеки, вам нужно предоставить
groupId, artifactId
и
version
библиотеки.
Давайте посмотрим на пример:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.5.RELEASE</version>
</dependency>
Когда Maven обрабатывает зависимости, он загружает библиотеку Spring Core в ваш локальный репозиторий Maven.
3.3. Хранилища
Репозиторий в Maven используется для хранения артефактов сборки и зависимостей различных типов. Локальный репозиторий по умолчанию находится в папке
.m2/repository
в домашнем каталоге пользователя.
Если в локальном репозитории имеется артефакт или плагин, Maven использует его. В противном случае он загружается из центрального хранилища и сохраняется в локальном хранилище. Центральный репозиторий по умолчанию —
Maven Central
.
Некоторые библиотеки, такие как сервер JBoss, недоступны в центральном хранилище, но доступны в альтернативном хранилище. Для этих библиотек необходимо указать URL-адрес альтернативного хранилища в файле
pom.xml
:
<repositories>
<repository>
<id>JBoss repository</id>
<url>http://repository.jboss.org/nexus/content/groups/public/</url>
</repository>
</repositories>
-
Обратите внимание, что вы можете использовать несколько репозиториев в своих проектах. **
3.4. Свойства
Пользовательские свойства могут помочь сделать ваш файл
pom.xml
более удобным для чтения и обслуживания. В классическом случае вы будете использовать пользовательские свойства для определения версий для зависимостей вашего проекта.
-
Свойства Maven являются заполнителями значений и доступны в любом месте
pom.xml
с помощью нотации
$ \ {name}
** , где
name
— это свойство.
Давайте посмотрим на пример:
<properties>
<spring.version>4.3.5.RELEASE</spring.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
Теперь, если вы хотите обновить Spring до более новой версии, вам нужно всего лишь изменить значение внутри тега свойства
_ <spring.version>
, и все зависимости, использующие это свойство в своих тегах
<version> _
, будут обновлены.
Свойства также часто используются для определения переменных пути сборки:
<properties>
<project.build.folder>${project.build.directory}/tmp/</project.build.folder>
</properties>
<plugin>
//...
<outputDirectory>${project.resources.build.folder}</outputDirectory>
//...
</plugin>
3.5. построить
Раздел
build
также является очень важным разделом Maven
POM. Он предоставляет информацию о Maven
goal
по умолчанию, каталоге скомпилированного проекта и окончательном имени приложения. Раздел
build__ по умолчанию выглядит следующим образом:
<build>
<defaultGoal>install</defaultGoal>
<directory>${basedir}/target</directory>
<finalName>${artifactId}-${version}</finalName>
<filters>
<filter>filters/filter1.properties</filter>
</filters>
//...
</build>
-
Папка вывода по умолчанию для скомпилированных артефактов называется
target
, а окончательное имя упакованного артефакта состоит из
artifactId
и
version
, но вы можете изменить его в любое время.
3.6. Использование
Profiles
Еще одна важная особенность Maven — поддержка
profiles.
profile
— это, по сути, набор значений конфигурации. Используя
profiles
, вы можете настроить сборку для различных сред, таких как Производство/Тестирование/Разработка:
<profiles>
<profile>
<id>production</id>
<build>
<plugins>
<plugin>
//...
</plugin>
</plugins>
</build>
</profile>
<profile>
<id>development</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<build>
<plugins>
<plugin>
//...
</plugin>
</plugins>
</build>
</profile>
</profiles>
Как видно из приведенного выше примера, для профиля по умолчанию установлено значение
development
. Если вы хотите запустить
production
profile
, вы можете использовать следующую команду Maven:
mvn clean install -Pproduction
4. Жизненные циклы Maven Build
Каждая сборка Maven следует указанному
lifecycle
. Вы можете выполнить несколько сборок
lifecycle
goals
, в том числе для компиляции кода проекта, создания
package,
и
install
файла архива в локальном репозитории зависимостей Maven.
4.1.
Lifecycle Phases
В следующем списке показаны наиболее важные фазы Maven
lifecycle
:
-
validate
— проверяет правильность проекта -
compile
— компилирует предоставленный исходный код в двоичные артефакты -
test
— выполняет модульные тесты -
package
— упаковывает скомпилированный код в файл архива -
integration-test
— выполняет дополнительные тесты, которые требуют
упаковка
**
verify
— проверяет, является ли пакет действительным
-
install
— устанавливает файл пакета в локальный репозиторий Maven -
deploy
— развертывает файл пакета на удаленном сервере или в хранилище
4.2.
Plugins
и
Goals
Maven
plugin
представляет собой набор из одного или нескольких
goals
. Цели выполняются поэтапно, что помогает определить порядок выполнения
goals
.
Богатый список плагинов, которые официально поддерживаются Maven, доступен по адресу
here
. ** Есть также интересная статья о том, как связать:/executetable-jar-with-maven[создать исполняемый файл
JAR
на Baeldung]с использованием различных плагинов.
Чтобы пройти любой из вышеперечисленных этапов, нам просто нужно вызвать одну команду:
Например,
mvn clean install
удалит ранее созданные файлы jar/war/zip и скомпилированные классы (
clean)
и выполнит все фазы, необходимые для установки нового архива (
install)
-
Обратите внимание, что
goals
, предоставляемые
plugins
, могут быть связаны с различными фазами
lifecycle
. **
5. Ваш первый проект Maven
В этом разделе мы будем использовать функциональность командной строки Maven для создания проекта Java.
5.1. Генерация простого Java-проекта
Чтобы построить простой Java-проект, давайте запустим следующую команду:
mvn archetype:generate
-DgroupId=org.baeldung
-DartifactId=org.baeldung.java
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false
GroupId
— это параметр, указывающий группу или отдельное лицо, создавшее проект, которое часто является обратным доменным именем компании.
ArtifactId
— это имя базового пакета, используемое в проекте, и мы используем стандартный
archetype
.
Поскольку мы не указали версию и тип упаковки, для них будут заданы значения по умолчанию — для версии будет задано
1.0-SNAPSHOT,
и для упаковки будет задано
jar
.
-
Если вы не знаете, какие параметры предоставить, вы всегда можете указать
_interactiveMode
=
true_
, чтобы Maven запрашивал все необходимые параметры. **
После завершения команды у нас есть проект Java, содержащий класс
App.java
, который является простой программой «Hello World», в папке
src/main/java
.
У нас также есть пример тестового класса в src/test/java. Pom.xml этого проекта будет выглядеть примерно так:
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>org.baeldung</groupId>
<artifactId>org.baeldung.java</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>org.baeldung.java</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.1.2</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Как видите, зависимость
junit
предоставляется по умолчанию.
5.2. Компиляция и упаковка проекта
Следующим шагом является компиляция проекта:
Maven будет проходить все этапы
lifecycle
, необходимые на этапе
compile
для создания исходных текстов проекта. Если вы хотите запустить только фазу
test
, вы можете использовать:
Теперь давайте вызовем фазу
package
_,
, которая создаст файл
jar_
скомпилированного архива:
5.3. Выполнение заявки
Наконец, мы собираемся выполнить наш Java-проект с помощью
exec-maven-plugin
. Давайте настроим необходимые плагины в
pom.xml
:
<build>
<sourceDirectory>src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.6.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.5.0</version>
<configuration>
<mainClass>org.baeldung.java.App</mainClass>
</configuration>
</plugin>
</plugins>
</build>
Первый плагин
maven-compiler-plugin
отвечает за компиляцию исходного кода с использованием Java версия 1.8. Https://search.maven.org/classic/#search%7Cga%7C1%7Ca%3A%22exec-maven-plugin%22[
exec-maven-plugin
]ищет
mainClass
в нашем проекте.
Чтобы выполнить приложение, мы запускаем следующую команду:
6. Мультимодульные проекты
Механизм в Maven, который обрабатывает многомодульные проекты (также называемые
aggregator
projects), называется
Reactor
.
Reactor
собирает все доступные модули для сборки, затем сортирует проекты в правильном порядке сборки и, наконец, строит их один за другим.
Давайте посмотрим, как создать многомодульный родительский проект.
6.1. Создать родительский проект
Прежде всего, нам нужно создать родительский проект. Чтобы создать новый проект с именем
parent-project,
мы используем следующую команду:
mvn archetype:generate -DgroupId=org.baeldung -DartifactId=parent-project
Затем мы обновляем тип упаковки внутри файла
pom.xml
, чтобы указать, что это модуль
parent
:
<packaging>pom</packaging>
6.2. Создать проекты субмодулей
На следующем шаге мы создаем проекты субмодулей из каталога
parent-project
:
cd parent-project
mvn archetype:generate -DgroupId=org.baeldung -DartifactId=core
mvn archetype:generate -DgroupId=org.baeldung -DartifactId=service
mvn archetype:generate -DgroupId=org.baeldung -DartifactId=webapp
Чтобы проверить, правильно ли мы создали подмодули, мы смотрим в файле
parent-project pom.xml
, где мы должны увидеть три модуля:
<modules>
<module>core</module>
<module>service</module>
<module>webapp</module>
</modules>
Более того, родительский раздел будет добавлен в
pom.xml
каждого подмодуля:
<parent>
<groupId>org.baeldung</groupId>
<artifactId>parent-project</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
6.3. Включить управление зависимостями в родительском проекте
Управление зависимостями — это механизм для централизации информации о зависимостях для родительского проекта muti-module и его дочерних элементов.
Если у вас есть набор проектов или модулей, которые наследуют общего родителя, вы можете поместить всю необходимую информацию о зависимостях в общий файл
pom.xml
. Это упростит ссылки на артефакты в дочернем
__POM
__s.
Давайте посмотрим на пример родительского
pom.xml
:
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.5.RELEASE</version>
</dependency>
//...
</dependencies>
</dependencyManagement>
Объявляя версию
spring-core
в родительском объекте, все подмодули, зависящие от
spring-core
, могут объявить зависимость, используя только
groupId
и
artifactId
, и версия будет наследоваться
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</dependency>
//...
</dependencies>
Более того, вы можете предоставить исключения для управления зависимостями в родительском
pom.xml
, чтобы определенные библиотеки не наследовались дочерними модулями:
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</exclusion>
</exclusions>
Наконец, если дочернему модулю нужно использовать другую версию управляемой зависимости, вы можете переопределить управляемую версию в файле
pom.xml
дочернего элемента:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.2.1.RELEASE</version>
</dependency>
-
Обратите внимание, что хотя дочерние модули наследуют от своего родительского проекта, родительский проект не обязательно имеет какие-либо модули, которые он объединяет. С другой стороны, родительский проект может также объединять проекты, которые не наследуются от него. **
6.4. Обновление субмодулей и построение проекта
Мы можем изменить тип
packaging
каждого подмодуля. Например, давайте изменим
packaging
модуля
webapp
на
WAR
, обновив файл
pom.xml
:
<packaging>war</packaging>
Теперь мы можем протестировать сборку нашего проекта с помощью команды
mvn clean install
. Выходные данные журналов Maven должны быть похожи на это:
----[INFO]Scanning for projects...[INFO]Reactor build order:[INFO] parent-project[INFO] core[INFO] service[INFO] webapp//.............[INFO]-----------------------------------------[INFO]Reactor Summary:[INFO]-----------------------------------------[INFO]parent-project .................. SUCCESS[2.041s][INFO]core ............................ SUCCESS[4.802s][INFO]service ......................... SUCCESS[3.065s][INFO]webapp .......................... SUCCESS[6.125s][INFO]-----------------------------------------
----
7. Заключение
В этой статье мы обсудили некоторые из наиболее популярных функций инструмента сборки Apache Maven.
Все примеры кода на Baeldung построены с использованием Maven, поэтому вы можете легко проверить наш
GitHub веб-сайт проекта
, чтобы увидеть различные конфигурации Maven.