Maven常用命令，以及多个mudule编译、打包指定module

maven 参数格式maven 命令除了常用的几个，大部分经常记不住，整理一下，方便查询。maven 命令的格式为 mvn [plugin-name]:[goal-name]，可以接受的参数如下，-D 指定参数，如 -Dmaven.test.skip=true 跳过单元测试；-P 指定 Profile 配置，可以用于区分环境；-e 显示maven运行出错的信息；-o 离线执行命令,即...

zzhongcy

7393人浏览 · 2020-04-07 17:34:48

zzhongcy · 2020-04-07 17:34:48 发布

maven 参数格式

maven 命令除了常用的几个，大部分经常记不住，整理一下，方便查询。

maven 命令的格式为 mvn [plugin-name]:[goal-name]，可以接受的参数如下，
-D 指定参数，如 -Dmaven.test.skip=true 跳过单元测试；
-P 指定 Profile 配置，可以用于区分环境；
-e 显示maven运行出错的信息；
-o 离线执行命令,即不去远程仓库更新包；
-X 显示maven允许的debug信息；
-U 强制去远程更新snapshot的插件或依赖，默认每天只更新一次。

常用maven命令

创建maven项目：mvn archetype:create
指定 group： -DgroupId=packageName
指定 artifact：-DartifactId=projectName
创建web项目：-DarchetypeArtifactId=maven-archetype-webapp
创建maven项目：mvn archetype:generate
验证项目是否正确：mvn validate
maven 打包：mvn package
只打jar包：mvn jar:jar
生成源码jar包：mvn source:jar
产生应用需要的任何额外的源代码：mvn generate-sources
编译源代码： mvn compile
编译测试代码：mvn test-compile
运行测试：mvn test
运行检查：mvn verify
清理maven项目：mvn clean
生成eclipse项目：mvn eclipse:eclipse
清理eclipse配置：mvn eclipse:clean
生成idea项目：mvn idea:idea
安装项目到本地仓库：mvn install
发布项目到远程仓库：mvn:deploy
在集成测试可以运行的环境中处理和发布包：mvn integration-test
显示maven依赖树：mvn dependency:tree
显示maven依赖列表：mvn dependency:list
下载依赖包的源码：mvn dependency:sources
安装本地jar到本地仓库：mvn install:install-file -DgroupId=packageName -DartifactId=projectName -Dversion=version -Dpackaging=jar -Dfile=path

Maven多模块项目

SpringBoot+Maven多模块项目（创建、依赖、打包可执行jar包部署测试）完整流程：

SpringBoot+Maven多模块项目（创建、依赖、打包可执行jar包部署测试）完整流程_凌云冷海的博客-CSDN博客

mudule编译、打包指定module

在多module的maven项目中，如果每次打包整个工程显得有些冗余和笨重。
例如A,B,P的继承关系为
P
|
—– A
|
—– B
即P包含A,B的module，每次打包P都会将A,B都打包。
假如我只修改了A模块，那么每次都要将B都一块打包吗？当然不是，maven提供了自定义参数：

-rf, --resume-from

Resume reactor from specified project

-pl, --projects

Build specified reactor projects instead of all projects

-am, --also-make

If project list is specified, also build projects required by the list

-amd, --also-make-dependents

If project list is specified, also build projects that depend on projects on the list

所以进入P目录，输入指令：

mvn install -pl A -am

或者指定profile

clean install -Dmaven.test.skip -P release-A -pl A -am

项目结构为：

xxx-parent（父pom），
--- xxx-client（子pom，jar包），
--- xxx-web（子pom，war包，依赖xxx-client）

我们的maven项目打包时，在根目录下，使用

mvn clean -U package -pl xxx-web -am -P $PROFILE -Dmaven.test.skip=$SKIP_TEST

例子1

在我们平时的开发中，一个项目因为要上线，会有很多种环境，在不同的环境中我们项目的配置文件往往都是不一样的，比如数据库，Redis的那些配置，那我们怎么设置不用每次都进行修改呢？

由于上面的问题，我们直接配置三个配置文件，只需要打包的时候，根据不同环境打包不同的配置文件就好了，如下图

这三个文件中

application.yml 是启动服务时，Spring会自动加载的配置文件
application-dev.yml 代表的是开发环境时的配置文件
application-prod.yml 代表的是生产环境的配置文件

后面这两个文件在SpringBoot服务启动时，Spring不会自动加载他们，那么在不同的环境中时怎么加载不同的配置文件的呢?

二、配置文件的加载设置

因为在服务启动时，Spring会自动加载application.yml

所以我们只需在这个配置文件中设置，需要哪个就加载哪个就好了

如上图所示，在服务启动加载的时候，服务器就会加载application.yml文件，然后通过配置去调用application-dev.yml文件,选择开发环境。当然如此，当active: prod,那么服务在启动时，Spring就会调用application-prod.yml文件进入生产环境。

三、Maven不同环境的打包

首先我们进行动态的调用不同的配置文件，首先我们的前提条件是拥有上述的三个配置文件，然后根据这些文件的名字来进行下列配置，大家根据自己需求进行更改。

然后我们要这样配置我们的 pom.xml

      <profiles>
        <!--这是开发环境-->
        <profile>
            <id>dev</id>
            <properties>
                <!-- 环境标识，需要与配置文件的名称相对应 -->
                <activatedEnv>dev</activatedEnv>
            </properties>
            <activation>
                <!-- 默认环境 -->
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile>
        <!--这是生产环境-->
        <profile>
            <id>prod</id>
            <properties>
                <activatedEnv>prod</activatedEnv>
            </properties>
        </profile>
    </profiles>

    <build>
        <!--最终 Jar 包的名字-->
        <finalName>Test</finalName>
        <!--Maven的打包插件-->
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- resource插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <executions>
                    <execution>
                        <id>test-resources</id>
                        <!--目标执行的阶段，具体值看Maven的生命周期列表；-->
                        <phase>compile</phase>
                        <!--一个plugin的execution的目标列表,也就是上面的id-->
                        <goals>
                            <goal>testResources</goal>
                        </goals>
                        <configuration>
                            <!-- 覆盖原有文件 -->
                            <overwrite>true</overwrite>
                            <outputDirectory>${project.build.outputDirectory}</outputDirectory>
                            <!-- 待处理的资源定义 -->
                            <resources>
                                <resource>
                                    <!-- 指定resources插件处理哪个目录下的资源文件 -->
                                    <directory>src/main/resources/${activatedEnv}</directory>
                                    <filtering>false</filtering>
                                </resource>
                            </resources>
                        </configuration>
                        <!--这个plugin是否应用到该POM的孩子POM，默认true；-->
                        <inherited>true</inherited>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

然后在我们的 application.yml 配置动态的使用

spring:
profiles:
active: @activatedEnv@

这里的 @activatedEnv@ ,使用的就是我们在pom.xml里设置的<activatedEnv> ,当我们需要Maven打包时，他就会用这里的值来进行使用

然后在Maven打包时，我们只需要指定参数就好了

比如我们需要打包开发环境：

mvn clean package -P dev

打包生产环境

mvn clean package -P prod

我们只需要修改参数就行了！这样就会打包不同的配置文件！

例子2

一个应用系统需要在不同的阶段以不同的配置文件来进行部署，在开发阶段需要开发时的配置文件启动服务，测试阶段或者生产阶段都是不同的配置，所以我们需要利用maven按照环境来将不同环境的配置文件按环境打包，减少我们的维护成本。

1、在pom文件中进行如下配置：

<profiles>
    <profile>
        <id>dev</id>
        <properties>
            <profileActive>dev</profileActive>
        </properties>
        <activation>
            <activeByDefault>false</activeByDefault>
        </activation>
    </profile>
    <profile>
        <id>test</id>
        <properties>
            <profileActive>test</profileActive>
        </properties>
        <activation>
            <activeByDefault>false</activeByDefault>
        </activation>
    </profile>
</profiles>
 
<build>
<resources>
    <resource>
        <directory>src/main/resources</directory>
        <includes>
            <include>application-${profileActive}.properties</include>
            <include>application.properties</include>
        </includes>
        <filtering>true</filtering>
    </resource>
</resources>
<plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <configuration>
            <delimiters>
                <delimiter>@</delimiter>
            </delimiters>
            <useDefaultDelimiters>false</useDefaultDelimiters>
        </configuration>
    </plugin>
</plugins>
</build>

2、application.properties中添加如下配置：

spring.profiles.active=@profileActive@

3、通过mvn package -P dev进行打包就会只将开发环境的配置文件扔到对应的jar包或者war包中

例子3

多环境配置解决方案#

网上大多数都是分为application-dev.xml、application-test.xml、application-prod.xml三个文件，可是我们在真实项目开发中，将会用到很多各式各样的文件（例如log4j的配置文件），它们在不同环境中应该也是不同的配置，不能在测试和生产环境使用同一个配置文件。所以我们将分为三个文件夹分别代表开发环境、测试环境、生产环境，他们里面的配置文件种类一致但是内容不一样。选择完当前环境后，打的jar包只包含当前环境文件夹下的配置文件。

├─main
│  ├─java
│  │  └─......
│  └─resources
│      ├─dev
│      │   └─config
│      │   │   └─mq.yml
│      │   │   └─redis.yml
│      │   └─application-dev.yml
│      ├─prod
│      │  └─config
│      │  │    └─mq.yml
│      │  │    └─redis.yml
│      │  └─application-prod.yml
│      └─test
│      │  └─config
│      │  │    └─mq.yml
│      │  │    └─redis.yml
│      │  └─application-test.yml
│      └─application.yml
│      └─a.xml
└─test
    └─java
        └─......

dev下的config下的mq.yml

mq: mq-dev

dev下的config下的redis.yml

redis: redis-dev

dev下的application-dev.yml

profiles.active:
  dev
port: dev-port

application.yml

spring:
  profiles:
    active: ${profiles.active}

port: ${port}

查看编译后的结果

其中application.yml中变量已经被替换为

spring:
  profiles:
    active: dev
port: dev-port

完整的pom.xml

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.1.0</version>
                <!--使用默认的变量分割符即${}-->
                <configuration>
                    <useDefaultDelimiters>true</useDefaultDelimiters>
                </configuration>
            </plugin>
        </plugins>

        <!-- 测试文件的编译路径设置 -->
        <testResources>
            <testResource>
                <!--这里是关键！ 根据不同的环境，把对应文件夹里的配置文件打包-->
                <directory>src/main/resources</directory>
                <includes>
                    <include>application.yml</include>
                </includes>
                <filtering>true</filtering>
            </testResource>

            <testResource>
                <!--这里是关键！ 根据不同的环境，把对应文件夹里的配置文件打包-->
                <directory>src/main/resources/${profiles.active}</directory>
                <includes>
                    <include>**/*.yml</include>
                </includes>
                <filtering>false</filtering>
            </testResource>
        </testResources>

        <resources>
            <resource>
                <!--打包该目录下的 application.yml -->
                <directory>src/main/resources</directory>
                <includes>
                    <include>application.yml</include>
                </includes>
                <!-- 启用过滤 即该资源中的变量将会被过滤器中的值替换 -->
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <!-- ${profiles.active}由profile提供 -->
                <directory>src/main/resources/${profiles.active}</directory>
                <includes>
                    <include>**/*.yml</include>
                </includes>
                <filtering>false</filtering>
            </resource>

        </resources>

        <!-- 定义 filter,即该资源中的值将会用来替换同名属性（设置 filtering 为 true 的资源中的属性）-->
        <filters>
          <filter>
              src/main/resources/${profiles.active}/application-${profiles.active}.yml
          </filter>
        </filters>
    </build>

    <profiles>
        <profile>
            <!-- 本地开发环境 -->
            <id>dev</id>
            <properties>
                <profiles.active>dev</profiles.active>
            </properties>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>

        </profile>

        <profile>
            <!-- 测试环境 -->
            <id>test</id>
            <properties>
                <profiles.active>test</profiles.active>
            </properties>
        </profile>

        <profile>
            <!-- 生产环境 -->
            <id>prod</id>
            <properties>
                <profiles.active>prod</profiles.active>
            </properties>
        </profile>
    </profiles>