Maven高级使用指南

在开发大型项目时，Maven作为一个强大的构建和项目管理工具，能显著提升项目管理和构建的效率。然而，随着项目的扩大，维护和管理的复杂性也随之增加。本文将探讨一些高级的Maven用法和解决方案，以帮助你更好地管理大型项目

1. 项目分模块管理

在处理大型项目时，项目的复杂性和规模会显著增加，使得维护和复用变得困难。为了解决这些问题，常见的做法是将一个大项目拆分为多个模块，每个模块负责处理不同的功能或业务逻辑。这种做法不仅可以提高代码的组织性，还能促进模块的重用。

问题：重复配置依赖

在一个多模块的项目中，每个模块通常需要引入相同的依赖库。如果在每个模块的pom.xml文件中都重复配置这些依赖，会导致以下问题：

• 维护难度增加：当依赖版本需要更新时，必须在每个模块中进行修改，容易遗漏或出错。
• 冗余配置：重复的配置增加了项目的复杂度和维护成本。
• 版本冲突：如果不同模块使用了不同版本的相同依赖，可能导致兼容性问题。

解决方案：引入父工程

为了简化依赖管理，Maven提供了继承机制，通过创建一个父工程（Parent Project），可以在父工程中集中管理所有公共的依赖和插件配置。这种方式可以显著减少重复配置，提高项目的可维护性。

步骤如下：

• 创建父工程：首先，创建一个父工程，其pom.xml文件中只包含依赖和插件的配置，不包含实际的业务代码。（父工程的打包方式设为pom）

• 父工程的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/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>

        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>5.3.8</version>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.12.0</version>
            </dependency>
            <!-- 更多公共依赖 -->
        </dependencies>
   

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.1</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
                <!-- 更多公共插件 -->
            </plugins>
        </pluginManagement>
    </build>

    <modules>
        <module>module-a</module>
        <module>module-b</module>
        <!-- 更多子模块 -->
    </modules>
</project>

子模块继承父工程：在每个子模块的pom.xml文件中，指定父工程，并使用父工程中定义的依赖和插件配置。

子模块的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/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0.0</version>
        <relativePath>../parent-project/pom.xml</relativePath>
    </parent>
    <artifactId>module-a</artifactId>

   
</project>

2. 版本管理

在多模块项目中，管理不同模块之间的版本变得尤为重要。如果每个模块都单独管理版本，容易导致不一致的情况。

解决方案：

在父工程中使用<dependencyManagement>标签统一管理依赖版本。这个标签仅定义依赖版本，但不会将依赖实际引入到构建中。

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>
        <!-- 更多依赖 -->
    </dependencies>
</dependencyManagement>

此外，可以使用<properties>标签定义版本号等属性，方便统一管理。

    <properties>
        <project.version>0.0.1</project.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <java.version>11</java.version>
        <cloud.version>2021.0.1</cloud.version>
        <cloud-alibaba.version>2021.0.1.0</cloud-alibaba.version>
        <mysql.version>8.0.26</mysql.version>
        <druid.verison>1.2.11</druid.verison>
   
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--SpringCloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--SpringCloudAlibaba-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- security -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-security</artifactId>
                <version>${security.version}</version>
            </dependency>
            <!-- oauth2 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-oauth2</artifactId>
                <version>${oauth2.version}</version>
            </dependency>
            <!-- rabbitmq -->
           
        </dependencies>
    </dependencyManagement>

• dependencies：用于实际引入依赖库，定义了项目的实际依赖项，包括依赖的版本。
• dependencyManagement：用于集中管理依赖的版本信息，子模块可以使用这些版本信息，但不直接引入这些依赖。

3. 聚合构建

在多模块项目中，单独构建每个模块可能会比较繁琐。通过Maven的聚合功能，可以将多个模块组织成一个整体进行构建。

解决方案：

创建一个聚合工程（父工程），它只包含一个pom.xml文件，没有业务代码，通过<modules>标签列出所有子模块。然后，在聚合工程目录下执行mvn install，Maven会自动构建所有子模块。

示例：

<project>
    <modelVersion>4.0.0</modelVersion>
    <packaging>pom</packaging>
    <modules>
        <module>module-a</module>
        <module>module-b</module>
        <!-- 更多模块 -->
    </modules>
</project>

 

4. 私服配置

在团队开发中，共享自定义的JAR包时，将其上传到中央仓库是不现实的，通常公司会搭建自己的私有Maven仓库。

使用私服，需要在maven的settings.xml配置文件中，做如下配置：

1. 需要在 servers 标签中，配置访问私服的个人凭证(访问的用户名和密码)

   <server>
       <id>maven-releases</id>
       <username>admin</username>
       <password>admin</password>
   </server>
       
   <server>
       <id>maven-snapshots</id>
       <username>admin</username>
       <password>admin</password>
   </server>

2. 在 mirrors 中只配置我们自己私服的连接地址(如果之前配置过阿里云，需要直接替换掉)

   <mirror>
       <id>maven-public</id>
       <mirrorOf>*</mirrorOf>
       <url>http://112.128.130.121:8081/repository/maven-public/</url>
   </mirror>

3. 需要在 profiles 中，增加如下配置，来指定snapshot快照版本的依赖，依然允许使用

   <profile>
       <id>allow-snapshots</id>
           <activation>
             <activeByDefault>true</activeByDefault>
           </activation>
       <repositories>
           <repository>
               <id>maven-public</id>
               <url>http://112.128.130.121:8081/repository/maven-public/</url>
               <releases>
                 <enabled>true</enabled>
               </releases>
               <snapshots>
                 <enabled>true</enabled>
               </snapshots>
           </repository>
       </repositories>
   </profile>

4. 如果需要上传自己的项目到私服上，需要在项目的pom.xml文件中，增加如下配置，来配置项目发布的地址(也就是私服的地址)

   <distributionManagement>
       <!-- release版本的发布地址 -->
       <repository>
           <id>maven-releases</id>
           <url>http://192.168.150.101:8081/repository/maven-releases/</url>
       </repository>
       
       <!-- snapshot版本的发布地址 -->
       <snapshotRepository>
           <id>maven-snapshots</id>
           <url>http://192.168.150.101:8081/repository/maven-snapshots/</url>
       </snapshotRepository>
   </distributionManagement>

5. 发布项目，直接运行 deploy 生命周期即可 (发布时，建议跳过单元测试)

启动本地私服

1. 解压： apache-maven-nexus.zip

2. 进入目录： apache-maven-nexus\nexus-3.39.0-01\bin

3. 启动服务：双击 start.bat

4. 访问服务：localhost:8081

5. 私服配置说明：将上述配置私服信息的 192.168.150.101 改为 localhost

总结

Maven作为一个强大的构建工具，提供了丰富的功能来帮助管理和构建大型项目。通过合理使用父工程、版本管理、聚合构建和私服配置，可以有效地简化多模块项目的管理，提高开发效率。希望本文提供的高级Maven用法和解决方案能帮助你更好地应对项目中的各种挑战。如果你有更多问题或想法，欢迎在评论区讨论！