Что такое maven: Краткое знакомство с Maven

Содержание

Краткое знакомство с Maven

Maven — инструмент для автоматизации сборки проектов. С ним работают в основном Java-разработчики, хотя есть плагины для интеграции с C/C++, Ruby, Scala, PHP и другими языками. В статье будут рассмотрены особенности и область применения Maven, описан процесс установки и начала работы, а также разобрана структура файла описания проекта.

Назначение и особенности

Собрать на Java проект уровня «Hello, world!» можно и с помощью командной строки. Но чем сложнее разрабатываемое ПО и чем больше оно использует сторонних библиотек и ресурсов, тем сложнее будет команда для сборки. Maven разработан для облегчения этой работы.

Одна из главных особенностей фреймворка — декларативное описание проекта. Это значит, что разработчику не нужно уделять внимание каждому аспекту сборки — все необходимые параметры настроены по умолчанию. Изменения нужно вносить лишь в том объёме, в котором программист хочет отклониться от стандартных настроек.

Ещё одно достоинство проекта — гибкое управление зависимостями. Maven умеет подгружать в свой локальный репозиторий сторонние библиотеки, выбирать необходимую версию пакета, обрабатывать транзитивные зависимости.

Разработчики также подчёркивают независимость фреймворка от ОС. При работе из командной строки параметры зависят от платформы, но Maven позволяет не обращать внимания на этот аспект.

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

В этой статье мы будем работать с Maven с помощью командной строки, однако этот фреймворк также интегрирован в Eclipse, IntelliJ IDEA, NetBeans и другие IDE.

Установка, настройка и создание стандартного проекта

Скачать Maven можно с официальной страницы проекта. Там же вас познакомят с минимальными требованиями — на машине должен быть установлен JDK, а также потребуется свободное место на диске, около 500 мегабайт. Это место нужно не для самой установки, оно будет использовано для создания локального репозитория.

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

Архив можно распаковать в любое удобное место. После этого нужно добавить путь к папке bin из распакованного архива в переменную среды PATH. В Windows нужно зайти в настройки параметров системы (вызывается комбинацией клавиш Win+Pause или щелчком правой кнопкой мыши по ярлыку «Мой / Этот компьютер» -> «Свойства»), и выбрать пункт «Дополнительные параметры системы». В правом нижнем углу нажмите кнопку «Переменные среды». Выберите переменную PATH, нажмите «Изменить», в открывшемся окне — «Создать» и добавьте путь. Обратите внимание, путь должен вести именно к папке bin.

В ОС на основе Unix переменную среды можно добавить консольной командной:

export PATH=/opt/apache-maven-3.6.0/bin:$PATH

Проверить, всё ли сделано правильно, можно с помощью консольной команды mvn -v. Вы должны увидеть что-то подобное:

Apache Maven 3.6.0 (97c98ec64a1fdfee7767ce5ffb20918da4f719f3; 2018-10-24T21:41:47+03:00)
Maven home: C:\apache-maven-3.6.0\bin\..
Java version: 10.0.1, vendor: Oracle Corporation, runtime: C:\Program Files\Java\jdk-10.0.1
Default locale: ru_RU, platform encoding: Cp1251
OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

Создаём папку для нового проекта и переходим в неё. Далее создаём новый проект. Для этого в консоли выполните команду:

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

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

archetype:generate это так называемая цель. Она указывает Maven, что нужно создать проект из архетипа. Дальше с помощью -D мы указываем определённые параметры генерации.

  • groupId=com.mycompany.app указывает на разработчика ПО, там вы можете указать доменное имя своей компании.
  • artifactId=my-app — название проекта. Maven оперирует так называемыми артефактами. Это приложения, плагины, архетипы и другие проекты. И ваша разработка также будет считаться артефактом.
  • archetypeArtifactId=maven-archetype-quickstart указывает, какой архетип использовать в качестве шаблона для создания приложения. Как видите, это тоже артефакт. Указанный архетип создаст простой проект, сгенерирует структуру каталогов и даже заботливо положит в папку исходников программу «Hello, world!», чтобы вам не пришлось самому писать её в двухсотый раз.
  • archetypeVersion=1.4 указывает на версию артефакта «архетип».
  • interactiveMode=false отключает создание проекта в интерактивном режиме. Вы можете запустить цель archetype:generate без параметров, и Maven предложит установить параметры в процессе генерации. В данном случае нам это не нужно. Кстати, отключить интерактивный режим можно параметром -B. Полный список параметров для mvn можно получить по команде mvn -h.

Выполнив команду, Maven сгенерирует следующую структуру проекта:

my-app

|-- pom.xml

`-- src

    |-- main

    |     `-- java

    |         `-- com

    |             `-- mycompany

    |                 `-- app

    |                     `-- App.java

    `-- test

        `-- java

            `-- com

                `-- mycompany

                    `-- app

                        `-- AppTest.java

Исходники нашего проекта будут лежать в папке src/main/java (и сейчас там уже есть автоматически сгенерированный файл), но нам сейчас интереснее файл pom. xml в корневом каталоге. Это и есть тот самый файл описания проекта, на основе которого осуществляются все операции Maven. Он написан на языке POM, входящим в семейство XML:

<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">

<groupId>com.mycompany.app</groupId>
<artifactId>my-app</artifactId>
<version>1.0-SNAPSHOT</version>

<name>my-app</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
</properties>

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <pluginManagement>
        <plugins>
            <...>
        </plugins>
    </pluginManagement>
</build>
</project>

Разберёмся, что всё это значит.

Что значат теги в pom.xml

Тег project является базовым и содержит всю информацию о проекте. В заголовке указана информация, необходимая Maven для понимания файла pom.xml. Тег modelVersion указывает на текущую версию POM. Эти два тега обычно генерируются автоматически, менять их не нужно.

Затем идёт информация, формирующая уникальный идентификатор проекта, теги groupId и artifactId

. Её мы задавали выше при генерации из архетипа. Тег version тоже входит в эту группу. Он обычно генерируется и обновляется автоматически. После номера версии идёт суффикс -SNAPSHOT. Это означает, что проект находится в стадии разработки. В процессе выпуска ПО фреймворк уберёт этот суффикс, а если разработка продолжится — автоматически увеличит номер версии. Вместе эти три тега позволяют однозначно идентифицировать артефакт.

name содержит отображаемое имя артефакта, а url — ссылку на сайт. Поскольку сайт не задан при генерации, pom.xml содержит напоминание об этом в виде комментария. Кроме того, можно добавить краткое описание в description. Эти три тега зачастую используются при формировании документации.

Дальше мы видим блок 

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

Следом идёт очень важный блок dependencies. В нём описываются все используемые в проекте зависимости. Каждую необходимо выделить тегом dependency и указать уникальные идентификационные данные: groupIdartifactId и version. Maven сам подгрузит транзитивные зависимости. Кроме того, с помощью тега scope можно указать этапы, на которых будет использован артефакт. Сейчас в pom.xml всего одна зависимость — артефакт JUnit, библиотека для модульного тестирования на Java, которая будет использоваться только на стадии тестирования.

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

  1. Проверка — validate. Фреймворк проверяет, корректен ли проект и предоставлена ли вся необходимая для сборки информация.
  2. Компиляция — compile. Maven компилирует исходники проекта.
  3. Тест — test. Проверка скомпилированных файлов. В нашем случае будет использована библиотека JUnit.
  4. Сборка проекта — package. По умолчанию осуществляется в формате JAR. Этот параметр можно изменить, добавив в project тег packaging.
  5. Интеграционное тестирование — integration-test. Maven обрабатывает и при необходимости распаковывает пакет в среду, где будут выполняться интеграционные тесты.
  6. Верификация — verify. Артефакт проверяется на соответствие критериям качества.
  7. Инсталляция — install. Артефакт попадает в локальный репозиторий. Теперь его можно использовать в качестве зависимости.
  8. Размещение проекта в удалённом репозитории — deploy, — финальная стадия работы.

Эти фазы упорядочены и выполняются поочерёдно. Если необходимо собрать проект, система последовательно проведёт оценку, компиляцию и тестирование, и только после этого сборку. Помимо этого есть две фазы, выполняющиеся отдельно, только прямой командой. Это очистка — clean, удаляющая предыдущие сборки, и создание документации для сайта — site.

Закончим рассмотрение pom.xml секцией build. Она не является обязательной, в данном pom.xml в неё включены плагины из архетипа, однако можно обойтись и без них. Плагинов для Maven тысячи, освоившись с применением фреймворка вы сможете сами подобрать себе необходимые.

В проектах чуть серьёзнее, чем вычисление факториала, приходится использовать внешние ресурсы. Maven способен автоматически обрабатывать файлы ресурсов и размещать их в сборке проекта. Для этого их нужно разместить в папке src/main/resources. Файлы будут упакованы с сохранением внутренней структуры каталогов. Если же по какой-то причине нужно переопределить каталог, используйте вложенные теги resources, resource, directory в секции build:

<build>
    <resources>
        <resource>
            <directory>src/main/another_resources_directory</directory>
        </resource>
    </resources>
</build>

Итак, с файлом описания мы разобрались. Попробуем собрать проект. Для этого перейдём в корневую папку и выполним команду нужной фазы, mvn package. Получим отчёт о сборке:

[INFO] ----------------------< com.mycompany.app:my-app >----------------------
[INFO] Building my-app 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:3.0.2:resources (default-resources) @ my-app ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory C:\javaProjects\new_project\my-app\src\main\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.8.0:compile (default-compile) @ my-app ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to C:\javaProjects\new_project\my-app\target\classes
[INFO]
[INFO] --- maven-resources-plugin:3.0.2:testResources (default-testResources) @ my-app ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory C:\javaProjects\new_project\my-app\src\test\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.8.0:testCompile (default-testCompile) @ my-app ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to C:\javaProjects\new_project\my-app\target\test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.22.1:test (default-test) @ my-app ---
[INFO]
[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.mycompany.app.AppTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.217 s - in com.mycompany.app.AppTest
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO]
[INFO] --- maven-jar-plugin:3.0.2:jar (default-jar) @ my-app ---
[INFO] Building jar: C:\javaProjects\new_project\my-app\target\my-app-1. 0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  20.670 s
[INFO] Finished at: 2019-02-17T02:25:07+03:00
[INFO] ------------------------------------------------------------------------

Теперь в корневом каталоге проекта вы обнаружите папку target, а в ней готовый файл my-app-1.0-SNAPSHOT.jar.

Запустите команду java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App — вы должны увидеть «Hello World!».

Поздравляем! Вы собрали проект с помощью Maven. Для более детального изучения инструмента советуем обратить внимание на эти книги и материалы.

Maven — зачем? / Хабр

На просторах сети вообще и хабра в частности мне доселось видеть не один топик посвящённый Maven. И везде, где было обсуждение, возникали вопросы вида:
  • Что даёт его использование в проекте типа X?
  • Чем он лучше Ant/Make/sh?
  • А что делать если я хочу использовать в проекте antlr/JAX-WS/XDoclet?

Я полагаю, что все эти вопросы происходят из незнания что на свете есть гугл недостаточного понимания что такое Maven и какой подход к решению задач build management он предлагает. Что в свою очередь растёт из недостаточного внимания, которое авторы статей уделяют идеям стоящим за xml-файлами и завораживающими консольными командами.

Мне очень важным кажется понимание того, что когда говорят Maven подразумевают 3 достаточно слабо связанные вещи:

  • POM. Project object model. Модель проекта — в ней описано из чего проект состоит и как устроен его жизненный цикл.
  • Репозитории артефактов. Места хранения продуктов сборки программных модулей вместе с метаданными.
  • Утилиту mvn и плагины к ней. Собственно инструмент сборки проектов управления жизненным циклом модулей.

Давайте рассмотрим каждую в отдельности, чтобы понять как их можно использовать вместе.
POM

Это общая модель проектов. В ней описываются такие общие характеристики как имя, версия, авторы и их контактная информация, VCS проекта и вообще связанные с ним сетевые ресурсы, тип проекта (например библиотека или web-модуль, в оригинальной терминологии называется packaging, хотя влияет не только на тип получаемого артефакта), связи с другими проектами, используемые при сборке плагины и описания способа их задействования. Мне кажутся особенно важными два компонента этой модели.
Связи с другими модулями

POM допускает три типа связей с другими модулями: зависимость, включение и наследование.

Зависимость, эта связь говорит, что для некоторых фаз жизненного цикла нашего модуля, требуются некоторые артефакты модулей-зависимостей (абстрактно получилось — аж самому страшно). Что конкретно и на какой фазе жизненного цикла требуется определяется так называемой областью действия зависимости. Maven понимает несколько предопределённых областей действия и позволяет добавлять свои. В качестве примера ограничусь одной областью действия: compile — она говорит, что бинарные сборки зависимости требуются на этапе компиляции, выполнения тестов и во время выполнения.

Включение — говорит, что связанный модуль является неотъемлемой частью нашего модуля. Для прохождения нашим модулем некоторой фазы жизненного цикла, входящий в него также должен пройти эту фазу. Классический пример enterprise-модуль, включающий в себя web-модуль, пакет с EJB и общую библиотеку. Очевидно, что его сборка требует сборки каждого из включаемых модулей.

Наследование. Такая связь подразумевает перенос на наследника части модели предка. Правила переноса несколько запутаны, но в основном действует принцип — значение параметра модели предка становится умолчанием для модели потомка. Пример из моей практики: был создан модуль, устанавливающий версию JDK для компиляции проектов, внутренние репозитарии для результатов, набор правил для поверки соответствия исходников стандарту кодирования, он должен был использоваться (а кое-где и действительно использовался 😉 ) как родитель для всех разрабатываемых в рамках проекта модулей.

Описание используемых при сборке плагинов

Описание состоит из имени задействуемого плагина, некоторых его настроек(они определяются плагинами индивидуально), и собственно выполняемых им целей на каждой из фаз жизненного цикла(подробное описание идей, стоящих за этими терминами см. ниже).

Этот элемент несколько чужд общей идеи POM — он несёт не декларативное описание модуля, а инструкции по его сборке конкретным инструментом.

Итоги
  1. POM — эта общая, унифицированая модель описания программных модулей.
  2. Она поддерживает хранение не только аттрибутов отдельных модулей но и высокоуровневых связей между ними.
  3. Также она несёт информацию об инструментах, необходимых для поддержки жизненного цикла модуля.

Репозитории артефактов

Репозитории артефактов являются выделенными хранилищами результатов сборки, устроенными так, чтобы упростить поиск нужного артефакта (по имени, версии, типу артефакта). Они позволяют группе разработчиков пользоваться результатами работы друг друга без необходимости иметь копии исходных кодов их модулей и выполнять сборку дерева зависимостей с 0. Maven-совместимые репозитарии стали стандартом де факто публикации результатов различных открытых проектов.

Нужно заметить, что pom-файлы, содержащие модель проекта, также являются артефактами и могут хранится в репозитариях вместе со всеми (на самом деле по крайней мере урезанные их версии, содержащие только идентификацию модуля и зависимости, хранятся всегда). Таким образом репозитарий является в том числе источником информации (как миннимум достаточной для дистрибуции) о хранимых в нём модулях.

Итак, какие бонусы они нам дают:

  1. Структурированное хранение артефактов, их каталогизация.
  2. Повторное использование артефактов.

Утилита управления жизненным циклом

Название получилось достаточно пафосное, однако оно вполне соответствует высокой миссии и сложности предмета.

Прежде чем погрузиться в её функции, необходимо немного познакомится с теорией организации жизненного цикла модуля в Maven. Жизненным циклом называется вся совокупность операций над модулем от инициализации сборки до развёртывания. В процессе прохождения жизненного цикла выполняются определённые операции над модулем, формируются некоторые артефакты. Жизненный цикл разделён на фазы. Каждая фаза подразумевает перевод модуля в новое состояние в результате её прохождения и появление новых артефактов. Каждая предыдущая фаза подготовливает основу для последующей. Список фаз является по сути частью POM, но глобальной, общей для всех модулей. Поный список приводить бессмысленно, но для примера приведу несколько фаз (достаточно интуитивно названных, на мой взгляд 🙂 ) в порядке их следования: compile,… test,… deploy.

В рамках каждой фазы выполняется некоторый набор целей в зависимости от модели конкретного модуля. Цель является конкретной операцией над исходными кодами и/или артефактами.

Теперь к самой утилите. Она отвечает за реализацию жизненного цикла на основании модели проекта. Состоит из двух основных компонентов:

  1. Во-первых из совсем маленького ядра, в котором описаны (захардкожены, как говорит простой народ) базовые принципы устройства проектов, цели по умолчанию для фаз стандартных типов проектов, рабочая среда для плагинов (интерфейсы доступа к моделям, репозитариям, ФС, настройкам и т.п.).
  2. Во-вторых из плагинов. Они собственно содержат код, выполняющий цели. Практически вся внешняя функциональность mvn реализуется ими. Именно они генерируют, компилируют, тестируют, пакуют и т.д. и т.п.

Общение с этой утилитой построено предельно просто: вы говорите до какой кондиции фазы нужно довести клиента модуль и она это делает. Вся сложность формулировки и выполнения задач по достижению цели остаётся на совести разработчиков плагинов (ну хорошо, немного остаётся на разработчика модели). Например говорим compile и нам компилируют, причём не только то, что вылезло из VCS но и генерируют необходимое например wsimport’ом и результаты тоже компилируют.

Также можно попросить выполнить отдельную задачу конкретного плагина. Например есть плагин для генерации Eclipse-проектов, задача «сгенерировать проект» которого по умолчанию не привязывается ни к одной фазе, а вызывается заинтересованными лицами вручную.

Ещё одной крайне интересной функцией mvn является создание заготовки проекта на основе архетипа. Архетип — обобщённый шаблон проекта, традиционно концентрирующийся на его структуре и используемых плагинах. Например есть стандартные архетипы java-библиотеки, web-модуля, и нестандартные, например grails приложение. Важно понимать отличие архетипа от типа проекта. Архетип — только шаблон начальной структуры и отдельных частей проекта, после создания проекта никакой информации о его архетипе не остаётся. Тип проекта — наоборот, часть модели, которая используется на протяжении всего жизненного цикла.

Что получается в сумме

Итак, мы выделили три столпа Maven. Что-же они дают нам вместе?
  • Концентрирование информации о модуле в одном месте и в одном формате. Не всё тут гладко, но многие IDE могут импортировать проекты из POM, большинство серверов автокомпиляции (continuous integration, как говорят адепты XP) также могут использовать их добавлении проекта.
  • Единая система идентификации модулей. Очень просто и очень важно. У нас нет теперь обозначений типа багфикс-ветка нашего-супер-проекта, собранная в 23 часа в прошлую субботу.
  • Один инструмент. Хотя это, прямо скажем, не уникальная фича Maven. Не удержусь и повторю прописную истину: проект должен собираться стандартными и переносимыми средствами. Сборка любимой IDE Первого Разработчика Проекта — путь в ад.
  • Автоматическое управление зависимостями. Связывание исходного кода проекта с бинарными сборками чего-то, очень невесёлая практика. Особо надо отметить трудности с поддержкой репозитариев исходников (сколько магнитных лент занимает бэкап вашего svn?)) ). Изобретения велосипеда в виде своих репозитариев или скриптов подтаскивающих исходнки зависимостей тоже не лучшее решение в эпоху, когда космические корабли бороздят просторы вселенной.
  • Повторное использование решений, связанных с устройством и процедурой сборки проектов. Благодаря наследованию и включению проектов мы можем многократно использовать однажды разработанные модели проектов, настройки, связанные с инфраструктурой и инструментарием принятыми в нашей компании. Использование архетипов позволяет автоматизировать этап создания новых проектов, съэкономить время на подготовке структуры проекта и минимизировать ошибки в использовании внешних моделей.
  • Готовое средство для управления результатами работы и простота их последующего использования. Настраиваем инфраструктуру подобающим образом и каждый билд оседает в нужном месте и доступен для последующего использования. Нужно проверить работоспособность разных компоновок версий/веток модулей большого проекта? Просто правим зависимости в POM.

Заключение

Что-то я местами отклонился от центрального вопроса и вплотную занялся вопросом «как», ну да ладно…

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

Надеюсь, что после прочтения топика каждый может уверенно ответить на вопросы, приведённые в начале 😉

P.S. Ещё я с интересом узнаю о вашем опыте нестандартного применения Maven. Есть идея в будующем создать пост с примерами интересных и необычных use case’ов для него.

Ответы на вопросы на собеседование Maven (часть 1).

  • Что такое сборка проекта, автоматизация сборки?

Сборка (англ. assembly) — двоичный файл, содержащий исполняемый код программы или другой, подготовленный для использования информационный продукт.

Автоматизация сборки — этап написания скриптов или автоматизация широкого спектра задач применительно к ПО, применяемому разработчиками в их повседневной деятельности, включая такие действия, как:

  • Компиляция исходного кода в бинарный код
  • Сборка бинарного кода
  • Выполнение тестов
  • Разворачивание программы на производственной платформе
  • Написание сопроводительной документации или описание изменений новой версии

  • Что такое Maven? Как он работает?

Apache Maven — это фреймворк для автоматизации сборки проектов, компиляции, создания jar, создания дистрибутива программы, генерации документации. Если собирать большие проекты с командной строки, то команда для сборки будет очень длинной, поэтому её иногда записывают в bat/sh скрипт. Но такие скрипты зависят от платформы. Для того чтобы избавиться от этой зависимостии и упростить написание скрипта используют инструменты для сборки проекта.

Maven, обеспечивает декларативную, а не императивную сборку проекта. То есть, в файлах проекта pom.xml содержится его декларативное описание, а не отдельные команды. Все задачи по обработке файлов Maven выполняется через плагины.

  • Какие преимущества Maven?

Основные преимущества Maven:

  • Независимость от OS. Сборка проекта происходит в любой операционной системе. Файл проекта один и тот же.
  • Управление зависимостями. Редко какие проекты пишутся без использования сторонних библиотек(зависимостей). Эти сторонние библиотеки зачастую тоже в свою очередь используют библиотеки разных версий. Maven позволяет управлять такими сложными зависимостями. Что позволяет разрешать конфликты версий и в случае необходимости легко переходить на новые версии библиотек.
  • Возможна сборка из командной строки. Такое часто необходимо для автоматической сборки проекта на сервере (Continuous Integration).
  • Хорошая интеграция со средами разработки. Основные среды разработки на java легко открывают проекты которые собираются c помощью maven. При этом зачастую проект настраивать не нужно — он сразу готов к дальнейшей разработке. 
  • Как следствие — если с проектом работают в разных средах разработки, то maven удобный способ хранения настроек. Настроечный файл среды разработки и для сборки один и тот же — меньше дублирования данных и соответственно ошибок.
  • Декларативное описание проекта.

  • Какие недостатки Maven?

Недостатки Maven:

  • Неочевидность. Если в Ant указывается команда на удаление — и удаляется файл, то в случае Maven надо всем сердцем довериться плагину и документации по нему.
  • При таком объёме необходимых знаний документации не так много, особенно по каким-то специальным моментам. Да и просто читать придётся много. Порог вхождения, если потребуется собирать даже не самое сложное приложение куда выше, чем у Ant.
  • Если нужно найти какой-то специальный плагин — это будет сделать непросто, плагинов много. И не факт, что найденный подойдёт на все 100% и будет работать без ошибок.
  • Нужен доступ в интернет (или придётся разворачивать собственный репозиторий, что трудоёмко)
  • Большие трудности, если проект не типовий.

  • Какими аспектами управляет Maven?

Вот основные аспекты, которыми позволяет управлять Maven:

  • Создание (Build)
  • Документирование (Documentation)
  • Отчёты (Reporting)
  • Зависимости (Dependencies)
  • Релизы (Releases)
  • SCM
  • Список рассылки (Mailing list)
  • Дистрибьюция (Distribution)

  • Как узнать какую версию Maven вы используете?

С помощью следующий команди:

mvn —version

  • Для чего создан Maven?

Основной целью Maven является предоставление разработчику:

  • Понятной модели для проектов, которая может быть использовано повторно и была бы проста в поддержании.
  • Плагины, которые могут взаимодействовать с этой моделью.
Структура и сожержание проекта Maven указывается в специальном xml-файле, который назывется Project Object Model (POM), который является базовым модулем всей системы.

  • Какая структура каталогов в Maven?

В Maven стандартная структура каталогов, благодаря ей отпадает необходимость прописывать пути к файлам проекта. В корневом каталоге проекта находится pom.xml и несколько текстовых файлов. Всё остальное хозяйство аккуратно разложено в подкаталогах. Главные из них — src и target. Однако, порядок сохраняется и вглубь:

  • Где вы хранятся файлы классов при компиляции проекта Maven?
Файлы классов хранятся в: ${basedir}/target/classes/.

  • Что такое pom.xml?

pom.xml — это XML-файл, который содержит информацию о деталях проекта, и  конфигурации используемых для создания проекта на Maven. Он всегда находится в базовом каталоге проекта. Этот файл также содержит задачи и плагины. Во время выполнения задач, Maven ищет файл pom.xml в базовой директории проекта. Он читает его и получает необходимую информацию, после чего выполняет задачи.

Корневой элемент <project>, схема, которая облегчает редактирование и проверку, и версия pom.xml. Внутри тега project содержится основная и обязательная информация о проекте.

  • Какую информацию содержит pom.xml?

Среди информации которую содержит pom.xml мы можем выделить следующие:

  • Зависимости проекта (project dependencies)
  • Плагины (plugins)
  • Задачи/цели (goals)
  • Профиль создания (build profiles)
  • Версия проекта (project version)
  • Разработчики (developers)
  • Список рассылки (mailing list)

  • Что такое супер POM?

Все POM — файлы являются наследниками родительского pom.xml. Этот POM-файл называется Super POM и содержит значения, унаследованные по умолчанию.

  • Какие элементы необходимы для минимального POM?

Требуемые элементы для минимального POM ето корневий елемент, modelVersion, GroupID, artifactID  и версия. Минимальный POM файл:

  • Что такое зависимости в Maven?

Зависимость (dependency) — это те библиотеки, которые непосредственно используются в вашем проекте для компиляции кода или его тестирования.

  • Что такое артефакт в Maven?

Артефакт (artefact) — это, по сути, любая библиотека, хранящаяся в репозитории (месте хранения). Это может быть какая-то зависимость или плагин. Обычно артефактом является JAR-файл, который хранится в репозитории Maven. Каждый артефакт содержит group ID, artifact ID и версию.

  • Что такое плагин в Maven?

Плагин (plugin) — это зависимости Maven’а, расширяющие его функционал.

  • Что такое задача в Maven?
Задача (goal) — это специальная задача, которая относится к сборке проекта и его управлению. Она может привязываться как к нескольким фазам, так и ни к одной. Задача, которая не привязана ни к одной фазе, может быть запущена вне фаз сборки с помощью прямого вызова.

  • Что такое архетип в Maven?

Архетип (archetype) — это некая стандартная компоновка файлов и каталогов в проектах различного рода (веб, swing-проекты и прочие). Другими словами, Maven знает, как обычно строятся проекты и в соответствии с архетипом создает структуру каталогов.

  • Что такое репозиторий в Maven?
Репозиторий (repository) — глобальное хранилище всех библиотек, доступных для Maven, это место где хранятся артефакты: jar файлы, pom-файлы, javadoc, исходники, плагины.

  • Какие типы репозитория существуют в Maven?

В Maven существуют три типы репозитория:

  • Локальный (local) репозиторий — это директория, которая хранится на нашем компьютере. Она создаётся в момент первого выполнения любой команды Maven. По умолчанию она расположена в <home директория>/.m2/repository — персональная для каждого пользователя.
  • Центральный (central) репозиторий — это репозиториий, который обеспечивается сообществом Maven. Он содержит огромное количество часто используемых библиотек. Который расположен в http://repo1.maven.org/maven2/ и доступен на чтение для всех пользователей в интернете. Если Maven не может найти зависимости в локальном репозитории, то автоматически начинается поиск необходимых файлов в центральном репозитории
  • Удалённые (remote) репозиторий — иногда, Maven не может найти необходимые зависимости в центральном репозитории. В этом случае, процесс сборки прерывается и в консоль выводится сообщение об ошибке. Для того, чтобы предотвратить подобную ситуацию, в Maven предусмотрен механизм Удалённого репозитория, который является репозиторием, который определяется самим разработчиком. Там могут храниться все необходимые зависимости.

  • Какая команда установляет JAR-файл в локальное хранилище?
mvn install

  • Какой порядок поиска зависимостей Maven?

Когда мы выполняем собрку проекта в Maven, автоматически начинается поиск необходимых зависимостей в следующем порядке:

  1. Поиск зависимостей в локальном репозитории Если зависимости не обнаружены, происходит переход к шагу 2.
  2. Поиск зависимостей в центральном репозитории. Если они не обнаружены и удалённый репозиторий определён, то происходит переход к шагу 4.
  3. Если удалённый репозиторий не определён, то процесс сборки прекращается и выводится сообщение об ошибке.
  4. Поиск зависимостей на удалённом репозитории, если они найдены, то происходит их загрузка в локальный репозиторий, если нет — выводится сообщение об ошибке.

  • Какие два файла настройки есть в Maven, как они называются и где расположены?

В Maven, файлы настройки называются settings. xml, и они расположены в двох местах:

  • Каталог где установлен Maven: $M2_Home/conf/settings.xml
  • Домашняя директория пользователя: ${user.home}/.m2/settings.xml

  • Что такое жизненный цикл сборки в Maven?

Жизненный цикл сборки(Lifecycle) — это чётко опредлённая последовательность фаз во время выполнения которых должын быть достигнуты определённые цели. Здесь фаза представляет собой стадию жизненного цикла.

  • Назовите основные фазы жизненного цикла сборки Maven?

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

В Maven есть следующие 3 стандартных жизненных цикла:

  • Очистка (clean) — очищает артефакты, созданные до сборки.
  • Сборка (default or build) — используется для создания приложения.
  • Создание сайта проекта (site) — генерирует документацию сайта для проекта.

  • Что делает команда mvn site?

mvn site — создает веб-сайт проекта.

  • Что делает команда mvn clean?
mvn clean — эта команда очищает целевую директорию от созданных в процессе сборки файлов.

Maven (часть 2).

Руководство по Maven. Плагины. – PROSELYTE

Если говорить в целом, то Maven – это фреймворк, который выполняет плагины. В этом фреймворке каждая задача, по сути своей, выполняется с помощью плагинов.

Плагины Maven использутся для:

  • создания jar – файла
  • создания war – файла
  • компиляции кода файлов
  • юнит-тестирования кода
  • создание отчётов проекта
  • создание документации проекта

В общей форме, плагин обеспечивает набор целей, которые могут быть выполнены с помощью такого синтаксиса:


mvn [имя-плагина]:[имя-цели]


Например, для того, чтобы выполнить компиляцию проекта нам необходимо использовать следующую команду:


mvn compiler:compile


Типы плагинов

Существует два типа плагинов в Maven:

  • Плагины сборки
    Выполняются в процессе сборки и должны быть конфигурированны внутри блока <build></build> файла pom. xml
  • Плагины отчётов
    Выполняются в процесса генерирования сайта и должны быть конфигурированны внутри блока <reporting></reporting> файла pom.xml.

Вот список, наиболее используемых плагинов:

  • clean
    Очищает цель после сборки. Удаляет директорию target.
  • compiler
    Компилирует исходные Java файлы.
  • surefire
    Запускает тесты JUnit. Создаёт отчёты о тестировании.
  • jar
    Собирает JAR файл текущего проекта.
  • war
    Собирает WAR файл текущего проекта.
  • javadoc
    Генерирует Javadoc проекта.
  • antrun
    Запускает набор задач ant из любой указанной фазы.

Для понимания того, как это работает на практике, рассмотрим следующий пример.

Пример:


<?xml version="1.0" encoding="UTF-8"?>
<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>ProselyteTutorials</groupId>
    <artifactId>MavenTutorial</artifactId>
    <version>1.0-SNAPSHOT</version>
    <profiles>
        <profile>
            <id>test</id>
            <activation>
                <file>
                    <missing>target/generated-sources/some/dir/net/proselyte/maven</missing>
                </file>
            </activation>
        </profile>
    </profiles>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3. 8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-antrun-plugin</artifactId>
                <version>1.1</version>
                <executions>
                    <execution>
                        <id>id.clean</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>run</goal>
                        </goals>
                        <configuration>
                            <tasks>
                                <echo>compile phase</echo>
                            </tasks>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>


После этого выполним в терминале следующую команду:


mvn compile


В результате выполнения команды, мы получим, примерно, следующий результат:


[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building MavenTutorial 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- maven-resources-plugin:2.3:resources (default-resources) @ MavenTutorial ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i. e. build is platform dependent!
[INFO] Copying 3 resources
[INFO] 
[INFO] --- maven-compiler-plugin:2.0.2:compile (default-compile) @ MavenTutorial ---
[INFO] Nothing to compile - all classes are up to date
[INFO] 
[INFO] --- maven-antrun-plugin:1.1:run (id.clean) @ MavenTutorial ---
[INFO] Executing tasks
     [echo] compile phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 0.620s
[INFO] Finished at: Wed Apr 27 16:21:41 EEST 2016
[INFO] Final Memory: 6M/150M
[INFO] ------------------------------------------------------------------------


Пример, приведённый выше, демонстрирует следующие ключевые концепции:

  • Плагины указываются в файле pom.xml внутри блока <plugins></plugins>
  • Каждый плагин может иметь несколько целей.
  • Мы можем определять фазу, из которой мы можем начать выполнение плагина. В примере выше мы использовали фазу compile.

На этом мы заканчиваем изучение плагинов.

В следующем уроке мы рассмотрим создание проекта Maven.

Введение в Maven — простой инструмент для автоматизации сборки — itGap

Мы начнем с быстрого вступления, а затем перечислим преимущества его использования. После всего этого мы увидим процесс его установки, а затем несколько технических терминов, которые необходимы новичку. Итак, начнем!

Что такое Maven?

Apache Maven — это программное обеспечение для управления и сборки проектов. Он основан на концепции объектной модели проекта (POM). Maven может управлять сборкой проекта, составлением отчетов и документацией из центральной части информации.

Apache Maven — это инструмент для сборки, и он выполняет эту задачу точно так же, как например Ant, который тоже является выдающимся инструментом для сборки. Это программный инструмент управления проектами, который дает новую концепцию объектной модели проекта (POM).

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

Зачем используется Maven?

Подводя итог, Maven упрощает и стандартизирует процесс сборки проекта. Он легко выполняет групповую совместную работу, компиляцию, распространение, документирование и отдельные задачи. Maven увеличивает возможность многократного использования, а также выполняет большинство задач, связанных со сборкой.

Он работает на многих этапах, таких как добавление jar-файлов в библиотеку проекта, создание отчетов и выполнение тестовых примеров Junits, создание файлов Jar, War, Ear для проекта и многое другое.

Очень важным аспектом Maven является назначение хранилищ для управления файлами JAR.

Maven может также использоваться для создания и управления проектами, написанными на таких языках, как C #, ruby ​​и других.

Давайте посмотрим на следующие преимущества Maven.

  • Его конфигурация очень минимальная
  • Имеет управляющие зависимости
  • Автоматизация всего процесса
  • Он имеет возможность запускать JUnit и другие интеграционные тесты
  • Возможность управление плагинами, тестирование и разработка
  • Стандартная и унифицированная инфраструктура среди проектов

Настройка среды Maven

Установка Maven включает в себя следующие шаги:

  • Проверьте, установлена ​​ли в системе Java. если нет то установите его
  • Проверьте, установлена ​​ли переменная среды Java. Если нет, то установите его
  • Скачайте Maven
  • Распакуйте архив maven в одной месте системы
  • Теперь добавьте папку bin из каталога apache-maven-3.6.3 в переменную среды PATH и системную переменную.
  • Откройте командную строку и выполните команду mvn -v, чтобы подтвердить установку.

Вот и все.

Чтобы получить подробные инструкции по установке, следуйте приведенному ниже руководству на YouTube по настройке среды Maven, поскольку мы не хотим, чтобы эта статья была простой для чтения и скучной.

Данное руководство для начинающих, должно включать технические термины, связанные с MAVEN. Вот некоторые из них, которые очень важны:

Maven локальный репозиторий

Maven Local Repository — это набор, в котором Maven хранит все файлы jar проекта, библиотеки или зависимости. По умолчанию имя папки установлено на .m2, а путь находиться в Libraries\Documents\.m2.

Maven Центральный репозиторий

Центральный репозиторий Maven является местоположением по умолчанию для загрузки Maven всех библиотек зависимостей проекта для использования. Для любой библиотеки, участвующей в проекте, Maven сначала просматривает папку .m2 Локального репозитория, и если он не находит нужную библиотеку, он ищет в Центральном репозитории и загружает библиотеку в локальный репозиторий.

Maven POM

POM — это XML-файл объектной модели проекта, содержащий информацию о проекте и сведения о конфигурации, необходимые Maven для разработки проекта. Он содержит значения по умолчанию для большинства проектов. Некоторые из структур, которые могут быть определены в POM, — это зависимости проекта, плагины, которые могут быть выполнены, и, конечно, профили сборки.

Элементы, используемые в создании файла pom.xml:

  • project — Проект является корневым элементом файла pom.xml.
  • modelVersion — Означает версию модели POM, с которой вы работаете.
  • groupId — подразумевает идентификатор группы проекта. Он уникален, и чаще всего вы будете применять идентификатор группы, связанный с именем корневого пакета Java.
  • artifactId — используется для предоставления названия проекта, который вы собираете.
  • Version — этот элемент состоит из номера версии проекта. Если ваш проект был выпущен в различных версиях, тогда удобно представить версию вашего проекта.

Зависимость (Dependency)

Зависимости (Dependency) — это библиотеки, которые нужны проекту. Подобно jar-файлам Log4j, jar-файлам Apache Poi, Selenium Jars — это несколько библиотек, которые требуются для проекта. Зависимости в Maven pom.xml упоминаются так:

<dependencies>

      <dependency>
         <groupId>com.companyname.groupname</groupId>
         <artifactId>App-Core-lib</artifactId>
         <version>1.0</version>
      </dependency>

</dependencies>

Плагин Surefire

Плагин Surefire необходим во время фазы тестирования жизненного цикла сборки для реализации модульных тестов приложения. Он создает отчеты в двух разных форматах, таких как обычный текстовый файл, XML-файлы, а также в HTML-файлах. Даже если вы используете инфраструктуру Junits или TestNG для создания отчетов, этот плагин необходим для использования, поскольку он помогает Maven находить тесты.

Практическое применение Maven

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

А Maven — это такой инструмент управления сборкой, который может выполнять все такие вещи, как добавление зависимостей, использование пути к классам для проецирования, автоматическое создание файлов war и jar и много других вещей.

Также рекомендуем прочитать:

  1. Книги по языку программирования Java
  2. Топ-5 последних потрясающих фреймворков на Java
  3. Топ-9 Java EE фреймворков для создания корпоративных приложений
  4. Как бесплатно получить SSL-сертификат для сайта?

Руководство по Maven. Сборка и тестирование проекта. – PROSELYTE

В предыдущем разделе мы рассмотрели создание Java приложения с помощью Maven. Теперь мы рассмотрим, как собрать и протестировать наше приложение.

Наш pom.xml файл выглядит следующим образом:


<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>net.proselyte.mavensimple</groupId>
  <artifactId>javaStudent</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>javaStudent</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>


Мы видим, что Maven автоматически добавил зависимости Junit в наш проект.

В терминале перейдём в директорию нашего проекта в папку javaStudent и напишем следующее:


mvn clean package


В результате мы получим следующий результат:


[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building javaStudent 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ javaStudent ---
[INFO] Deleting /home/proselyte/Programming/Projects/Proselyte/MavenSimpleProject/javaStudent/target
[INFO] 
[INFO] --- maven-resources-plugin:2.3:resources (default-resources) @ javaStudent ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /home/proselyte/Programming/Projects/Proselyte/MavenSimpleProject/javaStudent/src/main/resources
[INFO] 
[INFO] --- maven-compiler-plugin:2.0.2:compile (default-compile) @ javaStudent ---
[INFO] Compiling 1 source file to /home/proselyte/Programming/Projects/Proselyte/MavenSimpleProject/javaStudent/target/classes
[INFO] 
[INFO] --- maven-resources-plugin:2.3:testResources (default-testResources) @ javaStudent ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /home/proselyte/Programming/Projects/Proselyte/MavenSimpleProject/javaStudent/src/test/resources
[INFO] 
[INFO] --- maven-compiler-plugin:2.0.2:testCompile (default-testCompile) @ javaStudent ---
[INFO] Compiling 1 source file to /home/proselyte/Programming/Projects/Proselyte/MavenSimpleProject/javaStudent/target/test-classes
[INFO] 
[INFO] --- maven-surefire-plugin:2.10:test (default-test) @ javaStudent ---
[INFO] Surefire report directory: /home/proselyte/Programming/Projects/Proselyte/MavenSimpleProject/javaStudent/target/surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running net.proselyte.mavensimple.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.018 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] 
[INFO] --- maven-jar-plugin:2.2:jar (default-jar) @ javaStudent ---
[INFO] Building jar: /home/proselyte/Programming/Projects/Proselyte/MavenSimpleProject/javaStudent/target/javaStudent-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.071s
[INFO] Finished at: Wed Apr 27 17:04:01 EEST 2016
[INFO] Final Memory: 19M/190M
[INFO] ------------------------------------------------------------------------


Теперь попробуем запустить наше приложение.
Выполним в терминале следующую команду:


 cd target/classes


А затем следующую:


java net.proselyte.mavensimple.App


В результате мы получим, следующий результат:


/*Some system messages*/
Hello World!


На этом мы заканчиваем изучение данного урока.
В следующей статье мы рассмотрим внешние зависимости.

Что такое Maven целей и этапов и в чем их различие?

Жизненный цикл — это последовательность названных фаз .
Фазы выполняются последовательно. Выполнение фазы означает выполнение всех предыдущих фаз.

Плагин представляет собой набор целей , также называемых MOJO (M aven O ld J ava O bject).
Аналогия: плагин-это класс, а цели-это методы внутри класса.

Maven основан на центральной концепции жизненного цикла сборки. Внутри каждого жизненного цикла сборки есть фазы сборки, и внутри каждой фазы сборки есть цели сборки .

Мы можем выполнить либо фазу сборки, либо цель сборки. При выполнении фазы сборки мы выполняем все цели сборки в рамках этой фазы сборки. Цели сборки назначаются одной или нескольким фазам сборки. Мы также можем выполнить цель сборки напрямую.

Существует три основных встроенных жизненных цикла сборки :

  1. по умолчанию
  2. чистый
  3. сайт

Каждый жизненный цикл сборки состоит из фаз

Например, жизненный цикл default состоит из следующих этапов сборки :

◾validate - validate the project is correct and all necessary information is available
◾compile - compile the source code of the project
◾test - test the compiled source code using a suitable unit testing framework. These tests should not require the code be packaged or deployed
◾package - take the compiled code and package it in its distributable format, such as a JAR.
◾integration-test - process and deploy the package if necessary into an environment where integration tests can be run
◾verify - run any checks to verify the package is valid and meets quality criteria
◾install - install the package into the local repository, for use as a dependency in other projects locally
◾deploy - done in an integration or release environment, copies the final package to the remote repository for sharing with other developers and projects.

Таким образом, чтобы пройти через вышеперечисленные фазы, нам просто нужно вызвать одну команду:

mvn <phase> { Ex: mvn install }

Для приведенной выше команды, начиная с первой фазы, все фазы выполняются последовательно до фазы «установка». mvn может выполнить цель или фазу (или даже несколько целей или несколько фаз) следующим образом:

mvn clean install plugin:goal  

Однако, если вы хотите настроить префикс, используемый для ссылки на ваш плагин, вы можете указать префикс непосредственно через параметр конфигурации на maven-plugin-plugin в POM вашего плагина.

Фаза сборки состоит из целей плагина

Большая часть функциональности Maven находится в плагинах. Плагин предоставляет набор целей , которые могут быть выполнены с помощью следующего синтаксиса:

 mvn [plugin-name]:[goal-name]

Например, проект Java может быть скомпилирован с целью компиляции плагина компилятора, запустив mvn compiler:compile .

Жизненный цикл сборки — это список именованных фаз, которые можно использовать для приведения в порядок выполнения цели.

Цели, предоставляемые плагинами, могут быть связаны с различными фазами жизненного цикла. Например, по умолчанию цель compiler:compile связана с фазой compile , в то время как цель surefire:test связана с фазой test . Рассмотрим следующую команду:

mvn test

При выполнении предыдущей команды Maven запускает все цели, связанные с каждой из фаз, вплоть до фазы test включительно. В таком случае Maven запускает цель resources:resources , связанную с фазой process-resources , затем compiler:compile и так далее, пока, наконец, не запускает цель surefire:test .

Однако, даже если этап сборки отвечает за определенный этап жизненного цикла сборки, способ, которым он выполняет эти обязанности, может отличаться. И это делается путем объявления целей плагина, привязанных к этим этапам сборки.

Цель плагина представляет собой конкретную задачу (более тонкую, чем фаза сборки), которая способствует созданию и управлению проектом. Он может быть привязан к нулю или более фазам сборки. Цель, не привязанная к какой-либо фазе сборки, может быть выполнена вне жизненного цикла сборки прямым вызовом. Порядок выполнения зависит от порядка, в котором вызываются цель(Ы) и фаза(ы) сборки. Например, рассмотрим следующую команду. Аргументы clean и package являются фазами сборки, в то время как dependency:copy-dependencies -это цель (плагина).

mvn clean dependency:copy-dependencies package

Если это должно было быть выполнено, то сначала будет выполнена фаза clean (то есть она будет выполнять все предыдущие фазы чистого жизненного цикла плюс саму фазу clean ), а затем цель dependency:copy-dependencies , прежде чем, наконец, выполнить фазу package (и все ее предыдущие фазы сборки жизненного цикла по умолчанию).

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

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

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

Maven архитектура:

Ссылка 1
Ссылка 2

Eclipse пример для отображения жизненного цикла Maven

Maven — Добро пожаловать в Apache Maven

Добро пожаловать в Apache Maven

Apache Maven — это инструмент управления и понимания программных проектов. На основе концепции объектной модели проекта (POM) Maven может управлять сборкой проекта, отчетностью и документацией из центральной части информации.

Если вы считаете, что Maven может помочь вашему проекту, вы можете найти дополнительную информацию в разделе «О Maven». раздел навигации.Это включает в себя подробное описание того, что такое Maven и список некоторых из его основных функций.

Этот сайт разделен на следующие разделы, в зависимости от того, как вы хотите использовать Maven:

Использование Скачать, установить, запустить Maven Настроить, использовать плагины Maven и Maven
Информация для тех, кому нужно создать проект, использующий Maven Информация для разработчиков, использующих Maven для создания своих проектов, включая «10-минутный тест», который дает практический обзор основных функций Maven и список плагинов для получения дополнительной информации о каждом плагине.
Удлинить Написать плагины Maven Улучшение центрального репозитория Maven
Информация для разработчиков, пишущих плагины Maven. Информация для тех, кто может или не может использовать Maven, но заинтересован в переносе метаданных проекта в центральное хранилище.
Внести вклад Справка Maven Разработка Maven
Информация, если вы хотите принять участие.Maven — это сообщество с открытым исходным кодом, которое приветствует вклад. Информация для тех, кто в настоящее время является разработчиками Maven, или кому интересно в участии в самом проекте Maven.

Каждое руководство разделено на несколько маршрутов, которые помогут вам начать работу по определенной теме, и включает в себя справочная область и «поваренная книга» общих примеров.

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

Как получить поддержку

Поддержка Maven доступна в различных формах.

Для начала поищите документацию, система управления проблемами, вики или архивы списков рассылки на посмотреть, была ли проблема решена или о ней сообщалось ранее.

Если о проблеме не сообщалось ранее, рекомендуется обратиться за помощью. подписаться на список рассылки пользователей Maven.Многие другие пользователи и разработчики Maven ответит на ваши вопросы там, и ответ будет сохранен для других в будущем.

Вы также можете связаться с разработчиками Maven через IRC.

Фонд программного обеспечения Apache

Maven является частью Apache Software Foundation. Мы хотели бы поблагодарить спонсоры, оказывающие финансовую помощь фонду. Для получения дополнительной информации о том, как вы можете поддержать фонд, см. страницу спонсорства.

Вы также можете посетить мероприятия Apache. Не стесняйтесь спрашивать в списке рассылки Maven User если там будут члены команды Maven. Это может быть прекрасная возможность встретиться с ними.

Maven — Maven за 5 минут

Установка

Maven — это инструмент Java, поэтому для продолжения у вас должна быть установлена ​​Java.

Сначала загрузите Maven и следуйте инструкциям по установке. После этого введите в терминале или в командной строке следующее:

Он должен распечатать вашу установленную версию Maven, например:

 Apache Maven 3.6.3 (cecedd343002696d0abb50b32b541b8a6ba2883f)
Главная страница Maven: D: \ apache-maven-3.6.3 \ apache-maven \ bin \ ..
Версия Java: 1.8.0_232, поставщик: AdoptOpenJDK, среда выполнения: C: \ Program Files \ AdoptOpenJDK \ jdk-8.0.232.09-hotspot \ jre
Локаль по умолчанию: en_US, кодировка платформы: Cp1250
Название ОС: "windows 10", версия: "10.0", арка: "amd64", семейство: "windows" 

В зависимости от настроек вашей сети вам может потребоваться дополнительная настройка. При необходимости ознакомьтесь с Руководством по настройке Maven.

Если вы используете Windows, вам следует изучить Предварительные требования для Windows , чтобы убедиться, что вы готовы использовать Maven в Windows.

Создание проекта

Вам понадобится место для размещения вашего проекта, создание где-нибудь каталога и запуск оболочки в этом каталоге. В командной строке выполните следующую цель Maven:

 mvn архетип: сгенерировать -DgroupId = com.mycompany.app -DartifactId = my-app -DarchetypeArtifactId = maven-archetype-quickstart -DarchetypeVersion = 1.4 -DinteractiveMode = false 

Если вы только что установили Maven, первый запуск может занять некоторое время.Это связано с тем, что Maven загружает самые последние артефакты (jar-файлы плагинов и другие файлы) в ваш локальный репозиторий. Вам также может потребоваться выполнить команду несколько раз, прежде чем она будет успешной. Это связано с тем, что время ожидания удаленного сервера может истечь до завершения загрузки. Не волнуйтесь, есть способы исправить это.

Вы заметите, что цель сгенерировать создала каталог с тем же именем, что и artifactId. Перейдите в этот каталог.

В этом каталоге вы увидите следующую стандартную структуру проекта.

 мое приложение
| - pom.xml
`- src
    | - главная
    | `- java
    | `- com
    | `- моя компания
    | `- приложение
    | `- App.java
    `- тест
        `- java
            `- com
                `- моя компания
                    `- приложение
                        `- AppTest.java 

Каталог src / main / java содержит исходный код проекта, каталог src / test / java содержит исходный код теста, а каталог pom.xml — это объектная модель проекта или POM.

ПОМ

Файл pom.xml — это ядро ​​конфигурации проекта в Maven. Это единый файл конфигурации, который содержит большую часть информации, необходимой для создания проекта так, как вы хотите. POM огромен и может быть устрашающим по своей сложности, но совсем необязательно разбираться во всех тонкостях, чтобы использовать его эффективно. POM этого проекта:

 <проект 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">
   4.0.0 

   com.mycompany.app 
   мое приложение 
   1.0-SNAPSHOT 

  <свойства>
     1.7 
     1,7 
  

  <зависимости>
    <зависимость>
       junit 
       junit 
       4.12 
       тест 
    
  
 
Что я только что сделал?

Вы выполнили архетип цели Maven: сгенерировать и передали этой цели различные параметры. Префикс архетип — это плагин, который обеспечивает цель.Если вы знакомы с Ant, вы можете подумать, что это похоже на задачу. Этот архетип : сгенерировать цель создал простой проект, основанный на архетипе maven-archetype-quickstart. На данный момент достаточно сказать, что плагин представляет собой набор из целей с общим общим назначением. Например, jboss-maven-plugin, цель которого — «работать с различными элементами jboss».

Создайте проект

Командная строка распечатает различные действия и завершится следующим:

...
[ИНФОРМАЦИЯ] ----------------------------------------------- -------------------------
[ИНФОРМАЦИЯ] СОЗДАТЬ УСПЕХ
[ИНФОРМАЦИЯ] ----------------------------------------------- -------------------------
[ИНФОРМАЦИЯ] Общее время: 2,953 с.
[INFO] Окончание: 2019-11-24T13: 05: 10 + 01: 00
[ИНФОРМАЦИЯ] ----------------------------------------------- ------------------------- 

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

  1. подтвердить
  2. источники-генераторы
  3. процессы-источники
  4. генерировать ресурсы
  5. процесс-ресурсы
  6. compile

Вы можете протестировать недавно скомпилированный и упакованный JAR с помощью следующей команды:

 java -cp цель / мое-приложение-1.0-SNAPSHOT.jar com.mycompany.app.App 

Который напечатает наиболее существенное:

Java 9 или новее

По умолчанию ваша версия Maven может использовать старую версию maven-compiler-plugin , несовместимую с Java 9 или более поздними версиями. Чтобы настроить таргетинг на Java 9 или более позднюю версию, вы должны как минимум использовать версию 3.6.0 плагина maven-compiler-plugin и установить для свойства maven.compiler.release версию Java, на которую вы нацеливаете (например, 9, 10, 11 , 12 и т. Д.).

В следующем примере мы настроили наш проект Maven для использования версии 3.8.1 из maven-compiler-plugin и целевой Java 11:

 <недвижимость>
         11 
    

    <сборка>
        
            <плагины>
                <плагин>
                     org.apache.maven.plugins 
                     maven-compiler-plugin 
                    <версия> 3.8.1 
                
            
        
     

Чтобы узнать больше о параметре javac --release , см. JEP 247.

Запуск инструментов Maven

Фазы Maven

Хотя это и не полный список, это наиболее распространенные этапы жизненного цикла по умолчанию .

  • проверить : подтвердить правильность проекта и доступность всей необходимой информации
  • compile : скомпилировать исходный код проекта
  • test : протестируйте скомпилированный исходный код с помощью подходящей среды модульного тестирования.Эти тесты не должны требовать, чтобы код был упакован или развернут
  • пакет : возьмите скомпилированный код и упакуйте его в распространяемый формат, например JAR.
  • integration-test : обработайте и разверните пакет, если необходимо, в среде, где можно запускать интеграционные тесты
  • verify : запустить любые проверки, чтобы убедиться, что пакет действителен и соответствует критериям качества
  • установить : установить пакет в локальный репозиторий для использования в качестве зависимости в других проектах локально
  • развертывание : выполняется в среде интеграции или выпуска, последний пакет копируется в удаленный репозиторий для совместного использования с другими разработчиками и проектами.

Есть два других жизненных цикла Maven, которые следует отметить помимо приведенного выше списка по умолчанию . Их

  • clean : очищает артефакты, созданные предыдущими сборками
  • сайт : создает документацию сайта для этого проекта

Фазы фактически сопоставлены с основными целями. Конкретные цели, выполняемые на каждом этапе, зависят от типа упаковки проекта. Например, package выполняет jar: jar , если тип проекта — JAR, и war: war , если тип проекта — как вы уже догадались — WAR.

Интересно отметить, что этапы и цели могут выполняться последовательно.

 mvn чистая зависимость: пакет копий-зависимостей 

Эта команда очистит проект, скопирует зависимости и упакует проект (конечно, выполнит все фазы до , пакета ).

Создание сайта

На этом этапе создается сайт на основе информации о пом. Вы можете посмотреть документацию, созданную в разделе target / site .

Что такое Maven? Рамки проекта | Использует

Подробности

Что такое Maven?

Maven — это инструмент автоматизации и управления, разработанный Apache Software Foundation. Он написан на языке Java для создания проектов, написанных на C #, Ruby, Scala и других языках. Он позволяет разработчикам создавать проекты, зависимости и документацию, используя объектную модель проекта и плагины. Он имеет такой же процесс разработки, что и ANT, но он более продвинутый, чем ANT.

Maven также может встраивать любое количество проектов в желаемый результат, такой как jar, war, metadata.

Первоначально он был выпущен 13 июля 2004 года. На языке идиш Maven означает «накопитель знаний».

В этом руководстве по Maven для начинающих вы изучите основы Maven, например:

Каким образом Maven может помочь мне в процессе разработки?

Maven помогает разработчикам упростить создание проектов на основе Java. Доступность новой функции, созданной или добавленной в Maven, может быть легко добавлена ​​в проект в конфигурации Maven.Это увеличивает производительность проекта и процесса строительства.

Основная особенность Maven заключается в том, что он может автоматически загружать библиотеки зависимостей проекта.

Ниже приведены примеры некоторых популярных IDE, поддерживающих разработку с помощью Maven Framework:

  • Eclipse
  • IntelliJ IDEA
  • JBuilder
  • NetBeans
  • MyEclipse

  • Build
  • Документация
  • Процессы, которыми можно управлять с помощью maven
  • Отчетность
  • Зависимости
  • SCM
  • Релизы
  • Распространение
  • список рассылки
  • Архитектура Maven

    Архитектура Maven включает в себя jar плагина, файл кода и т. Д.

    Архитектура Maven

    Как использовать Maven

    • Для настройки Maven на Java необходимо использовать объектную модель проекта, которая хранится в файле pom.xml.
    • POM включает все параметры конфигурации, относящиеся к Maven. Плагины можно настраивать и редактировать в теге файла pom.xml. И разработчик может использовать любой плагин без детализации каждого плагина.
    • Когда пользователь начинает работать над Maven Project, он предоставляет настройки конфигурации по умолчанию, поэтому пользователю не нужно добавлять каждую конфигурацию в pom.xml

    Шаги / процесс, участвующие в создании проекта:

    • Добавить / написать код для создания приложения и обработать его в репозитории исходного кода
    • Изменить конфигурацию / pom.XML / сведения о плагине
    • Создать приложение
    • Сохранить вывод процесса сборки в виде файла WAR или EAR в локальное расположение или на сервер
    • Получите файл из локального местоположения или сервера и разверните файл на производственном сайте или клиентском сайте
    • Обновлен документ приложения с указанием даты и номера обновленной версии приложение
    • создает и генерирует отчет в соответствии с приложением или требованием.

    Описание:

    • Maven — это инструмент автоматизации и управления.
    • Инструмент Maven написан на языке Java и используется для создания и управления проектами, написанными на C # (C Sharp), Ruby, Scala и других языках.
    • Разработчики могут легче создавать проекты на основе Java с помощью инструмента Maven.
    • Для настройки Maven необходимо использовать объектную модель проекта, которая хранится в файле pom.xml.

    Что такое Maven?

    Объяснение Maven

    Apache Maven — это инструмент автоматизации сборки для проектов Java.Подумайте о Ant или Make, но намного мощнее и проще в использовании. Если вам когда-либо приходилось иметь дело со сборкой Java-проекта с зависимостями или особыми требованиями к сборке, вы, вероятно, пережили разочарования, которые Maven стремится устранить.

    В этой статье я объясню немного больше об этом инструменте, о том, как он используется, и, надеюсь, отвечу на ваш вопрос — Что такое Maven?

    Чем полезен Maven?

    Maven является проектом с открытым исходным кодом под Apache с 2003 года, начиная с Sonatype до этого.Учитывая его сильную поддержку и огромную популярность, Maven является очень стабильным и многофункциональным, предоставляя многочисленные плагины, которые могут делать что угодно, от создания PDF-версий документации вашего проекта до создания списка последних изменений из вашего SCM. И все, что требуется для добавления этой функциональности, — это небольшой дополнительный XML-код или дополнительный параметр командной строки.

    У вас много зависимостей? Без проблем. Maven подключается к удаленным репозиториям (или вы можете настроить свои собственные локальные репозитории) и автоматически загружает все зависимости, необходимые для сборки вашего проекта.

    Например, допустим, у вас есть проект, в котором используется инструмент маршрутизации Apache Camel версии 2.10.6, но затем выходит новая версия Camel, 2.11.1. Вместо того, чтобы заходить на веб-сайт Apache, загружать дистрибутив 2.11.1 и заменять им 2.10.6, вы можете просто указать Maven использовать новый дистрибутив, и работа будет выполнена за вас. Не то чтобы сложно загрузить один пакет Java и поместить его в папку проекта, но подумайте о том, чтобы делать это для нескольких зависимостей каждый раз при обновлении одного из них.Это небольшой промежуток времени, но он быстро накапливается.

    Как вы используете Maven?

    Использовать Maven чрезвычайно просто, если вы изучите несколько основных концепций. Каждый проект содержит файл, называемый POM (объектная модель проекта), который представляет собой просто XML-файл, содержащий сведения о проекте. Некоторые из этих деталей могут включать имя проекта, версию, тип пакета, зависимости, плагины Maven и т. Д.

    (очень) простой файл pom.xml может выглядеть примерно так:

      <проект 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/maven-v4_0_0.xsd">
      
       4.0.0 
       com.stackabuse.myproject 
       мойпроект 
      <упаковка> банка 
       1.0-SNAPSHOT 
      
       мойпроект 
       http://stackabuse.com 
      
      <сборка>
        <плагины>
          <плагин>
             maven-myquery-plugin 
            <версия> 1.0 
            <конфигурация>
               http://foobar.com 
               10 
              <варианты>
                
                
              
            
          
        
      
      
      <зависимости>
      <зависимость>
       org.apache.camel 
       верблюжье ядро ​​
      <версия> 2.11.1 
      
      <зависимость>
       org.apache.camel 
       верблюд-http 
       2.11.1 
      
        <зависимость>
           junit 
           junit 
           3.8.1 
           тест 
        
      
      
    
      

    Не беспокойтесь обо всех мелких деталях этого XML, просто обратите внимание на то, какое содержимое находится в pom.xml, например имя, версия и зависимости. Здесь будет происходить большая часть вашего взаимодействия с Maven, а остальное — через вызовы командной строки.

    Чтобы запустить Maven, все, что вам нужно сделать, это перейти в папку проекта и запустить:

      mvn [команда]
      

    Команда может быть несколькими вещами, но назвать несколько:

    • test : запускает все тесты для проекта
    • clean : Удаляет все старые файлы сборки
    • пакет : пакетирует проект в jar (или другой формат в зависимости от того, что было указано)
    • install : помещает проект в локальный репозиторий Maven
    • deploy : помещает проект в удаленный репозиторий Maven

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

    Узнать больше

    Хотите узнать больше об Apache Maven? Попробуйте пройти онлайн-курс, такой как Maven Crash Course, в котором будет гораздо больше деталей, чем в этой статье. Он научит вас использовать этот важнейший инструмент автоматизации Java, например, настроить его, ключевые концепции и даже интегрировать его в Eclipse. Серьезно, сэкономьте время и извлеките уроки из одного из лучших ресурсов.

    Ресурсы

    Что такое Maven? | Rebel

    В этом блоге мы даем обзор Maven, как он используется, как работает, а также сравниваем преимущества и популярность Maven, Gradle и Ant.

    Что такое Maven?

    Maven, или MVN, представляет собой мощный инструмент управления проектами программного обеспечения, используемый в среде разработки Java для управления и создания проектов, а также для поддержания зависимостей.

    Для чего используется Maven?

    Без инструмента сборки управление и создание приложений Java было бы очень болезненным, долгим и часто повторяющимся процессом. С Maven легко поддерживать библиотеки проекта, используя систему зависимостей, и строить проект, используя одну из целей.

    Как работает Maven?

    Сам Maven требует, чтобы на вашем компьютере была установлена ​​Java. Вы можете проверить, установлен ли Maven на вашем компьютере, запустив «mvn -v» в командной строке / терминале. Maven основан на конфигурации объектной модели проекта (POM), которая хранится в одноименном XML-файле — pom.xml. Это структурированный формат, описывающий проект, его зависимости, плагины и цели.

      
    <проект 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">
         4.0.0 
    
         org.example 
         SampleProject 
         1.0-SNAPSHOT 
    
        <зависимости>
            <зависимость>
                 junit 
                 junit 
                <версия> 4.13 
                 тест 
            
        
    
    
      

    В приведенном выше примере представлена ​​структура простого проекта, который имеет одну зависимость от сторонней библиотеки JUnit. Этот файл всегда находится в корне папки проекта, и при выполнении команд управления Maven используется файл из текущего местоположения. Maven также поддерживает многомодульные проекты, где каждый из модулей представлен отдельным файлом pom.xml хранится в соответствующем каталоге.

    Плагины Maven и жизненный цикл сборки

    Все плагины вызываются с использованием следующего синтаксиса команды «mvn [plugin_name]: [goal]». Цель в основном представляет функцию плагина, которую пользователь хочет выполнить. В Maven уже есть несколько плагинов, поэтому вы часто можете видеть, что он используется без [plugin_name], например «mvn compile». Поскольку во время сборки приложения иногда вызывается больше подключаемых модулей, Maven определяет жизненный цикл сборки.Это используется для связывания плагина с одной из фаз и когда фаза выполняется, так что это плагин. Maven определяет жизненный цикл по умолчанию по следующим этапам:

    • проверка — проверка правильности проекта и доступность всей необходимой информации
    • компиляция — компиляция исходного кода проекта
    • проверка — проверка скомпилированного исходный код с использованием подходящей среды модульного тестирования. Эти тесты не должны требовать, чтобы код был упакован или развернут.
    • package — возьмите скомпилированный код и упакуйте его в его распространяемом формате, таком как JAR.
    • verify — запускает любые проверки результатов интеграционных тестов для обеспечения соответствия критериям качества
    • install — устанавливает пакет в локальный репозиторий для использования в качестве зависимости в других проектах локально
    • deploy — выполнено в среде сборки копирует окончательный пакет в удаленный репозиторий для совместного использования с другими разработчиками и проектами.

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

    Получить шпаргалку

    Популярна ли Maven?

    Maven, без сомнения, один из самых популярных инструментов сборки на Java. Вместе с Gradle, другим инструментом сборки с аналогичной функциональностью, они используются более чем в 90% проектов Java. Остальные проекты используют Ant или другие проприетарные инструменты сборки.

    Изображение: Отчет Java Developer Productivity Report за 2020 год

    Что касается каждого проекта, могут быть разные причины, по которым они выбирают Maven.Для многих самые большие преимущества Maven заключаются в том, как он управляет проектом и работает с зависимостями.

    Maven против Gradle

    Хотя оба инструмента используются с одной и той же целью, а именно для автоматизации процесса сборки приложения, все же существуют некоторые существенные различия. В то время как Maven использует XML (pom.xml) для конфигурации проекта, Gradle имеет свой собственный предметно-ориентированный язык (DSL) на основе кода Groovy (build.gradle) или Kotlin (build.gradle.kts).

    Преимущества Maven vs.Gradle
    Преимущества Maven Преимущества Gradle
    Управление зависимостями Официальный инструмент сборки для Android
    POM — легче адаптировать Лучшая производительность
    Доступно множество плагинов Использование Groovy / Kotlin
    Интеграция IDE Гибкость
    Управление зависимостями

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

    Блог по теме: Ускорение сборки Gradle

    Maven против Ant

    Apache Ant является предшественником Apache Maven. Впервые выпущенный в 2000 году, Ant был разработан как замена инструмента сборки Make, который в прошлом широко использовался при разработке программного обеспечения. Используя XML-файл, Ant используется для автоматизации задач сборки. Но без добавления плагина Apache Ivy Ant не поддерживает управление зависимостями.

    Преимущества Maven по сравнению с Ant
    Преимущества Maven Преимущества Ant
    Управление зависимостями Гибкость
    POM — легче адаптировать Нет соглашения о принудительном кодировании
    Многие плагины доступно Нет принудительной структуры проекта
    Интеграция IDE

    Ограничения Ant были причиной, по которой большая часть команды разработчиков позже перешла на Maven, который является не только инструментом сборки, но и сложным инструментом, который помогает с управлением жизненным циклом программного обеспечения.Есть еще ряд проектов, которые используют Ant в качестве основного инструмента сборки, включая SAP Hybris.

    Заключительные мысли

    Без таких инструментов сборки, как Maven или Gradle, разработка и сопровождение проектов были бы болезненным процессом. Maven — отличный инструмент, который помогает не только создавать приложение, но и управляет всеми зависимостями. Gradle занимает значительную часть рынка инструментов сборки Java и в значительной степени фокусируется на той же функциональной цели — управлении процессом сборки. Разница в том, как работают оба инструмента.Успешный предшественник, Apache Ant, все еще существует с нами, но его рыночная доля сейчас очень мала.

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

    Дополнительные ресурсы

    Если вы хотите услышать дополнительное обсуждение Maven и его места в пространстве инструментов сборки Java, обязательно посмотрите этот веб-семинар. В нем анализируются результаты нашего опроса разработчиков Java за 2020 год, включая комментарии по основным технологиям, которые сегодня используются в приложениях Java.

    Если вам нужен дополнительный контент, относящийся к Maven, стоит ознакомиться с приведенными ниже ссылками.

    Сегодня оптимизация процессов разработки важна как никогда.Так какая проблема встает на пути почти каждого разработчика Java? Повторное развертывание! Если вы готовы пропустить повторное развертывание и вернуться к кодированию, попробуйте JRebel. JRebel позволяет разработчикам пропускать повторное развертывание и поддерживать состояние приложения, чтобы разработчики могли продолжать делать то, что у них получается лучше всего, создавая потрясающие приложения Java.

    Попробовать JRebel бесплатно

    Учебное пособие по изучению Maven — javatpoint

    Учебник

    Maven предоставляет базовые и расширенные концепции технологии apache maven . Наш учебник maven разработан для начинающих и профессионалов.

    Maven — это мощный инструмент управления проектами , основанный на POM (объектной модели проекта). Он используется для сборки проектов, зависимостей и документации.

    Он упрощает процесс сборки, как ANT. Но он слишком продвинут, чем ANT.

    Текущая версия Maven — 3.


    Понимание проблемы без Maven

    Есть много проблем, с которыми мы сталкиваемся при разработке проекта. Они обсуждаются ниже:

    1) Добавление набора Jar-файлов в каждый проект: В случае фреймворков struts, spring, hibernate, нам нужно добавить набор jar-файлов в каждый проект.Он также должен включать все зависимости jar-файлов.

    2) Создание правильной структуры проекта: Мы должны создать правильную структуру проекта в сервлете, стойках и т. Д., Иначе он не будет выполнен.

    3) Сборка и развертывание проекта: Нам необходимо собрать и развернуть проект, чтобы он мог работать.


    Что он делает?

    Maven упрощает вышеупомянутые проблемы. Он выполняет в основном следующие задачи.

    1. Это упрощает сборку проекта
    2. Он обеспечивает единый процесс сборки (проект maven может использоваться всеми проектами maven)
    3. Он предоставляет информацию о проекте (документ журнала, источники с перекрестными ссылками, список рассылки, список зависимостей, отчеты модульного тестирования и т. Д.)
    4. Легко перейти на новые функции Maven

    Apache Maven помогает управлять

    • Строит
    • Документация
    • Ремонт
    • SCM
    • Релизы
    • Распределение

    Что такое Build Tool

    Инструмент сборки позаботится обо всем, чтобы построить процесс. Это делает следующее:

    • Создает исходный код (если используется автоматически созданный код)
    • Создает документацию из исходного кода
    • Компилирует исходный код
    • Скомпилированный код пакетов в JAR из ZIP-файла
    • Устанавливает упакованный код в локальном репозитории, репозитории сервера или центральном репозитории

    Индекс Maven


    Maven в Eclipse

    Интервью с Maven


    Знаете ли вы? Производительность, совместимость, сборки и многое другое

    — Stackify

    Gradle — один из нескольких инструментов разработки Java, представленных в Комплексном руководстве разработчика Java от Stackify, но это не единственный инструмент автоматизации сборки, который следует учитывать.Maven — более старая и часто используемая альтернатива, но какая система сборки лучше всего подходит для вашего проекта? С другими инструментами, такими как Spring, позволяющими разработчикам выбирать между двумя системами, в сочетании с растущим числом интеграций для обеих, решение в значительной степени зависит от вас.

    Размер вашего проекта, ваши потребности в настройке и несколько других переменных могут помочь вам в выборе. Давайте взглянем.



    Что такое Gradle?

    Gradle — это система автоматизации сборки с полностью открытым исходным кодом, использующая концепции, которые вы видите в Apache Maven и Apache Ant.Он использует предметно-ориентированный язык, основанный на языке программирования Groovy, что отличает его от Apache Maven, который использует XML для конфигурации своего проекта. Он также определяет порядок выполнения задач с помощью ориентированного ациклического графа.

    Несколько разработчиков создали Gradle и впервые выпустили его в 2007 году, а в 2013 году он был принят Google в качестве системы сборки для проектов Android. Он был разработан для поддержки многопроектных сборок, которые, как ожидается, будут довольно большими. Он также позволяет постепенно добавлять в вашу сборку, потому что знает, какие части вашего проекта обновляются.Задачи, зависящие от обновленных деталей, больше не выполняются повторно. На данный момент последней стабильной версией является версия 3.4, выпущенная в феврале 2017 года. Она поддерживает разработку и последующее развертывание с использованием Java, Scala и Groovy, а в будущем будут представлены другие рабочие процессы и языки проекта.

    Что такое Maven?

    Maven используется для автоматизации сборки проектов с использованием Java. Это помогает вам определить, как построено конкретное программное обеспечение, а также его различные зависимости.Он использует файл XML для описания проекта, который вы создаете, зависимостей программного обеспечения в отношении сторонних модулей и частей, порядка сборки, а также необходимых подключаемых модулей. Существуют заранее определенные цели для таких задач, как упаковка и компиляция.

    Maven загрузит библиотеки и плагины из разных репозиториев, а затем поместит их все в кэш на вашем локальном компьютере. Хотя он в основном используется для проектов Java, вы можете использовать его для Scala, Ruby и C #, а также для множества других языков.

    Gradle vs. Maven

    Существуют некоторые фундаментальные различия в способах построения двух систем. Gradle основан на графике зависимостей задач, в котором задачи — это вещи, которые выполняют работу, в то время как Maven основан на фиксированной и линейной модели фаз. В Maven цели привязаны к фазам проекта, а цели выполняют ту же функцию, что и задачи Gradle, являясь «вещами, которые выполняют работу».

    С точки зрения производительности, оба позволяют параллельную работу многомодульных сборок.Однако Gradle допускает инкрементные сборки, потому что он проверяет, какие задачи обновляются, а какие нет. Если это так, то задача не выполняется, что сокращает время сборки. Другие отличительные особенности производительности, которые вы можете найти в Gradle, включают:

    • Инкрементальные компиляции для классов Java
    • Избегание компиляции для Java
    • Использование API для инкрементных подзадач
    • Демон компилятора, который также значительно ускоряет компиляцию

    Когда речь идет об управлении зависимостями, и Gradle, и Maven могут обрабатывать динамические и транзитивные зависимости, использовать сторонние кеши зависимостей и читать формат метаданных POM.Вы также можете объявлять версии библиотеки через определение централизованного управления версиями и применять централизованное управление версиями. Оба загружают транзитивные зависимости из своих репозиториев артефактов. У Maven есть Maven Central, а у Gradle есть JCenter, и вы также можете определить свой собственный репозиторий частной компании. Если требуется несколько зависимостей, Maven может загрузить их одновременно.

    Gradle, однако, выигрывает, когда дело доходит до зависимостей API и реализации, а также, по сути, позволяя одновременное использование безопасных кешей.Он также хранит метаданные репозитория вместе с кэшированными зависимостями, гарантируя, что два или более проектов, использующих один и тот же кеш, не будут перезаписывать друг друга, и он имеет кеш на основе контрольной суммы и может синхронизировать кеш с репозиторием. Кроме того, Gradle совместим с метаданными IVY, что позволяет вам определять собственные правила, чтобы указать версию для динамической зависимости и разрешать конфликты версий. Они недоступны в Maven.

    Другие функции управления зависимостями, которые вы можете найти только в Gradle:

    • Использование правил замены для совместимых библиотек
    • Использование правил ReplacedBy
    • Лучшее разрешение метаданных
    • Возможность динамически заменять зависимости проекта внешними , и наоборот

    Gradle также упрощает работу с составными сборками и позволяет работать со специальными и постоянными составными сборками, а также комбинировать различные сборки и импортировать составную сборку в Eclipse of IntelliJ. ИДЕЯ.

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

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

    Примеры кода

    При сравнении Ant, Gradle и Maven Нареш Джоши сравнивает код, необходимый для создания сценария сборки, который компилируется, выполняет статический анализ, запускает модульные тесты и создает файлы JAR в Programming Mitra.

    Вот код, необходимый для этого с Maven:

     
    
     4.0.0 
     com.programming.mitra 
     инструменты для сборки Java 
    <упаковка> банка 
     1.0 
    
    <зависимости>
    <зависимость>
     junit 
     junit 
    <версия> 4.11 
    
    
    
    <сборка>
    <плагины>
    <плагин>
     org.apache.maven.plugins 
     maven-compiler-plugin 
     2.3.2 
    
    
    
    
     

    Чтобы запустить цель Maven, которая создает файл JAR, вы должны выполнить следующее:

     mvn package
     

    Обратите внимание, что с помощью этого кода вы устанавливаете параметры, но не указываете задачи, которые необходимо выполнить.Вы можете добавить плагины (такие как Maven CheckStyle, FindBugs и PMD) для выполнения статического анализа в качестве единой цели вместе с модульными тестами, но вы захотите указать путь к конфигурации стиля таможенной проверки, чтобы убедиться, что он не сработает при ошибке. , используя такой код, как:

     <плагин>
     org.apache.maven.plugins 
     maven-checkstyle-plugin 
     2.12.1 
    <казни>
    <выполнение>
    <конфигурация>
     config / checkstyle / checkstyle.xml 
     истина 
     истина 
    
    <цели>
     проверить 
    
    
    
    
    <плагин>
     org.codehaus.mojo 
     findbugs-maven-plugin 
     2.5.4 
    <казни>
    <выполнение>
    <цели>
     проверить 
    
    
    
    
    <плагин>
     org.apache.maven.plugins 
     maven-pmd-plugin 
     3.1 
    <казни>
    <выполнение>
    <цели>
     проверить 
    
    
    
    
     

    Чтобы достичь цели, выполните следующее:

     mvn verify
     

    Требуется довольно много кода XML для выполнения некоторых основных и общих задач, и по этой причине проекты в Maven с большим количеством задач и зависимостей могут привести к тому, что pom.xml, которые содержат от сотен до тысяч строк кода.

    Для сравнения приведем пример кода build.gradle, который дает аналогичный результат:

     apply plugin: 'java'
    применить плагин: 'checkstyle'
    применить плагин: 'findbugs'
    применить плагин: 'pmd'
    
    версия = '1.0'
    
    репозитории {
        mavenCentral ()
    }
    
    dependencies {
        Группа testCompile: 'junit', имя: 'junit', версия: '4.11'
    }
     

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

     gradle tasks --all
     

    Как выбрать

    В целом, оба инструмента имеют свои сильные и слабые стороны.

    • Индивидуальные сборки. С помощью Maven вы можете легко определить метаданные и зависимости своего проекта, но создание полностью настраиваемой сборки может стать кошмаром для пользователей Maven. POM-файл может легко раздуться по мере роста вашего проекта и впоследствии может стать нечитаемым XML-файлом.
    • Управление зависимостями и структура каталогов. Тем не менее, Maven обеспечивает простое, но эффективное управление зависимостями, а поскольку он имеет структуру каталогов для ваших проектов, у вас есть своего рода стандартный макет для всех ваших проектов. Он использует декларативный XML-файл для своего POM-файла и имеет множество плагинов, которые вы можете использовать. Gradle использует структуру каталогов, которую вы видите в Maven, но ее можно настроить. Он также использует тот же формат GAV, который Maven использует для идентификации артефактов.
    • Плагины и интеграции. Maven также поддерживает широкий спектр этапов жизненного цикла сборки и легко интегрируется со сторонними инструментами, такими как серверы CI, плагины покрытия кода и системы репозиториев артефактов, среди прочего. Что касается плагинов, то сейчас количество доступных плагинов растет, и есть крупные поставщики, которые имеют плагины, совместимые с Gradle. Однако для Maven все еще доступно больше плагинов по сравнению с количеством, доступным для Gradle.
    • Гибкость.С другой стороны, Gradle очень гибок и основан на скрипте. На Gradle было бы легко создавать собственные сборки. Однако, поскольку Gradle фактически новичок, количество разработчиков, знающих Gradle наизнанку, может быть ограничено.

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

    Дополнительные ресурсы и руководства по Gradle и Maven

    Для дальнейшего чтения и получения дополнительной информации, в том числе полезных руководств, посетите следующие ресурсы:

    • Что такое нагрузочное тестирование? Как это работает, инструменты, руководства и многое другое — 5 февраля 2021 г.
    • Americaneagle.com и ROC Commerce остаются впереди с Retrace — 25 сентября 2020 г.
    • Новые цены Stackify: все, что вам нужно знать — 9 сентября 2020 г.
    • ИННОВАТОРЫ ПРОТИВ COVID 19 Мэтт Уотсон, генеральный директор Stackify, советует предпринимателям сосредоточиться на вещах, которые делают их счастливыми, независимо от того, является ли работа огромным пожаром в мусорном контейнере — 2 сентября 2020 г.
    • Stackify присоединяется к 2020 Inc.

    Добавить комментарий

    Ваш адрес email не будет опубликован. Обязательные поля помечены *

    Theme: Overlay by Kaira Extra Text
    Cape Town, South Africa