maven常用插件配置详解

 

 

常用插件配置详解
Java代码   

1. <!-- 全局属性配置 -->  
2. <properties>  
3.     <project.build.name>tools</project.build.name>  
4.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
5. </properties>  

project.build.name：  用来定义war包名称  
project.build.sourceEncoding：  用来定义资源文件的编码格式  

下面开始讲解常用的maven插件配置  

一、编译插件   

Java代码   

1. <!-- 编译插件 -->  
2. <plugin>  
3.     <groupId>org.apache.maven.plugins</groupId>  
4.     <artifactId>maven-compiler-plugin</artifactId>  
5.     <configuration>  
6.         <source>1.6</source>  
7.         <target>1.6</target>  
8.         <encoding>${project.build.sourceEncoding}</encoding>  
9.     </configuration>  
10. </plugin>  

source： 源代码编译版本；  
target： 目标平台编译版本；  
encoding： 字符集编码。  

二、设置资源文件的编码方式   

Java代码   

1. <!-- 设置资源文件的编码方式 -->  
2. <plugin>  
3.     <groupId>org.apache.maven.plugins</groupId>  
4.     <artifactId>maven-resources-plugin</artifactId>  
5.     <version>2.4.3</version>  
6.     <executions>  
7.         <execution>  
8.             <phase>compile</phase>  
9.         </execution>  
10.     </executions>  
11.     <configuration>  
12.         <encoding>${project.build.sourceEncoding}</encoding>  
13.     </configuration>  
14. </plugin>  

xml、properties文件都是资源文件，编码的时候遇到中文总要进行转码！用什么编码？UTF-8，那就记得强制<encoding>${project.build.sourceEncoding}</encoding>   

三、自动拷贝jar包到target目录   

Java代码   

1. <!-- 依赖插件 -->  
2. <plugin>  
3.     <groupId>org.apache.maven.plugins</groupId>  
4.     <artifactId>maven-dependency-plugin</artifactId>  
5.     <version>2.6</version>  
6.     <executions>  
7.         <execution>  
8.             <id>copy-dependencies</id>  
9.             <phase>compile</phase>  
10.             <goals>  
11.                 <goal>copy-dependencies</goal>  
12.             </goals>  
13.             <configuration>  
14.                 <!-- ${project.build.directory}为Maven内置变量，缺省为target -->  
15.                 <outputDirectory>${project.build.directory}/lib</outputDirectory>  
16.                 <!-- 表示是否不包含间接依赖的包 -->  
17.                 <excludeTransitive>false</excludeTransitive>  
18.                 <!-- 表示复制的jar文件去掉版本信息 -->  
19.                 <stripVersion>true</stripVersion>  
20.             </configuration>  
21.         </execution>  
22.     </executions>  
23. </plugin>  

在部署war包时，需要将项目依赖的jar包，也打到war包中，因此就会用到上述插件  

四、生成源代码jar包   

Java代码   

1. <!-- 源代码打包插件 -->  
2. <plugin>  
3.     <artifactId>maven-source-plugin</artifactId>  
4.     <version>2.1</version>  
5.     <configuration>  
6.         <!-- <finalName>${project.build.name}</finalName> -->  
7.         <attach>true</attach>  
8.         <encoding>${project.build.sourceEncoding}</encoding>  
9.     </configuration>  
10.     <executions>  
11.         <execution>  
12.             <phase>compile</phase>  
13.             <goals>  
14.                 <goal>jar</goal>  
15.             </goals>  
16.         </execution>  
17.     </executions>  
18. </plugin>  

该插件主要用于在打jar包时，把源代码也打成jar包  

五、将项目打成jar包   

Java代码   

1. <!-- jar包插件 -->  
2. <plugin>  
3.     <groupId>org.apache.maven.plugins</groupId>  
4.     <artifactId>maven-jar-plugin</artifactId>  
5.     <version>2.4</version>  
6.     <configuration>  
7.         <archive>  
8.             <manifest>  
9.                 <!-- 告知 maven-jar-plugin添加一个 Class-Path元素到 MANIFEST.MF文件，以及在Class-Path元素中包括所有依赖项 -->  
10.                 <addClasspath>true</addClasspath>  
11.                 <!-- 所有的依赖项应该位于 lib文件夹 -->  
12.                 <classpathPrefix>lib/</classpathPrefix>  
13.                 <!-- 当用户使用 lib命令执行JAR文件时，使用该元素定义将要执行的类名 -->  
14.                 <mainClass>com.zhengtian.tools.service.phone.MobilePhoneTool</mainClass>  
15.             </manifest>  
16.         </archive>  
17.     </configuration>  
18. </plugin>  

在将项目打成jar包时，有时会需要将项目打成可以直接运行的jar包，因此就需要将项目依赖的jar包也打入jar包中，此时需要在Eclipse上安装例外一个插件，用来打可执行jar包，详情见链接 http://zheng12tian.iteye.com/blog/1765626   

六、将项目打成war包   

Java代码   

1. <!-- war插件 -->  
2. <plugin>  
3.     <groupId>org.apache.maven.plugins</groupId>  
4.     <artifactId>maven-war-plugin</artifactId>  
5.     <version>2.1.1</version>  
6.     <configuration>  
7.         <!-- <warName>${project.build.name}</warName> -->  
8.     </configuration>  
9. </plugin>  

encoding： 强制字符集编码  
warName： war包名字——platform.war  
webappDirectory： 产生war前，用于存放构建war包的目录——target/platform。  
warSourceDirectory： 我把web工程搞成了eclipse下的WTP类型。我不喜欢maven产生的webapp目录，更喜欢WebContent！  

需要注意的是：   
采用上述插件部署项目的话，使用 clean package tomcat:redeploy 命令。使用该命令前，需要先启动tomcat，实际上是为了让tomcat启动manager项目，实现动态部署  

此部署方式虽然也是动态部署的范畴，但是每次修改文件后，需要手动再次重新部署，才会加载更改。  

如果想让tomcat自动扫描项目的改动，自动加载，那么需要将maven工程的java全部编译的webapp目录下，然后将jar包和资源文件也打到webapp目录。最后在$CATALINA_HOME/conf /Catalina/localhost中添加一个xml文件，修改docbase为webapp目录。  

Tomcat常用的部署方式介绍： http://blog.csdn.net/yangxueyong/article/details/6130065   

配置描述：当你的pom文件中把你的当前项目的packaging配置为war后，maven会使用该插件将当前项目生成war文件，但是有时候我们不想要war文件，只想让maven生成当前项目的网站目录结构，尤其是在调试的时候，因为生成war文件的同时，会生成当前项目的网站目录结构，这样一来，浪费了打包的时间和磁盘的空间！

maven使用war插件生成war文件所用的目标（goal）为war，从帮助文档中可以看出，war插件还有一个目标（goal）是exploded，即，只生成目录结构，而不生成war文件。

参见：http://maven.apache.org/plugins/maven-war-plugin/plugin-info.html

可以在当前目录下直接使用mvn war:exploded，就能生成当前项目的网站目录结构。

使用mvn war:exploded生成网站目录结构的时候，war插件会把src/main/webapp目录下的内容全部copy到target/${finalName}目录下，但是，有时候webapp里的一些资源部需要copy，比如我会在src/main/webapp的js目录下放很多jQuery的插件，其中包括插件的帮助文档；但是我可能只会用到其中一部分插件。所以在生成网站目录结构的时候，我根本不需要把src/main/webapp的js目录下的所以文件都copy到target/${finalName}目录中，这时候就需要对exploded目标（goal）进行资源过滤了——不把没用的资源copy到网站的目录结构中去：

[html]  view plain copy

 

1. <plugin>  
2.     <artifactId>maven-war-plugin</artifactId>  
3.     <configuration>  
4.         <warSourceExcludes>js/参考/**</warSourceExcludes>  
5.     </configuration>  
6. </plugin>  

说明：上面的配置，使用了war插件的warSourceExcludes参数，该参数是一个String类型，需要把被排除的路径或文件使用逗号（comma）间隔开。

参见：

1、http://www.wsria.com/archives/1335

2、http://maven.apache.org/plugins/maven-war-plugin/exploded-mojo.html#warSourceDirectory

七、在打包时，需要清空一些指定的目录   

配置描述：maven提供了很多有用插件，如mvn clean使用到的maven-clean-plugin，mvn compile使用到的maven-compile-plugin等，这些插件可以通过pom文件绑定到maven三个生命周期（life-cycle）的各阶段（phase）上，也可以在命令行（如Windows下的cmd）中单独由mvn命令调用，如mvn clean，可以调用maven-clean-plugin的clean目标（goal）。对于绑定到各阶段（phase）运行的插件的参数（parameter）可以用<configuration>标签（tag）配置，但是在该插件在命令行下单独由mvn命令调用，那么这个参数该如何使用pom文件配置呢？比如，在一个J2EE项目中，想使用mvn clean命令清除target里的内容的同时，也清除tomcat/webapp下的相应目录，该怎么办呢？这就需要在pom文件中对插件进行全局配置了。

[html]  view plain copy

 

1. <plugin>  
2.     <artifactId>maven-clean-plugin</artifactId>  
3.     <configuration>  
4.         <verbose>true</verbose>  
5.         <filesets>  
6.             <fileset>  
7.                 <directory>c:/a</directory>  
8.             </fileset>  
9.       </filesets>  
10.     </configuration>  
11. </plugin>  

插件的配置分为局部配置和全局配置，本文中对antrun和resource插件的配置是局部配置，对clean插件的配置是全局配置，能看出差别吧？

局部配置的<configuration>标签（tag）放在<execution>标签（tag）里边，而全局配置的<configuration>标签（tag）则放在<plugin>标签（tag）里边，因为全局配置里根本就没有<execution>标签（tag），因为全局配置针对的是该插件的全部目标（goal）配置的！

本例中，删除的是C:/a目录，即，当用户在该maven项目中执行mvn clean后，除了删除clean插件默认的project.build.directory, project.build.outputDirectory,project.build.testOutputDirectory, 和 project.reporting.outputDirectory目录外

（参考：http://maven.apache.org/plugins/maven-clean-plugin/clean-mojo.html#filesets），

还会删除C:/a目录。

注意，该配置仅针对本项目有效，即，用户在当前项目下使用mvn clean时，会删除C:/a目录；当用户在其他没有如此配置clean插件的maven项目中执行mvn clean时，不会删除C:/a目录。

设置fileset的目录时候用到的<directory>标签不能乱用，比如<dir>，否则maven没法识别，因为maven使用pom设置插件参数（parameter）的时候用的是设置java bean的方式，之所以用<directory>标签，是因为在org.apache.maven.plugin.clean.Fileset.java中，Fileset类只有如下成员变量：

（参见：http://search.maven.org/remotecontent?filepath=org/apache/maven/plugins/maven-clean-plugin/2.4.1/maven-clean-plugin-2.4.1-source-release.zip）

[java]  view plain copy

 

1. private File directory;  
2.   
3. private String[] includes;  
4.   
5. private String[] excludes;  
6.   
7. private boolean followSymlinks;  

相关阅读：

1、Maven clean plugin - delete additional directories

http://maven.40175.n5.nabble.com/Maven-clean-plugin-delete-additional-directories-td122794.html

八、利用tomcat-maven-plugin插件将项目自动打包并部署到tomcat中   

Java代码   

1.  <!-- tomcat插件 -->  
2.     <plugin>  
3.         <groupId>org.codehaus.mojo</groupId>  
4.         <artifactId>tomcat-maven-plugin</artifactId>  
5.         <configuration>  
6.             <server>tomcat6-manager</server>  
7.             <path>/${project.build.name}</path>  
8.             <url>http://localhost:8080/manager</url>  
9.             <username>admin</username>  
10.             <password>admin</password>  
11.         </configuration>  
12.         <executions>  
13.             <execution>  
14.                 <phase>deploy</phase>  
15.                 <goals>  
16.                     <goal>deploy</goal>  
17.                 </goals>  
18.             </execution>  
19.         </executions>  
20.     </plugin>  
21. </plugins>  

path： 是指项目部署到tomcat后的项目名称  
url： 是指tomcat的manager访问地址  
server： 这个是tomcat服务名称设置，需要配置maven的settings.xml文件，在servers节点中手动配置server，如下所示：  

Java代码   

1. <server>  
2.     <id>tomcat6-manager</id>  
3.     <username>admin</username>  
4.     <password>admin</password>  
5. </server>  

九、利用cargo-maven2-plugin插件将项目自动打包并部署到tomcat中   

配置描述：使用maven做web项目时，cargo插件可以帮助你完成WAR包到服务器的部署及服务器的启动和关闭等工作，方便，快速！

[html]  view plain copy

 

1. <plugin>  
2.     <groupId>org.codehaus.cargo</groupId>  
3.     <artifactId>cargo-maven2-plugin</artifactId>  
4.     <version>1.2.0</version>  
5.     <configuration>  
6.         <container>  
7.             <containerId>${server_name}</containerId>  
8.             <home>${server_home}</home>  
9.         </container>  
10.         <configuration>  
11.             <type>existing</type>  
12.             <home>${server_home}</home>  
13.             <properties>  
14.                 <cargo.servlet.port>8088</cargo.servlet.port>  
15.             </properties>  
16.         </configuration>  
17.     </configuration>  
18. </plugin>  

注意，如果你的tomcat服务器的端口使用的不是默认的8080（如本例中的8088），则需要使用cargo.servlet.port参数将cargo的监听端口也配置到tomcat的那个监听端口（如本例中的8088），否则使用mvn cargo:run启动的服务器会在120000毫秒（120秒）后自动关闭！

mvn cargo:start命令完成WAR包部署后，启动服务器，然后会将服务器立即关掉；

mvn cargo:run命令完成WAR包部署后，启动服务器，直到你Ctrl+C将服务器关掉；

mvn cargo:stop命令关闭服务器。

参考：http://cargo.codehaus.org/Maven2+plugin

Java代码   

1. <plugin>  
2.                 <!-- 指定插件名称及版本号 -->  
3.                 <groupId>org.codehaus.cargo</groupId>  
4.                 <artifactId>cargo-maven2-plugin</artifactId>  
5.                 <version>1.2.3</version>  
6.                 <!-- 插件的Tomcat6.x配置 -->  
7.                 <configuration>  
8.                     <!-- 容器的配置 -->  
9.                     <container>  
10.                         <!-- 指定服务器版本 -->  
11.                         <containerId>tomcat6x</containerId>  
12.                         <!-- 指定服务器的安装目录 -->  
13.                         <home>E:Program Files omcat-6.0.32</home>  
14.                     </container>  
15.                     <!-- 具体的配置 -->  
16.                     <configuration>  
17.                         <!-- 部署模式：existing、standalone等 -->  
18.                         <type>existing</type>  
19.                         <!-- Tomcat的位置，即catalina.home -->  
20.                         <home>E:Program Files omcat-6.0.32</home>  
21.                         <!-- 配置属性 -->  
22.                         <properties>  
23.                             <!-- 管理地址 -->  
24.                             <cargo.tomcat.manager.url>http://localhost:8080/manager</cargo.tomcat.manager.url>  
25.                             <!-- Tomcat用户名 -->  
26.                             <cargo.remote.username>admin</cargo.remote.username>  
27.                             <!-- Tomcat密码 -->  
28.                             <cargo.remote.password>admin</cargo.remote.password>  
29.                             <!-- <cargo.jvmargs> -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8787 </cargo.jvmargs> -->  
30.                         </properties>  
31.                     </configuration>  
32.                 </configuration>  
33.             </plugin>  

username和password： 是指tomcat的tomcat-users.xml文件中配置的，文件路径为E:Program Files omcat-6.0.32conf omcat-users.xml，如下所示：  

Java代码   

1. <role rolename="manager"/>   
2. <user password="admin" roles="manager" username="admin"/>   

十、有时候插件检查不通过，需要人为的忽略对有些插件的检查   

Java代码   

1. <!-- 插件管理 -->  
2. <pluginManagement>  
3.     <plugins>  
4.         <plugin>  
5.             <groupId>org.eclipse.m2e</groupId>  
6.             <artifactId>lifecycle-mapping</artifactId>  
7.             <version>1.0.0</version>  
8.             <configuration>  
9.                 <lifecycleMappingMetadata>  
10.                     <pluginExecutions>  
11.                         <!-- 忽略2.0以上版本的maven-dependency-plugin的检查 -->  
12.                         <pluginExecution>  
13.                             <pluginExecutionFilter>  
14.                                 <groupId>org.apache.maven.plugins</groupId>  
15.                                 <artifactId>maven-dependency-plugin</artifactId>  
16.                                 <versionRange>[2.0,)</versionRange>  
17.                                 <goals>  
18.                                     <goal>copy-dependencies</goal>  
19.                                 </goals>  
20.                             </pluginExecutionFilter>  
21.                             <action>  
22.                                 <ignore />  
23.                             </action>  
24.                         </pluginExecution>  
25.                     </pluginExecutions>  
26.                 </lifecycleMappingMetadata>  
27.             </configuration>  
28.         </plugin>  
29.     </plugins>  
30. </pluginManagement>  

十一、maven-resources-plugin

配置描述：把web项目的输出copy到tomcat的webapp下

[html]  view plain copy

 

1. <plugin>  
2.     <groupId>org.apache.maven.plugins</groupId>  
3.     <artifactId>maven-resources-plugin</artifactId>  
4.     <version>2.5</version>  
5.     <executions>  
6.         <execution>  
7.             <id>deploy-website</id>  
8.             <phase>package</phase>  
9.             <goals>  
10.                 <goal>copy-resources</goal>  
11.             </goals>  
12.             <configuration>  
13.                 <outputDirectory>${server_home}/webapps/${project.build.finalName}</outputDirectory>  
14.                 <resources>  
15.                     <resource>  
16.                         <directory>${project.build.directory}/${project.build.finalName}</directory>  
17.                     </resource>  
18.                 </resources>  
19.             </configuration>  
20.         </execution>  
21.     </executions>  
22. </plugin>  

十二、maven-antrun-plugin

配置描述：在maven中使用antrun调用bat文件

（我这里调用的是tomcat的startup.bat文件，但是没有成功启动tomcat，提示说环境变量没配置，可我双击运行startup.bat将就可以运行，奇怪了……）

（现在知道原因了：antrun运行的bat文件，实际上是在${basedir}上运行bat文件里的内容，而tomcat的startup.bat文件在运行时会调用同目录下的其他bat文件，而这些bat文件在${basedir}目录下不存在！

解决方法：使用令一个bat文件，如mystartup.bat运行startup.bat，注意在运行startup.bat之前，需要在mystartup.bat文件中把目录切换到startup.bat所在的目录，搞定！

具体做法，参见：使用Maven的antrun插件启动Tomcat的两种方法：http://blog.csdn.net/lslxdx/article/details/7245695）

参见：http://markmail.org/message/c3igpnp7dvkajsrl

[html]  view plain copy

 

1. <plugin>  
2.     <artifactId>maven-antrun-plugin</artifactId>  
3.     <executions>  
4.       <execution>  
5.         <id>start-server</id>  
6.         <phase>package</phase>  
7.         <configuration>  
8.           <tasks>  
9.                <exec  
10.                  executable="${server_home}/bin/startup.bat"  
11.                  >  
12.                </exec>  
13.           </tasks>  
14.         </configuration>  
15.         <goals>  
16.           <goal>run</goal>  
17.         </goals>  
18.       </execution>  
19.     </executions>  
20. </plugin>  

先将我用到的自定义变量贴过来，防止插件中出现一些变量，大家不理解 

<!-- 全局属性配置 -->
<properties>
    <project.build.name>tools</project.build.name>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

project.build.name： 用来定义war包名称 
project.build.sourceEncoding： 用来定义资源文件的编码格式 

下面开始讲解常用的maven插件配置 

一、编译插件 

<!-- 编译插件 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <source>1.6</source>
        <target>1.6</target>
        <encoding>${project.build.sourceEncoding}</encoding>
    </configuration>
</plugin>

source：源代码编译版本； 
target：目标平台编译版本； 
encoding：字符集编码。 

二、设置资源文件的编码方式 

<!-- 设置资源文件的编码方式 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <version>2.4.3</version>
    <executions>
        <execution>
            <phase>compile</phase>
        </execution>
    </executions>
    <configuration>
        <encoding>${project.build.sourceEncoding}</encoding>
    </configuration>
</plugin>

xml、properties文件都是资源文件，编码的时候遇到中文总要进行转码！用什么编码？UTF-8，那就记得强制<encoding>${project.build.sourceEncoding}</encoding> 

三、自动拷贝jar包到target目录 

<!-- 依赖插件 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.6</version>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>compile</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <!-- ${project.build.directory}为Maven内置变量，缺省为target -->
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <!-- 表示是否不包含间接依赖的包 -->
                <excludeTransitive>false</excludeTransitive>
                <!-- 表示复制的jar文件去掉版本信息 -->
                <stripVersion>true</stripVersion>
            </configuration>
        </execution>
    </executions>
</plugin>

在部署war包时，需要将项目依赖的jar包，也打到war包中，因此就会用到上述插件 

四、生成源代码jar包 

<!-- 源代码打包插件 -->
<plugin>
    <artifactId>maven-source-plugin</artifactId>
    <version>2.1</version>
    <configuration>
        <!-- <finalName>${project.build.name}</finalName> -->
        <attach>true</attach>
        <encoding>${project.build.sourceEncoding}</encoding>
    </configuration>
    <executions>
        <execution>
            <phase>compile</phase>
            <goals>
                <goal>jar</goal>
            </goals>
        </execution>
    </executions>
</plugin>

该插件主要用于在打jar包时，把源代码也打成jar包 

五、将项目打成jar包 

<!-- jar包插件 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <archive>
            <manifest>
                <!-- 告知 maven-jar-plugin添加一个 Class-Path元素到 MANIFEST.MF文件，以及在Class-Path元素中包括所有依赖项 -->
                <addClasspath>true</addClasspath>
                <!-- 所有的依赖项应该位于 lib文件夹 -->
                <classpathPrefix>lib/</classpathPrefix>
                <!-- 当用户使用 lib命令执行JAR文件时，使用该元素定义将要执行的类名 -->
                <mainClass>com.zhengtian.tools.service.phone.MobilePhoneTool</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

在将项目打成jar包时，有时会需要将项目打成可以直接运行的jar包，因此就需要将项目依赖的jar包也打入jar包中，此时需要在Eclipse上安装例外一个插件，用来打可执行jar包，详情见链接http://zheng12tian.iteye.com/blog/1765626 

六、将项目打成war包 

<!-- war插件 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.1.1</version>
    <configuration>
        <!-- <warName>${project.build.name}</warName> -->
    </configuration>
</plugin>

encoding：强制字符集编码 
warName：war包名字——platform.war 
webappDirectory：产生war前，用于存放构建war包的目录——target/platform。 
warSourceDirectory：我把web工程搞成了eclipse下的WTP类型。我不喜欢maven产生的webapp目录，更喜欢WebContent！ 

需要注意的是： 
采用上述插件部署项目的话，使用clean package tomcat:redeploy命令。使用该命令前，需要先启动tomcat，实际上是为了让tomcat启动manager项目，实现动态部署 

此部署方式虽然也是动态部署的范畴，但是每次修改文件后，需要手动再次重新部署，才会加载更改。 

如果想让tomcat自动扫描项目的改动，自动加载，那么需要将maven工程的java全部编译的webapp目录下，然后将jar包和资源文件也打到webapp目录。最后在$CATALINA_HOME/conf /Catalina/localhost中添加一个xml文件，修改docbase为webapp目录。 

Tomcat常用的部署方式介绍：http://blog.csdn.net/yangxueyong/article/details/6130065 

七、在打包时，需要清空一些指定的目录 

<!-- clean插件 -->
<plugin>
    <artifactId>maven-clean-plugin</artifactId>
    <version>2.4.1</version>
    <configuration>
        <filesets>
            <fileset>
                <directory>src/main/webapp/WEB-INF/classes</directory>
            </fileset>
            <fileset>
                <directory>src/main/webapp/WEB-INF/lib</directory>
            </fileset>
            <fileset>
                <directory>${project.build.directory}</directory>
            </fileset>
        </filesets>
    </configuration>
</plugin>

八、利用tomcat-maven-plugin插件将项目自动打包并部署到tomcat中 

 <!-- tomcat插件 -->
    <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>tomcat-maven-plugin</artifactId>
        <configuration>
            <server>tomcat6-manager</server>
            <path>/${project.build.name}</path>
            <url>http://localhost:8080/manager</url>
            <username>admin</username>
            <password>admin</password>
        </configuration>
        <executions>
            <execution>
                <phase>deploy</phase>
                <goals>
                    <goal>deploy</goal>
                </goals>
            </execution>
        </executions>
    </plugin>
</plugins>

path：是指项目部署到tomcat后的项目名称 
url：是指tomcat的manager访问地址 
server：这个是tomcat服务名称设置，需要配置maven的settings.xml文件，在servers节点中手动配置server，如下所示： 

<server>
    <id>tomcat6-manager</id>
    <username>admin</username>
    <password>admin</password>
</server>

九、利用cargo-maven2-plugin插件将项目自动打包并部署到tomcat中 

<plugin>
                <!-- 指定插件名称及版本号 -->
                <groupId>org.codehaus.cargo</groupId>
                <artifactId>cargo-maven2-plugin</artifactId>
                <version>1.2.3</version>
                <!-- 插件的Tomcat6.x配置 -->
                <configuration>
                    <!-- 容器的配置 -->
                    <container>
                        <!-- 指定服务器版本 -->
                        <containerId>tomcat6x</containerId>
                        <!-- 指定服务器的安装目录 -->
                        <home>E:Program Files	omcat-6.0.32</home>
                    </container>
                    <!-- 具体的配置 -->
                    <configuration>
                        <!-- 部署模式：existing、standalone等 -->
                        <type>existing</type>
                        <!-- Tomcat的位置，即catalina.home -->
                        <home>E:Program Files	omcat-6.0.32</home>
                        <!-- 配置属性 -->
                        <properties>
                            <!-- 管理地址 -->
                            <cargo.tomcat.manager.url>http://localhost:8080/manager</cargo.tomcat.manager.url>
                            <!-- Tomcat用户名 -->
                            <cargo.remote.username>admin</cargo.remote.username>
                            <!-- Tomcat密码 -->
                            <cargo.remote.password>admin</cargo.remote.password>
                            <!-- <cargo.jvmargs> -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8787 </cargo.jvmargs> -->
                        </properties>
                    </configuration>
                </configuration>
            </plugin>

username和password：是指tomcat的tomcat-users.xml文件中配置的，文件路径为E:Program Files omcat-6.0.32conf omcat-users.xml，如下所示： 

<role rolename="manager"/>
<user password="admin" roles="manager" username="admin"/>

十、有时候插件检查不通过，需要人为的忽略对有些插件的检查 

<!-- 插件管理 -->
<pluginManagement>
    <plugins>
        <plugin>
            <groupId>org.eclipse.m2e</groupId>
            <artifactId>lifecycle-mapping</artifactId>
            <version>1.0.0</version>
            <configuration>
                <lifecycleMappingMetadata>
                    <pluginExecutions>
                        <!-- 忽略2.0以上版本的maven-dependency-plugin的检查 -->
                        <pluginExecution>
                            <pluginExecutionFilter>
                                <groupId>org.apache.maven.plugins</groupId>
                                <artifactId>maven-dependency-plugin</artifactId>
                                <versionRange>[2.0,)</versionRange>
                                <goals>
                                    <goal>copy-dependencies</goal>
                                </goals>
                            </pluginExecutionFilter>
                            <action>
                                <ignore />
                            </action>
                        </pluginExecution>
                    </pluginExecutions>
                </lifecycleMappingMetadata>
            </configuration>
        </plugin>
    </plugins>
</pluginManagement>

常用Maven插件介绍

我们都知道Maven本质上是一个插件框架，它的核心并不执行任何具体的构建任务，所有这些任务都交给插件来完成，例如编译源代码是由maven-compiler-plugin完成的。进一步说，每个任务对应了一个插件目标（goal），每个插件会有一个或者多个目标，例如maven-compiler-plugin的compile目标用来编译位于src/main/java/目录下的主源码，testCompile目标用来编译位于src/test/java/目录下的测试源码。

用户可以通过两种方式调用Maven插件目标。第一种方式是将插件目标与生命周期阶段（lifecycle phase）绑定，这样用户在命令行只是输入生命周期阶段而已，例如Maven默认将maven-compiler-plugin的compile目标与compile生命周期阶段绑定，因此命令mvn compile实际上是先定位到compile这一生命周期阶段，然后再根据绑定关系调用maven-compiler-plugin的compile目标。第二种方式是直接在命令行指定要执行的插件目标，例如mvn archetype:generate 就表示调用maven-archetype-plugin的generate目标，这种带冒号的调用方式与生命周期无关。

认识上述Maven插件的基本概念能帮助你理解Maven的工作机制，不过要想更高效率地使用Maven，了解一些常用的插件还是很有必要的，这可以帮助你避免一不小心重新发明轮子。多年来Maven社区积累了大量的经验，并随之形成了一个成熟的插件生态圈。Maven官方有两个插件列表，第一个列表的GroupId为org.apache.maven.plugins，这里的插件最为成熟，具体地址为：http://maven.apache.org/plugins/index.html。第二个列表的GroupId为org.codehaus.mojo，这里的插件没有那么核心，但也有不少十分有用，其地址为：http://mojo.codehaus.org/plugins.html。

接下来笔者根据自己的经验介绍一些最常用的Maven插件，在不同的环境下它们各自都有其出色的表现，熟练地使用它们能让你的日常构建工作事半功倍。

maven-antrun-plugin

http://maven.apache.org/plugins/maven-antrun-plugin/

maven-antrun-plugin能让用户在Maven项目中运行Ant任务。用户可以直接在该插件的配置以Ant的方式编写Target，然后交给该插件的run目标去执行。在一些由Ant往Maven迁移的项目中，该插件尤其有用。此外当你发现需要编写一些自定义程度很高的任务，同时又觉得Maven不够灵活时，也可以以Ant的方式实现之。maven-antrun-plugin的run目标通常与生命周期绑定运行。

maven-archetype-plugin

http://maven.apache.org/archetype/maven-archetype-plugin/

Archtype指项目的骨架，Maven初学者最开始执行的Maven命令可能就是mvn archetype:generate，这实际上就是让maven-archetype-plugin生成一个很简单的项目骨架，帮助开发者快速上手。可能也有人看到一些文档写了mvn archetype:create，但实际上create目标已经被弃用了，取而代之的是generate目标，该目标使用交互式的方式提示用户输入必要的信息以创建项目，体验更好。maven-archetype-plugin还有一些其他目标帮助用户自己定义项目原型，例如你由一个产品需要交付给很多客户进行二次开发，你就可以为他们提供一个Archtype，帮助他们快速上手。

maven-assembly-plugin

http://maven.apache.org/plugins/maven-assembly-plugin/

maven-assembly-plugin的用途是制作项目分发包，该分发包可能包含了项目的可执行文件、源代码、readme、平台脚本等等。maven-assembly-plugin支持各种主流的格式如zip、tar.gz、jar和war等，具体打包哪些文件是高度可控的，例如用户可以按文件级别的粒度、文件集级别的粒度、模块级别的粒度、以及依赖级别的粒度控制打包，此外，包含和排除配置也是支持的。maven-assembly-plugin要求用户使用一个名为assembly.xml的元数据文件来表述打包，它的single目标可以直接在命令行调用，也可以被绑定至生命周期。

maven-dependency-plugin

http://maven.apache.org/plugins/maven-dependency-plugin/

maven-dependency-plugin最大的用途是帮助分析项目依赖，dependency:list能够列出项目最终解析到的依赖列表，dependency:tree能进一步的描绘项目依赖树，dependency:analyze可以告诉你项目依赖潜在的问题，如果你有直接使用到的却未声明的依赖，该目标就会发出警告。maven-dependency-plugin还有很多目标帮助你操作依赖文件，例如dependency:copy-dependencies能将项目依赖从本地Maven仓库复制到某个特定的文件夹下面。

maven-enforcer-plugin

http://maven.apache.org/plugins/maven-enforcer-plugin/

在一个稍大一点的组织或团队中，你无法保证所有成员都熟悉Maven，那他们做一些比较愚蠢的事情就会变得很正常，例如给项目引入了外部的SNAPSHOT依赖而导致构建不稳定，使用了一个与大家不一致的Maven版本而经常抱怨构建出现诡异问题。maven-enforcer-plugin能够帮助你避免之类问题，它允许你创建一系列规则强制大家遵守，包括设定Java版本、设定Maven版本、禁止某些依赖、禁止SNAPSHOT依赖。只要在一个父POM配置规则，然后让大家继承，当规则遭到破坏的时候，Maven就会报错。除了标准的规则之外，你还可以扩展该插件，编写自己的规则。maven-enforcer-plugin的enforce目标负责检查规则，它默认绑定到生命周期的validate阶段。

maven-help-plugin

http://maven.apache.org/plugins/maven-help-plugin/

maven-help-plugin是一个小巧的辅助工具，最简单的help:system可以打印所有可用的环境变量和Java系统属性。help:effective-pom和help:effective-settings最为有用，它们分别打印项目的有效POM和有效settings，有效POM是指合并了所有父POM（包括Super POM）后的XML，当你不确定POM的某些信息从何而来时，就可以查看有效POM。有效settings同理，特别是当你发现自己配置的settings.xml没有生效时，就可以用help:effective-settings来验证。此外，maven-help-plugin的describe目标可以帮助你描述任何一个Maven插件的信息，还有all-profiles目标和active-profiles目标帮助查看项目的Profile。

maven-release-plugin

http://maven.apache.org/plugins/maven-release-plugin/

maven-release-plugin的用途是帮助自动化项目版本发布，它依赖于POM中的SCM信息。release:prepare用来准备版本发布，具体的工作包括检查是否有未提交代码、检查是否有SNAPSHOT依赖、升级项目的SNAPSHOT版本至RELEASE版本、为项目打标签等等。release:perform则是签出标签中的RELEASE源码，构建并发布。版本发布是非常琐碎的工作，它涉及了各种检查，而且由于该工作仅仅是偶尔需要，因此手动操作很容易遗漏一些细节，maven-release-plugin让该工作变得非常快速简便，不易出错。maven-release-plugin的各种目标通常直接在命令行调用，因为版本发布显然不是日常构建生命周期的一部分。

关于作者

许晓斌（Juven Xu），国内社区公认的Maven技术专家、Maven中文用户组创始人、Maven技术的先驱和积极推动者，著有《Maven实战》一书。对Maven有深刻的认识，实战经验丰富，不仅撰写了大量关于Maven的技术文章，而且还翻译了开源书籍《Maven权威指南》，对Maven技术在国内的普及和发展做出了很大的贡献。就职于Maven之父的公司，负责维护Maven中央仓库，是Maven仓库管理器Nexus（著名开源软件）的核心开发者之一，曾多次受邀到淘宝等大型企业开展Maven方面的培训。此外，他还是开源技术的积极倡导者和推动者，擅长Java开发和敏捷开发实践。他的个人网站是：http://www.juvenxu.com。

 

我们都知道Maven本质上是一个插件框架，它的核心并不执行任何具体的构建任务，所有这些任务都交给插件来完成，例如编译源代码是由maven- compiler-plugin完成的。进一步说，每个任务对应了一个插件目标（goal），每个插件会有一个或者多个目标，例如maven- compiler-plugin的compile目标用来编译位于src/main/java/目录下的主源码，testCompile目标用来编译位于src/test/java/目录下的测试源码。

用户可以通过两种方式调用Maven插件目标。第一种方式是将插件目标与生命周期阶段（lifecycle phase）绑定，这样用户在命令行只是输入生命周期阶段而已，例如Maven默认将maven-compiler-plugin的compile目标与 compile生命周期阶段绑定，因此命令mvn compile实际上是先定位到compile这一生命周期阶段，然后再根据绑定关系调用maven-compiler-plugin的compile目标。第二种方式是直接在命令行指定要执行的插件目标，例如mvn archetype:generate 就表示调用maven-archetype-plugin的generate目标，这种带冒号的调用方式与生命周期无关。

认识上述Maven插件的基本概念能帮助你理解Maven的工作机制，不过要想更高效率地使用Maven，了解一些常用的插件还是很有必要的，这可 以帮助你避免一不小心重新发明轮子。多年来Maven社区积累了大量的经验，并随之形成了一个成熟的插件生态圈。Maven官方有两个插件列表，第一个列 表的GroupId为org.apache.maven.plugins，这里的插件最为成熟，具体地址为：http://maven.apache.org/plugins/index.html。第二个列表的GroupId为org.codehaus.mojo，这里的插件没有那么核心，但也有不少十分有用，其地址为：http://mojo.codehaus.org/plugins.html。

接下来笔者根据自己的经验介绍一些最常用的Maven插件，在不同的环境下它们各自都有其出色的表现，熟练地使用它们能让你的日常构建工作事半功倍。

maven-antrun-plugin

http://maven.apache.org/plugins/maven-antrun-plugin/

maven-antrun-plugin能让用户在Maven项目中运行Ant任务。用户可以直接在该插件的配置以Ant的方式编写Target， 然后交给该插件的run目标去执行。在一些由Ant往Maven迁移的项目中，该插件尤其有用。此外当你发现需要编写一些自定义程度很高的任务，同时又觉 得Maven不够灵活时，也可以以Ant的方式实现之。maven-antrun-plugin的run目标通常与生命周期绑定运行。

maven-archetype-plugin

http://maven.apache.org/archetype/maven-archetype-plugin/

Archtype指项目的骨架，Maven初学者最开始执行的Maven命令可能就是mvn archetype:generate，这实际上就是让maven-archetype-plugin生成一个很简单的项目骨架，帮助开发者快速上手。可能也有人看到一些文档写了mvn archetype:create， 但实际上create目标已经被弃用了，取而代之的是generate目标，该目标使用交互式的方式提示用户输入必要的信息以创建项目，体验更好。 maven-archetype-plugin还有一些其他目标帮助用户自己定义项目原型，例如你由一个产品需要交付给很多客户进行二次开发，你就可以为 他们提供一个Archtype，帮助他们快速上手。

maven-assembly-plugin

http://maven.apache.org/plugins/maven-assembly-plugin/

maven-assembly-plugin的用途是制作项目分发包，该分发包可能包含了项目的可执行文件、源代码、readme、平台脚本等等。 maven-assembly-plugin支持各种主流的格式如zip、tar.gz、jar和war等，具体打包哪些文件是高度可控的，例如用户可以 按文件级别的粒度、文件集级别的粒度、模块级别的粒度、以及依赖级别的粒度控制打包，此外，包含和排除配置也是支持的。maven-assembly- plugin要求用户使用一个名为assembly.xml的元数据文件来表述打包，它的single目标可以直接在命令行调用，也可以被绑定至生命周期。

maven-dependency-plugin

http://maven.apache.org/plugins/maven-dependency-plugin/

maven-dependency-plugin最大的用途是帮助分析项目依赖，dependency:list能够列出项目最终解析到的依赖列表，dependency:tree能进一步的描绘项目依赖树，dependency:analyze可以告诉你项目依赖潜在的问题，如果你有直接使用到的却未声明的依赖，该目标就会发出警告。maven-dependency-plugin还有很多目标帮助你操作依赖文件，例如dependency:copy-dependencies能将项目依赖从本地Maven仓库复制到某个特定的文件夹下面。

maven-enforcer-plugin

http://maven.apache.org/plugins/maven-enforcer-plugin/

在一个稍大一点的组织或团队中，你无法保证所有成员都熟悉Maven，那他们做一些比较愚蠢的事情就会变得很正常，例如给项目引入了外部的 SNAPSHOT依赖而导致构建不稳定，使用了一个与大家不一致的Maven版本而经常抱怨构建出现诡异问题。maven-enforcer- plugin能够帮助你避免之类问题，它允许你创建一系列规则强制大家遵守，包括设定Java版本、设定Maven版本、禁止某些依赖、禁止 SNAPSHOT依赖。只要在一个父POM配置规则，然后让大家继承，当规则遭到破坏的时候，Maven就会报错。除了标准的规则之外，你还可以扩展该插 件，编写自己的规则。maven-enforcer-plugin的enforce目标负责检查规则，它默认绑定到生命周期的validate阶段。

maven-help-plugin

http://maven.apache.org/plugins/maven-help-plugin/

maven-help-plugin是一个小巧的辅助工具，最简单的help:system可以打印所有可用的环境变量和Java系统属性。help:effective-pom和help:effective-settings最 为有用，它们分别打印项目的有效POM和有效settings，有效POM是指合并了所有父POM（包括Super POM）后的XML，当你不确定POM的某些信息从何而来时，就可以查看有效POM。有效settings同理，特别是当你发现自己配置的 settings.xml没有生效时，就可以用help:effective-settings来验证。此外，maven-help-plugin的describe目标可以帮助你描述任何一个Maven插件的信息，还有all-profiles目标和active-profiles目标帮助查看项目的Profile。

maven-release-plugin

http://maven.apache.org/plugins/maven-release-plugin/

maven-release-plugin的用途是帮助自动化项目版本发布，它依赖于POM中的SCM信息。release:prepare用来准备版本发布，具体的工作包括检查是否有未提交代码、检查是否有SNAPSHOT依赖、升级项目的SNAPSHOT版本至RELEASE版本、为项目打标签等等。release:perform则 是签出标签中的RELEASE源码，构建并发布。版本发布是非常琐碎的工作，它涉及了各种检查，而且由于该工作仅仅是偶尔需要，因此手动操作很容易遗漏一 些细节，maven-release-plugin让该工作变得非常快速简便，不易出错。maven-release-plugin的各种目标通常直接在 命令行调用，因为版本发布显然不是日常构建生命周期的一部分。

maven-resources-plugin

http://maven.apache.org/plugins/maven-resources-plugin/

为了使项目结构更为清晰，Maven区别对待Java代码文件和资源文件，maven-compiler-plugin用来编译Java代码，maven-resources-plugin则用来处理资源文件。默认的主资源文件目录是src/main/resources，很多用户会需要添加额外的资源文件目录，这个时候就可以通过配置maven-resources-plugin来实现。此外，资源文件过滤也是Maven的一大特性，你可以在资源文件中使用${propertyName}形式的Maven属性，然后配置maven-resources-plugin开启对资源文件的过滤，之后就可以针对不同环境通过命令行或者Profile传入属性的值，以实现更为灵活的构建。

maven-surefire-plugin

http://maven.apache.org/plugins/maven-surefire-plugin/

可能是由于历史的原因，Maven 2/3中用于执行测试的插件不是maven-test-plugin，而是maven-surefire-plugin。其实大部分时间内，只要你的测试 类遵循通用的命令约定（以Test结尾、以TestCase结尾、或者以Test开头），就几乎不用知晓该插件的存在。然而在当你想要跳过测试、排除某些 测试类、或者使用一些TestNG特性的时候，了解maven-surefire-plugin的一些配置选项就很有用了。例如 mvn test -Dtest=FooTest 这样一条命令的效果是仅运行FooTest测试类，这是通过控制maven-surefire-plugin的test参数实现的。

build-helper-maven-plugin

http://mojo.codehaus.org/build-helper-maven-plugin/

Maven默认只允许指定一个主Java代码目录和一个测试Java代码目录，虽然这其实是个应当尽量遵守的约定，但偶尔你还是会希望能够指定多个 源码目录（例如为了应对遗留项目），build-helper-maven-plugin的add-source目标就是服务于这个目的，通常它被绑定到 默认生命周期的generate-sources阶段以添加额外的源码目录。需要强调的是，这种做法还是不推荐的，因为它破坏了 Maven的约定，而且可能会遇到其他严格遵守约定的插件工具无法正确识别额外的源码目录。

build-helper-maven-plugin的另一个非常有用的目标是attach-artifact，使用该目标你可以以classifier的形式选取部分项目文件生成附属构件，并同时install到本地仓库，也可以deploy到远程仓库。

exec-maven-plugin

http://mojo.codehaus.org/exec-maven-plugin/

exec-maven-plugin很好理解，顾名思义，它能让你运行任何本地的系统程序，在某些特定情况下，运行一个Maven外部的程序可能就是最简单的问题解决方案，这就是exec:exec的 用途，当然，该插件还允许你配置相关的程序运行参数。除了exec目标之外，exec-maven-plugin还提供了一个java目标，该目标要求你 提供一个mainClass参数，然后它能够利用当前项目的依赖作为classpath，在同一个JVM中运行该mainClass。有时候，为了简单的 演示一个命令行Java程序，你可以在POM中配置好exec-maven-plugin的相关运行参数，然后直接在命令运行 mvn exec:java 以查看运行效果。

jetty-maven-plugin

http://wiki.eclipse.org/Jetty/Feature/Jetty_Maven_Plugin

在进行Web开发的时候，打开浏览器对应用进行手动的测试几乎是无法避免的，这种测试方法通常就是将项目打包成war文件，然后部署到Web容器 中，再启动容器进行验证，这显然十分耗时。为了帮助开发者节省时间，jetty-maven-plugin应运而生，它完全兼容 Maven项目的目录结构，能够周期性地检查源文件，一旦发现变更后自动更新到内置的Jetty Web容器中。做一些基本配置后（例如Web应用的contextPath和自动扫描变更的时间间隔），你只要执行 mvn jetty:run ，然后在IDE中修改代码，代码经IDE自动编译后产生变更，再由jetty-maven-plugin侦测到后更新至Jetty容器，这时你就可以直接 测试Web页面了。需要注意的是，jetty-maven-plugin并不是宿主于Apache或Codehaus的官方插件，因此使用的时候需要额外 的配置settings.xml的pluginGroups元素，将org.mortbay.jetty这个pluginGroup加入。

versions-maven-plugin

http://mojo.codehaus.org/versions-maven-plugin/

很多Maven用户遇到过这样一个问题，当项目包含大量模块的时候，为他们集体更新版本就变成一件烦人的事情，到底有没有自动化工具能帮助完成这件 事情呢？（当然你可以使用sed之类的文本操作工具，不过不在本文讨论范围）答案是肯定的，versions-maven- plugin提供了很多目标帮助你管理Maven项目的各种版本信息。例如最常用的，命令 mvn versions:set -DnewVersion=1.1-SNAPSHOT 就能帮助你把所有模块的版本更新到1.1-SNAPSHOT。该插件还提供了其他一些很有用的目标，display-dependency- updates能告诉你项目依赖有哪些可用的更新；类似的display-plugin-updates能告诉你可用的插件更新；然后use- latest-versions能自动帮你将所有依赖升级到最新版本。最后，如果你对所做的更改满意，则可以使用 mvn versions:commit 提交，不满意的话也可以使用 mvn versions:revert 进行撤销。

小结

本文介绍了一些最常用的Maven插件，这里指的“常用”是指经常需要进行配置的插件，事实上我们用Maven的时候很多其它插件也是必须的，例如 默认的编译插件maven-compiler-plugin和默认的打包插件maven-jar-plugin，但因为很少需要对它们进行配置，因此不在 本文讨论范围。了解常用的Maven插件能帮助你事倍功半地完成项目构建任务，反之你就可能会因为经常遇到一些难以解决的问题而感到沮丧。本文介绍的插件 基本能覆盖大部分Maven用户的日常使用需要，如果你真有非常特殊的需求，自行编写一个Maven插件也不是难事，更何况还有这么多开放源代码的插件供 你参考。

本文的这个插件列表并不是一个完整列表，读者有兴趣的话也可以去仔细浏览一下Apache和Codehaus Mojo的Maven插件列表，以的到一个更为全面的认识。最后，在线的Maven仓库搜索引擎如http://search.maven.org/也能帮助你快速找到自己感兴趣的Maven插件。

maven关于打包的那些插件

在工作中使用maven创建java工程，管理jar包依赖，方便快捷。根据需要，需要把工程打包成各种需要的形式，这些打包插件就用到了。
现将各种打包用到的插件总结到这里，你可以参考官方文档，修改或者增加适合你的参数。

第一个：打源码包

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-source-plugin</artifactId> <version>2.1</version> <configuration> <attach>true</attach> </configuration> <executions> <execution> <phase>compile</phase> <goals> <goal>jar</goal> </goals> </execution> </executions> </plugin>

第二个：打全量包

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>1.2.1</version> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> <configuration> <transformers> <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> <mainClass>com.zhaoyanblog.Launcher</mainClass> </transformer> <!--防止spring多个包同名配置文件覆盖--> <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer"> <resource>META-INF/spring.handlers</resource> </transformer> <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer"> <resource>META-INF/spring.schemas</resource> </transformer </transformers> </configuration> </execution> </executions> </plugin>

第三个：copy依赖jar包

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <executions> <execution> <id>copy</id> <phase>package</phase> <goals> <goal>copy-dependencies</goal> </goals> <configuration> <includeScope>runtime</includeScope> <outputDirectory>target/lib/</outputDirectory> </configuration> </execution> </executions> </plugin>

第四个：指定main方法，修改manifest文件

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <version>2.3.2</version> <configuration> <archive> <manifest> <addClasspath>true</addClasspath> <classpathPrefix>lib</classpathPrefix> <mainClass>com.zhaoyanblog.Launcher</mainClass> </manifest> <manifestEntries> <Class-Path>conf/</Class-Path> </manifestEntries> </archive> <finalName>tools-${project.version}</finalName> </configuration> </plugin>

第五个：打压缩包。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-assembly-plugin</artifactId> <version>2.4</version> <executions> <execution> <id>make-tar.gz</id> <phase>package</phase> <goals> <goal>single</goal> </goals> <configuration> <finalName>${project.build.finalName}</finalName> <skipAssembly>false</skipAssembly> <descriptors> <descriptor>tar.gz.xml</descriptor> </descriptors> </configuration> </execution> </executions> </plugin>

同时要增加一个tar.gz.xml文件，描述打包内容

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

<?xml version="1.0" encoding="UTF-8"?>   <assembly 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/assembly-1.0.0.xsd"> <id>package</id> <formats> <format>tar.gz</format> </formats> <includeBaseDirectory>false</includeBaseDirectory> <fileSets> <fileSet> <directory>bin</directory> <outputDirectory>/</outputDirectory> <fileMode>0755</fileMode> <directoryMode>0755</directoryMode> </fileSet> <fileSet> <directory>${project.build.directory}/conf</directory> <outputDirectory>/conf</outputDirectory> <includes> <include>*.xml</include> <include>*.properties</include> </includes> </fileSet> </fileSets> <files> <file> <source>${project.build.directory}/${project.build.finalName}.jar</source> <destName>/${project.build.finalName}.jar</destName> </file> </files> <dependencySets> <dependencySet> <outputDirectory>lib</outputDirectory> <scope>runtime</scope> </dependencySet> </dependencySets> </assembly>