maven 插件

1：为了使项目结构更为清晰，Maven区别对待Java代码文件和资源文件，

                 maven-compiler-plugin用来编译Java代码，

                 maven-resources-plugin则用来处理资源文件。

maven-compiler-plugin（可以指定jdk版本及编译使用的字符集，这里使用的是compiler2.0版本）

<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.0</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>

 

2：过滤不毕要的资源文件

<build>
 
<filters>
			<filter>D:/WebApp/rmi.test/antx.properties</filter>
		</filters>
		<resources>
			<resource>
				<directory>src/main/resources</directory>
				<includes>
					<include>**.xml</include>
				</includes>
				<filtering>true</filtering>
			</resource>
			<resource>
				<directory>src/main/resources</directory>
				<excludes>	
					<exclude>**.xml</exclude>
				</excludes>
			</resource>
		</resources>
</build>

 

可实现将src/main/resources下的所有.xml文件过滤，用D:/WebApp/rmi.test/antx.properties中的配置属性替换.xml中${xx.xx.xx}.   

3：

默认的主资源文件目录是src/main/resources，很多用户会需要添加额外的资源文件目录，这个时候就可以通过配置maven-resources-plugin即使用<resources>来实现。如下：

<resource>
				<directory>src/main/webapp</directory>
				<includes>
					<include>WEB-INF/**.xml</include>
				</includes>
				<filtering>true</filtering>
			</resource>

 

编译后，src/main/webapp/WEB-INF及其下的所有.xml文件将同时在target\工程名\WEB-INF\classes路径下 

 

转的

Maven是一个常用的Java build Manager, 使用Maven可以很好的对Java Project的dependency进行管理. 这里我记录几个比较常用的Plugin配置. 

 

1. 生成JAR打包文件:

    过滤xml不打到jar包中
    配置jar包的入口，即manifest.mf的Main-Class（main方法所在的类）

    配置jar包的lib依赖，即manifest.mf的Class-Path

<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-jar-plugin</artifactId>
				<version>2.3.2</version>
				<configuration>
					<excludes>
						<exclude>conf/*.xml</exclude>
					</excludes>

					<archive>
						<manifest>
							<mainClass>com.chinacache.billing.normandy.deployconfig.main.Main</mainClass>
							<addClasspath>true</addClasspath>        <!--是否配置Class-Path-->
							<classpathPrefix>lib/</classpathPrefix>   <!--依赖路径Class-Path-->
						</manifest>
						<manifestEntries>
							<Class-Path>.</Class-Path>   <!--依赖在jar包的当前目录 Class-Path-->
						</manifestEntries>
					</archive>
				</configuration>
			</plugin>

 

1. 拷贝XML配置文件:
   
   [html]   view plain copy

   1. <plugin>  
   2.                 <artifactId>maven-resources-plugin</artifactId>  
   3.                 <executions>  
   4.                     <execution>  
   5.                         <id>copy-resources</id>  
   6.                         <phase>package</phase>  
   7.                         <goals>  
   8.                             <goal>copy-resources</goal>  
   9.                         </goals>  
   10.                         <configuration>  
   11.                             <outputDirectory>target</outputDirectory>  
   12.                             <resources>  
   13.                                 <resource>  
   14.                                     <directory>src/main/resources</directory>  
   15.                                     <filtering>true</filtering>  
   16.                                 </resource>  
   17.                             </resources>  
   18.                         </configuration>  
   19.                     </execution>  
   20.                 </executions>  
   21.             </plugin>  
   这个plugin配置将把在src/main/resources文件夹下的配置文件都拷贝到target文件夹. 这种文件夹配置是IntelliJ下的默认配制.
2. 拷贝所有的Dependency JARs:
   
   [html]   view plain copy

   1. <plugin>  
   2.                 <groupId>org.apache.maven.plugins</groupId>  
   3.                 <artifactId>maven-dependency-plugin</artifactId>  
   4.                 <executions>  
   5.                     <execution>  
   6.                         <id>copy-dependencies</id>  
   7.                         <phase>package</phase>  
   8.                         <goals>  
   9.                             <goal>copy-dependencies</goal>  
   10.                         </goals>  
   11.                         <configuration>  
   12.                             <outputDirectory>target/libs</outputDirectory>  
   13.                             <overWriteReleases>false</overWriteReleases>  
   14.                             <overWriteSnapshots>false</overWriteSnapshots>  
   15.                             <overWriteIfNewer>true</overWriteIfNewer>  
   16.                         </configuration>  
   17.                     </execution>  
   18.                 </executions>  
   19.             </plugin>  
   这个plugin将拷贝所有的Dependency JARs到target/libs文件夹下, 这样只要添加这个目录到classpath下, 我们就可以在没有IDE的环境的情况下直接运行我们的程序. 
3. 生成运行文件:
   
   [html]   view plain copy

   1. <plugin>  
   2.                 <groupId>org.apache.maven.plugins</groupId>  
   3.                 <artifactId>maven-antrun-plugin</artifactId>  
   4.                 <executions>  
   5.                     <execution>  
   6.                         <id>manifest</id>  
   7.                         <phase>package</phase>  
   8.                         <goals>  
   9.                             <goal>run</goal>  
   10.                         </goals>  
   11.                         <configuration>  
   12.                             <tasks>  
   13.                                 <echo file="target/runjetty.sh">  
   14.                                     java -cp "libs/*:jettysetup-1.0-SNAPSHOT.jar" weblog.examples.jettysetup.JettyLauncher  
   15.                                 </echo>  
   16.                             </tasks>  
   17.                         </configuration>  
   18.                     </execution>  
   19.                 </executions>  
   20.             </plugin>  
   通过这个plugin配置, 我们将在target文件夹下生成一个叫runjetty.sh的文件来设置我们的classpath, 这样我们就可以通过这个脚本直接运行我们的程序了. 上面的这个例子是我在另一篇配置Jetty环境的文章中使用的, 整个的pom.xml配置文件可以在Github上找到.

通过上面的4个简单的配置, 我们可以实现对我们的项目进行打包, 同时拷贝配置文件, 和Dependency JAR文件, 生成执行脚本, 这个打包有几个优势:

 

1. 打包文件不包含配置文件, 这样我们可以很方便得对配置文件进行修改
2. 打包文件不包含Dependency JARs, 由于这些JAR并没有打包在我们的project jar文件里, 当我们有多个项目打包文件的时候, 这些JAR将会被共享.