Maven实战——聚合与继承(中)

依赖管理

上一节我们说到可以继承dependencies元素,我们很容易想到把这一特性应用到accout-parent中。子模块account-email和account-persist同时依赖了org.springframework:spring-core:2.5.6,spring-beans:2.5.6,spring-context:2.5.6,junit:junit:4.7。以此可以将这些公共依赖放到父模块account-parent中,两个子模块就能移除这些依赖,简化配置。

上述方法时可行的,但是有问题。因为我们无法确定将来添加子模块就一定需要这四个模块依赖。Maven提供dependencyManagement元素既能让子模块继承到父模块的依赖配置,又能保证子模块依赖使用的灵活性。在dependencyManagement元素下依赖声明不会引入实际的依赖,不过他能够约束dependencies下依赖的使用。例如,可以在account-parent下加入这样的dependencyManagement配置,代码如下:

<modelVersion>4.0.0</modelVersion>
<groupId>com.juvenxu.mvnbook.account</groupId>
<artifactId>account-parent</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>pom</packaging>
<name>Account Parent</name>
<properties>
    <springframework.version>2.5.6</springframework.version>
    <junit.version>4.7</junit.version>
</properties>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

现在修改account-email配置如下

<properties>
    <javax.mail.version>1.4.1</javax.mail.version>
    <greenmail.version>1.3.1b</greenmail>
</properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${springframework.version}</version>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>mail</artifactId>
            <version>${junit.mail.version}</version>
        </dependency>
        <dependency>
            <groupId>com.icegreen</groupId>
            <artifactId>greenmail</artifactId>
            <version>${greenmail.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

使用这种依赖管理机制似乎不能减少太多了POM配置,但是我还是强烈推荐采用这种方法。原因是在于父pom中使用dependencyManagement声明依赖能够统一项目范围中依赖的版本,降低依赖的冲突。

如果子模块中不声明依赖的使用,即使该依赖已经在父pom的dependencyManagement中声明了也不会产生任何实际的效果,如果account-persist:

<properties>
        <dom4j.version>1.6.1</dom4j.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>${dom4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
    </dependencies>

这里没有声明spring-context-support,那么该依赖就不会被引入。

这里顺便提一下import的依赖范围,这个依赖范围只在dependencyManagement元素下才有效果。使用该范围的依赖通常指向一个POM,作用是将目标POM中的dependencyManagement配置导入并合并到当前pom的dependencyManagement元素中。例如:

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.juvenxu.mvnbook.account</groupId>
                <artifactId>account-parent</artifactId>
                <version>1.0-SNAPSHOT</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

插件管理

Maven提供了dependencyManagement元素帮助管理依赖,类似的Maven也提供了pluginManagement元素帮助管理插件。在该元素中配置的依赖不会造成实际的插件调用行为,当POM中配置了真正了plugin元素,并且其groupId和artifactId与pluginManagement中配置的插件匹配时,pluginManagement的配置才会影响到实际的插件行为

例如:

<bulid>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.1.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>jar-no-fork</goal>
                        </goals>
                    <execution>
                </executions>
            </plugin>
        </plugins>
    </pluginManagement>
</bulid>

将其jar-no-fork目标绑定到了verity生命周期阶段,以生成项目源码包,当子模块需要生成源码包的时候,只需要如下简单的配置,代码如下:

<bulid>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
        <plugin>
    </plugins>
</build>

如果子模块需要不同于父模块的插件配置,可以自行配置以覆盖父模块的pluginManagement配置。有了pluginManagement元素,account-email和account-persist的pom也得以简化。他们都配置了maven-compiler-plugin和maven-resoureces-plugin。可以将这两个插件配置移到account-parent的pluginManagement元素中。

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
        </plugins>
    </pluginManagement>
</build>

account-email和accoun-persist可以完全移除关于maven-compiler-plugin和maven-resources-plugin的配置,但他们仍能享受这两个插件服务。

当项目的多个模块有同样的插件配置时,应当将配置移到父pom的pluginManagement的元素中。即使各个模块对同一个插件的具体配置不尽相同,也应当使用父pom的pluginManagement元素统一声明插件的版本。甚至可以要求将所有用到的插件的版本在父pom的pluginManagement元素中声明,子模块使用插件时不配置版本信息,这么做可以统一项目的插件版本,避免潜在的插件不一致或者不稳定问题,也更易于维护。

时间: 2024-11-10 14:04:17

Maven实战——聚合与继承(中)的相关文章

Maven实战——聚合与继承(上)

聚合 首先我们来看两个pom.xml文件,我们将通过这两个pom文件来引入我们要学习的聚合与继承 account-email <modelVersion>4.0.0</modelVersion> <groupId>com.juvenxu.mvnbook.account</groupId> <artifactId>account-email</artifactId> <name>Account Email</name&

Maven实战——聚合与继承(下)

聚合与继承的关系 聚合是为了方便快速构建项目,继承是为了消除重复配置 共同点是两者的packaging都是pom,聚合模块与继承关系中的父模块除了pom之外都没有实际内容. 聚合关系与继承关系的比较: 在现有实际项目中,往往发现一个pom既是聚合pom又是父pom,这么做主要是为了方便.一般来说,融合使用聚合和继承没有什么问题.例如,可以将account-aggregator和account-parent合并成为一个新的account-parent,如下: <modelVersion>4.0.

Maven之——聚合与继承

Maven之--聚合与继承 1.    聚合 所谓聚合就是用一个pom.xml配置文件将一个或者多个项目关联起来.这样当我们执行聚合文件pom.xml的生命周期阶段的时候.他就会执行在聚合文件中指定聚合的所有项目的对应生命周期阶段. 包含聚合文件的是一个额外的模块.这个模块必须要有自己的POM文件.并切此聚合项目的POM的packaging必须是pom: <modelVersion>4.0.0</modelVersion> <groupId>org.andy.items

Maven学习笔记(三):Maven的聚合和继承

Maven的聚合其实就是把各个项目拷贝到一个项目里,便于统一构建(这种是父子目录结构构件,个人喜欢这种,平行结构不喜欢),实现聚合的方式为: -- 新建一个普通的Maven项目,只保留pom文件,其他的目录结构都删除 -- 配置新建项目的pom文件: 1 <project ...> 2 <modelVersion>4.0.0</modelVersion> 3 <groupId>XXXX</groupId> 4 <artifactId>

maven的聚合与继承5

一.聚合 如果我们想一次构建多个项目模块,那我们就需要对多个项目模块进行聚合 1.1.聚合配置代码 1 <modules> 2 <module>模块一</module> 3 <module>模块二</module> 4 <module>模块三</module> 5 </modules> 例如:对项目的Hello.HelloFriend.MakeFriends这三个模块进行聚合 1 <modules>

Maven之 聚合与继承 详解

说到聚合与继承我们都很熟悉,maven同样也具备这样的设计原则,下面我们来看一下Maven的pom如何进行聚合与继承的配置实现. 一.为什么要聚合? 随着技术的飞速发展和各类用户对软件的要求越来越高,软件本身也变得越来越复杂,然后软件设计人员开始采用各种方式进行开发,于是就有了我们的分层架构.分模块开发,来提高代码的清晰和重用.针对于这一特性,maven也给予了相应的配置. 情景分析一: 我们在开发过程中,创建了2个以上的模块,每个模块都是一个独立的maven project,在开始的时候我们可

Maven真——聚合和继承(于)

依赖管理 我们谈论继承一个dependencies因素,我们非常easy这个特性被认为是适用于accout-parent于. 子模块account-email和account-persist同一时候依赖了org.springframework:spring-core:2.5.6,spring-beans:2.5.6,spring-context:2.5.6,junit:junit:4.7.以此能够将这些公共依赖放到父模块account-parent中,两个子模块就能移除这些依赖,简化配置. 上述

Maven模块聚合与继承

聚合 假如有account-email和account-persist两个模块,我们想要一次构建这两个项目,这时需要用到聚合. 聚合模块 package值必须为pom 必须有元素modules module值为相对目录名 新建account-aggregator模块,下面有如下pom文件,其它两个模块保持不变. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/

maven的聚合与继承

新建一个空的maven项目user-parent 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