Maven 技巧

Maven 技巧

 mvn install:install-file -Dfile=/Users/leone/Downloads/maven-replacer-plugin-1.4.0.jar -DgroupId=com.google.code.maven-replacer-plugin -DartifactId=replacer -Dversion=1.4.0 -Dpackaging=jar

JAVA 命令参数详解：

1、-D<name>=<value> set a system property  设置系统属性。

java -D参数简化加入多个jar

      java命令引入jar时可以-cp参数，但时-cp不能用通配符(多个jar时什么烦要一个个写,不能*.jar)，面通常的jar都在同一目录，且多于1个。前些日子找到（发现）-Djava.ext.dirs太好。

如：

java -Djava.ext.dirs=lib MyClass  

 

可以在运行前配置一些属性，比如路径什么的。

java -Dconfig="d:/config/config.xml" Abc

这样在Abc中就可以通过System.getProperty("config");获得这个值了。

    Java独立应用程序的执行有两种方式：
  　java -jar 命令
和 java -classpath 命令

    其中，因为java -jar 不接收classpath参数（或者说-classpath对它不起作用），因此必须把所有依赖的文件都打到一个jar里（比如 One jar）。这样就存在一个问题：修改这个独立应用程序的配置文件会很不方便。（ps:当前路径是它的类路径）。
    所以除非不用配置信息或从命令行指定配置信息，更好的方式应该是使用java -cp（即-classpath）的方式，并从类路径中读取配置文件。

    那么，一个独立应用程序的目录结构可以是如下形式：
    1、一个lib文件夹用于存放这个独立应用程序所依赖的jar包。
    2、把这个独立应用程序所依赖的配置文件（而且是可能需要修改的）放在与jar包同级目录下。
    3、一个jar包，里面是主程序。

    若要执行这个独立应用程序，可以使用脚本拼出classpath的值，然后调用java -cp命令。
   
    在Linux下使用shell脚本：
   

Shell代码  

1. CLASSPATH="."  
2. # 遍历应用程序依赖的jar包，并加入CLASSPATH。  
3. for jarfile in `ls lib/.`; do  
4.     CLASSPATH="${CLASSPATH}:lib/$jarfile"  
5. done  
6.  
7. #---------------下面是以前写错的部分，不需要这种方式把配置文件加入到类中径中。  
8. # 因为类路径中设都应该是目录（而不是文件），jar文件也是按目录来处理的  
9. #  
10. # 配置文件的遍历（与上类似）  
11. # 这里面我的配置文件都是xml的  
12. #for configfile in `ls *.xml`; do  
13. #    CLASSPATH="configfile:${CLASSPATH}"  
14.  
15. export CLASSPATH  
16. java -cp ${CLASSPATH} Test  

    在windows平台下就要麻烦一些了，使用dos批处理：
   

Batch代码  

1. @echo off  
2. for %%i in (lib/*.jar) do call cpappend.bat %%i  
3. java -cp %CLASSPATH% Test  

    下面是cpappend.bat：
   

Batch代码  

1. @echo off  
2. if ""%1"" =="""" goto end  
3. set CLASSPATH=%CLASSPATH%;lib/%1  
4. shift  
5.  
6. rem Process the remaining arguments  
7. :setArgs  
8. if ""%1"" =="""" goto doneSetArgs  
9. set CLASSPATH=%CLASSPATH% %1  
10. shift  
11. goto setArgs  
12. :doneSetArgs  
13. :end  

    cpappend.bat是不是见过？没错，tomcat下的，直接从那抄的，dos的批处理的写法我是没研究明白。

    set CLASSPATH=%CLASSPATH%;lib/%1后面不要有空格。

注：类路径中，最好把配置文件的路径放在jar文件的路径之前，因为我们实际项目中遇到过：有的jar包中包含同名配置文件把我们自己的配置文件给覆盖了的情况。改一下在classpath中的顺序，这样就可以让程序优先使用我们的配置文件。

    这样，方便修改配置的独立应用程序的执行方法已经出来了。下面的问题是，那些依赖的jar包，以及配置文件谁来拷出来？用maven来做这件事是最方便不过的了。
    使用maven的resources插件。
    下面我们要做的就是：在使用maven打包时，把程序依赖的jar包都拷出来，配置文件拷出来。同时，因为要使用外部的配置文件，所以要避免把配置文件打到jar包里。pom里的配置如下：
   

Pom代码  

1. <plugin>  
2.     <groupId>org.apache.maven.plugins</groupId>  
3.     <artifactId>maven-jar-plugin</artifactId>  
4.     <configuration>  
5.         <archive>  
6.             <manifest>  
7.                 <addClasspath>true</addClasspath><!--加载class -->  
8.                 <classpathPrefix>lib/</classpathPrefix><!--加载的class目录的前缀（依赖的jar目录） -->  
9.                 <mainClass>test.Test</mainClass><!--入口类名 -->  
10.             </manifest>  
11.         </archive>  
12.     </configuration>  
13. </plugin>  
14. <!-- 把依赖的jar包拷到lib目录下 -->  
15. <plugin>  
16.     <groupId>org.apache.maven.plugins</groupId>  
17.     <artifactId>maven-dependency-plugin</artifactId>  
18.     <executions>  
19.         <execution>  
20.             <id>copy-dependencies</id>  
21.             <phase>package</phase>  
22.             <goals>  
23.                 <goal>copy-dependencies</goal>  
24.             </goals>  
25.             <configuration>  
26.                 <outputDirectory>${project.build.directory}/lib</outputDirectory>  
27.                 <overWriteReleases>false</overWriteReleases>  
28.                 <overWriteSnapshots>false</overWriteSnapshots>  
29.                 <overWriteIfNewer>true</overWriteIfNewer>  
30.             </configuration>  
31.         </execution>  
32.     </executions>  
33. </plugin>  
34.     <!-- 以utf-8编码拷贝配置文件，拷贝过程中是可以做变量替换的，也就是说你的配置文件可以是个模板，里面的${}所包含的内容是可以拷贝过程中替换的 -->  
35. <plugin>  
36.     <groupId>org.apache.maven.plugins</groupId>  
37.     <artifactId>maven-resources-plugin</artifactId>  
38.     <version>2.3</version>  
39.     <executions>  
40.         <execution>  
41.             <id>copy-resources</id>  
42.             <phase>package</phase>  
43.             <goals>  
44.                 <goal>copy-resources</goal>  
45.             </goals>  
46.             <configuration>  
47.                 <encoding>UTF-8</encoding>  
48.                 <outputDirectory>${project.build.directory}</outputDirectory><!--把配置文件拷到和jar包同一个路径下 -->  
49.                 <resources>  
50.                     <resource>  
51.                         <directory>src/main/resources/</directory>  
52.                         <includes>  
53.                             <include>config.xml</include>  
54.                             <include>log4j.xml</include>  
55.                         </includes>  
56.                         <filtering>true</filtering>  
57.                     </resource>  
58.                 </resources>  
59.             </configuration>  
60.         </execution>  
61.     </executions>  
62. </plugin>  
63. <!-- 打jar包时需要把配置文件给排除在外 -->  
64. <plugin>  
65.     <groupId>org.apache.maven.plugins</groupId>  
66.     <artifactId>maven-jar-plugin</artifactId>  
67.     <executions>  
68.         <execution>  
69.             <phase>package</phase>  
70.             <goals>  
71.                 <goal>jar</goal>  
72.             </goals>  
73.             <configuration>  
74.                 <classifier>lib</classifier>  
75.                 <excludes>  
76.                     <exclude>config.xml</exclude>  
77.                     <exclude>log4j.xml</exclude>  
78.                 </excludes>  
79.             </configuration>  
80.         </execution>  
81.     </executions>  
82. </plugin>  
83.    

上面有几个需要特别说明的地方：
1、phase节点，表示要在什么阶段执行这个任务，比如

Pom代码  

1. <phase>package</phase>  
2.                         <goals>  
3.                             <goal>copy-dependencies</goal>  
4.                         </goals>  

表示在打包（package）之前执行copy-dependencies的任务（关于copy-dependencies，请查阅resources插件的说明）。
2、最后一个plugin节点中的classifier节点，表示这种方式（排除了配置文件）打出的jar包通过什么来和别的jar包区分开，我设的值是lib，这样打出来的包名就是：xxxx-lib.jar
3、最后一个plugin节点中的：

Pom代码  

1. <exclude>config.xml</exclude>                               <exclude>log4j.xml</exclude>  

可以写成：

Pom代码  

1. <exclude>*.xml</exclude>  

我没这么写，是因为我还有其它的.xml文件不需要放在外面。

到这里，用maven打独立应用程序的jar包的方式就讲解完了。在这再补充一个小知识。
如果你有多个工程，统一用一个父pom来管理（这些工程的pom都继承自父pom），如果有的工程中使用了resources插件，你在使用maven打包时，会出现错误，maven命令无法成功执行。
提示的错误大意是：你在pom中指定要执行copy-resources任务，却没有resources插件。
解决的办法是在父pom中加入：

Pom代码  

1. <pluginManagement>  
2.           <plugins>  
3.             <plugin>  
4.               <groupId>org.apache.maven.plugins</groupId>  
5.               <artifactId>maven-resources-plugin</artifactId>  
6.               <version>2.3</version>  
7.               <configuration>  
8.                 <encoding>UTF-8</encoding>  
9.               </configuration>  
10.             </plugin>  
11.           </plugins>  
12.         </pluginManagement>  

<build>

<finalName>FlightTask</finalName>
<plugins>

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <mainClass>youmainclasspath</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>

</plugins>
</build>

执行 mvn dependency:copy-dependencies -DoutputDirectory=lib package

然后把lib里的所有jar放到你工程的jar包所在的目录

运行java -jar youjar.jar