Maven打包方式

最新推荐文章于 2024-08-27 17:49:26 发布

靓玲珑

最新推荐文章于 2024-08-27 17:49:26 发布

阅读量266

点赞数

文章标签： maven jar

以storm本地版和打jar包为例。打jar包分为三种方式。

1.——————————只打自己的包，不打依赖包——————————
pom下什么也不用设置，或者设置个打包编译的JDK就行了，例如

           <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

2.——————————打自己的包，把自己的包放在当前目录下的lib文件夹下——————————
将项目中的JAR包的依赖包输出到指定的目录下,修改outputDirectory配置，如下面的${project.build.directory}/lib。如想将打包好的JAR包可以通过命令直接运行，如java -jar xx.jar，还需要制定manifest配置的classpathPrefix与上面配置的相对应,如上面把依赖JAR包输出到了lib，则这里的classpathPrefix也应指定为lib/；同时，并指定出程序的入口类，在配置mainClass节点中配好入口类的全类名。
这种打包方式对于JAVA项目是通用的，不管是不是springBoot的项目还是传统的JAVA项目，都可行。

<build>
             <plugins>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                            <mainClass>com.storm.WordCountTopologyMain</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy</id>
                        <phase>install</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
 </build>

   出错原因，上次jdk1.7就错了，改成1.8正确了，可能必须跟eclipse显示的一样，或者版本太低了，package和install都一样，不过必须一致，如果提示jdk过低，必须要更新下maven

这种打包方式会把maven的包放在classpath下的lib下，classpath就是相对于主类所在路径就是classpath，也就是.class或者.jar。并且JAR包中，有设置，如图，还会加上打包的JDK，因为上面的代码设置了。
这里写图片描述

但是自己文件夹里的依赖包打不上，为了打上去，必须在manifast下面添加这三行：

<manifestEntries>  
                            <Class-Path>.</Class-Path>  
                        </manifestEntries>  

  <Class-Path>.</Class-Path>  //设置为.时，当前路径下任何.class都能找到。
  <Class-Path>./abc.jar</Class-Path>  //设置成这样时，把自己依赖的jar包放在当前路径下，也就是主类所在的路径下，就能找到了。

但是userlibrary还是不能打进去，解决方法刚才的，设置到. 里，或者打好后，用winrar打开，在manifest.MF里手动设置。

3————————————maven打成一个超级大的jar，但是Spring框架会出错。

使用maven-assembly-plugin插件打包

 <plugin>
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-assembly-plugin</artifactId>  
            <version>2.5.5</version>  
            <configuration>  
                <archive>  
                    <manifest>  
                        <mainClass>com.\storm.WordCountTopologyMain</mainClass>  
                    </manifest>  
                </archive>  
                <descriptorRefs>  
                    <descriptorRef>jar-with-dependencies</descriptorRef>  
                </descriptorRefs>  
            </configuration>  
        </plugin>

这种打包只能打maven依赖的JAR自己的JAR没法打。
打包命令：package assembly:single
但此种方式对于传统的JAVA项目打包没问题，如是打有spring框架的JAR包就不可以了。可以采用maven-shade-plugin的插件来打包，来实现spring框架的打包

4.————————————maven打jar不用那个复杂命令

      <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-assembly-plugin</artifactId>  
            <version>2.5.5</version>  
            <configuration>  
                <archive>  
                    <manifest>  
                        <mainClass>com.storm.WordCountTopologyMain</mainClass>  
                    </manifest>  
                </archive>  
                <descriptorRefs>  
                    <descriptorRef>jar-with-dependencies</descriptorRef>  
                </descriptorRefs>  
            </configuration>  
            <executions>  
                <execution>  
                    <id>make-assembly</id>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>single</goal>  
                    </goals>  
                </execution>  
            </executions>  
        </plugin>

直接用package命令就行了。
5.————————————maven打成spring框架的大JAR的方式：

1.<build>  
2.    <plugins>  
3.  
4.        <plugin>  
5.            <groupId>org.apache.maven.plugins</groupId>  
6.            <artifactId>maven-shade-plugin</artifactId>  
7.            <version>2.4.1</version>  
8.            <executions>  
9.                <execution>  
10.                    <phase>package</phase>  
11.                    <goals>  
12.                        <goal>shade</goal>  
13.                    </goals>  
14.                    <configuration>  
15.                        <transformers>  
16.                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
17.                                <mainClass>com.xxg.Main</mainClass>  
18.                            </transformer>  
19.                        </transformers>  
20.                    </configuration>  
21.                </execution>  
22.            </executions>  
23.        </plugin>  
24.  
25.    </plugins>  
26.</build>

配置完成后，执行mvn package即可打包。在target目录下会生成两个jar包，注意不是original-xxx.jar文件，而是另外一个。和maven-assembly-plugin一样，生成的jar文件包含了所有依赖，所以可以直接运行。
如果项目中用到了Spring Framework，将依赖打到一个jar包中，运行时会出现读取XML schema文件出错。原因是Spring Framework的多个jar包中包含相同的文件spring.handlers和spring.schemas，如果生成一个jar包会互相覆盖。为了避免互相影响，可以使用AppendingTransformer来对文件内容追加合并：

1.<build>  
2.    <plugins>  
3.  
4.        <plugin>  
5.            <groupId>org.apache.maven.plugins</groupId>  
6.            <artifactId>maven-shade-plugin</artifactId>  
7.            <version>2.4.1</version>  
8.            <executions>  
9.                <execution>  
10.                    <phase>package</phase>  
11.                    <goals>  
12.                        <goal>shade</goal>  
13.                    </goals>  
14.                    <configuration>  
15.                        <transformers>  
16.                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
17.                                <mainClass>com.xxg.Main</mainClass>  
18.                            </transformer>  
19.                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
20.                                <resource>META-INF/spring.handlers</resource>  
21.                            </transformer>  
22.                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
23.                                <resource>META-INF/spring.schemas</resource>  
24.                            </transformer>  
25.                        </transformers>  
26.                    </configuration>  
27.                </execution>  
28.            </executions>  
29.        </plugin>  
30.  
31.    </plugins>  
32.</build>

附录：eclipse打jar包
必须是javaprofile文件。

我们可以选择把自己的jar打进去，但是userlib打不进去，这个无所谓，但是把自己lib打进去这个大JAR有时候找不到主类。
据说这是eclipse本身的问题，建议用fat-jar
另外一种方法就是把自己的JAR放在JDK运行时必须的路径，这样不太好，但是可以运行。
还有一种方法就是在打包的时候不选这个路径。等打好后，只有自己的主类。然后用winrar打开MANIFEST.MF

Manifest-Version: 1.0

Class-Path: joda-time-2.2.jar

Main-Class: main.java.hello.HelloWorld
修改添加。class-path就行了，然后怎么添加，jar就放在哪，当然我们可以再运行的时候自己写上java -jar -classpath:c:/这种

至于eclispe自己生成的.classpath记录了eclipse是否把文件夹当成个java项目。