в чем разница между <parent></parent>и<dependency><dependency> в maven? [дубликат]

avatar
jiangke
8 апреля 2018 в 08:05
2296
4
6

В моем проекте я всегда использую <dependency><dependency>, но я могу видеть <parent></parent> в некоторых проектах pom.xml например:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.2.RELEASE</version>
</parent>

поэтому я хочу знать, когда его использовать.

Источник
Thorbjørn Ravn Andersen
8 апреля 2018 в 10:07
0

Родительский pom, по сути, является оператором включения в текущем pom.

Ответы (4)

avatar
davidxxx
8 апреля 2018 в 09:27
6

<parent> надмножество <dependencies>

Элементы

<parent> и <dependencies> — это две разные вещи, но между ними существует важная связь.

Проще говоря, parent определяет родительский pom текущего pom, а dependencies определяет фактические зависимости текущего pom.
Родительский pom может определять dependencies, но также и многие другие вещи, унаследованные дочерним проектом Maven (и особенно элемент dependencyManagement и элемент build, которые позволяют настраивать многие вещи), поэтому можно в некотором роде рассматривать как надмножество элемента dependencies.
Вот список элементов , унаследованных от родительского pom:

groupId
version
description
url
inceptionYear
organization
licenses
developers
contributors
mailingLists
scm
issueManagement
ciManagement
properties
dependencyManagement
dependencies
repositories
pluginRepositories
build
plugin executions with matching ids
plugin configuration
etc.
reporting
profiles

Как использовать dependencies и как использовать <parent>?

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


Ваш пример идеально подходит для иллюстрации последствий для клиентских проектов использования <parent> или dependencies в качестве альтернативы.

1) С родительским наследником

Здесь проект наследуется от spring-boot-starter-parent pom :

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.2.RELEASE</version>
</parent>

Как следствие, проект унаследует все, что определено в dependencies и dependencyManagement, но он также унаследует от элемента <build>, определенного в super pom.

Например, у вас будет встроенный плагин компилятора Maven, настроенный на Java 8 и UTF-8 (которую вы, конечно, можете переопределить в своем дочернем проекте):

<properties>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
    <resource.delimiter>@</resource.delimiter>
    <maven.compiler.source>${java.version}</maven.compiler.source>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.target>${java.version}</maven.compiler.target>
</properties>

Кроме того, некоторые другие подключаемые модули, потенциально полезные для проекта Spring Boot, также будут определены в суперпомпе и будут унаследованы вашим проектом, например:

<pluginManagement>
  <plugins>
     ...
    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <executions>
            <execution>
                <goals>
                    <goal>repackage</goal>
                </goals>
            </execution>
        </executions>
        <configuration>
            <mainClass>${start-class}</mainClass>
        </configuration>
    </plugin>
    ...
  </plugins>
</pluginManagement>

Обратите внимание, что родительский pom может определять dependencies, напрямую унаследованный дочерними проектами, но не обязательно.
Например, spring-boot-starter-parent не определяет какие-либо dependency, напрямую унаследованные дочерними проектами, а вместо определения dependency в <dependencyManagement><dependencies>.
Это означает, что дети этого родительского pom могут использовать зависимости, но они должны явно указать это в dependencies.
. Например:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.2.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Обратите внимание, что версия не оценивается как унаследованная.

2) Без наследования родителем

Вам нужно будет определить все необходимые зависимости в приложении Spring Boot или более прямо использовать зависимость spring-boot-dependencies в dependencyManagement с областью действия import, чтобы иметь возможность объявить им спасибо к функции управления зависимостями:

<dependencyManagement>
        <dependencies>
        <dependency>
            <!-- Import dependency management from Spring Boot -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>1.5.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Но в любом случае вы никогда не наследуете от plugins, изначально сконфигурированного родителем, поскольку у вас нет родителя.
Поэтому вы должны объявить их явно в pom.xml вашего проекта.

Например, чтобы определить версию компилятора, используемую кодировку и настроить сборку для переупаковки встроенного компонента (чтобы сделать его автономным исполняемым), вам нужно будет указать больше вещей:

<properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <springboot.version>1.5.2.RELEASE</springboot.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${springboot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<build>
   <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
             <version>${springboot.version}</version>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <mainClass>myClass</mainClass>
            </configuration>
        </plugin>      
   <plugins>
</build>
avatar
SeverityOne
8 апреля 2018 в 09:04
0

Зависимость — это библиотеки, необходимые для компиляции вашего кода. Это может быть ваш собственный код или библиотеки, такие как Apache Commons.

Родительский объект содержит информацию, но ничего не нужно строить, и эта информация используется несколькими вашими проектами. Предположим, у вас есть пара модулей связанного кода, и вы хотите убедиться, что все модули используют одни и те же версии библиотек. Затем вы можете определить эти библиотеки в разделе <dependencies> каждого модуля, но вы должны определить версию в разделе <dependencyManagement> родительского модуля.

Родительские POM могут иметь своих собственных родителей, поэтому вы можете построить целую иерархию.

avatar
Vinay
8 апреля 2018 в 08:16
2

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

Где как зависимость pom объявлена ​​как jar. Таким образом, его можно включить в проект, и, таким образом, проект может использовать его функции.

Родительский pom Maven может содержать почти все, и они могут быть унаследованы в дочерние файлы pom, например,

  • Общие данные — имена разработчиков, адрес SCM, управление распространением и т. д.
  • Константы — например, номера версий
  • Общие зависимости — общие для всех дочерних элементов. Это имеет тот же эффект, что и запись их несколько раз в отдельные файлы pom.
  • Свойства — например, плагины, объявления, исполнения и идентификаторы.
  • Конфигурации
  • Ресурсы
Thorbjørn Ravn Andersen
8 апреля 2018 в 10:07
0

Он должен распространяться.

avatar
Jabir
8 апреля 2018 в 08:13
0

Сценарий использования <paraent> — это место, где вы храните информацию о версиях артефактов и настройках/версиях компилятора, которые используются в модулях.

Подробнее см. ниже Введение в POM