devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

maven打war包和jar包的方式（项目本身与依赖的jar包合并或者分离两种方式）

作者：我家自动化 | 2024-03-25 08:11:32

赞

踩

maven打war包

maven怎么打war包

一个童鞋问我maven怎么打war包，一听有点懵，懵的不是maven到底该怎么打war包，我不会？而是觉得maven打war包需要配置吗，也许只有最简单的才是最适合的。maven配置文件pom.xml的基本结构：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.   <groupId>com.roadjava</groupId>
  5.   <artifactId>fraud</artifactId>
  6.   <version>0.0.1-SNAPSHOT</version>
  7.   <packaging>war</packaging>
  8.   <name>fraud</name>
  9.   <description>反欺诈_群组</description>
  10.   <properties>
  11.   	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  12.   	<spring.version>4.0.0.RELEASE</spring.version>
  13.   	<java.version>1.7</java.version>
  14. 		<java.encoding>UTF-8</java.encoding>
  15.   </properties>
  16.   <dependencies>  
  17. 		  <dependency>
  18. 		    <groupId>net.sf.json-lib</groupId>
  19. 		    <artifactId>json-lib</artifactId>
  20. 		    <version>2.4</version>
  21. 		    <classifier>jdk15</classifier> 
  22. 		</dependency>
  23. 		<!--这里很多依赖我省略了...-->
  24.     </dependencies>  
  25. </project>

针对具有上面的pom.xml的maven web工程怎么打war包，简单的很，直接使用命令"maven  package"即可打出名字为“fraud-0.0.1-SNAPSHOT.war”的war包，一点错误没有，可以直接放到web容器中去运行。这就是最简单的方式，也是最常用的方式，至于还有其他配置只是针对特定项目而言的，没啥特殊要求就像上面的方式编写pom即可。

其他要求，比如：

        一、我想修改最终生成的war包的名字，默认生成的war包名字是“fraud-0.0.1-SNAPSHOT.war”，这是由artifactId+“-”+version组成的，我不喜欢这个名字，如何修改？

        二、我想指定jdk编译级别为1.6，怎么指定？

我就拿上面的两个需求举例子：

针对上面两个需求，只需要加入如下配置：

  1.  <build>
  2.      	<finalName>xfraud</finalName>
  3. 	    <plugins>
  4. 			<plugin>
  5. 				<artifactId>maven-compiler-plugin</artifactId>
  6. 				<configuration>
  7. 					<source>${java.version}</source>
  8. 					<target>${java.version}</target>
  9. 					<encoding>${java.encoding}</encoding>
  10. 				</configuration>
  11. 			</plugin>
  12. 	    </plugins>
  13. </build>

其中，finalName指定了你执行命令“maven package”后最终生成的war包的名字。

通过maven-compiler-plugin这个plugin指定编译级别。

提醒：不需要担心的是，使用maven打war包，依赖的jar包都会被放入war包之中，这点跟打jar包的时候还是要区分开的。

maven打jar包--项目本身jar与依赖jar分离打包并可以直接运行main函数

maven打jar包，这里牵涉到的问题需要考虑很多，比如，需要被打包为jar的工程是否依赖其他的jar？再比如，需要被打包为jar的工程是否需要直接运行主类(需要运行main函数)还是只是给其他应用提供服务（不需要运行main函数）？

一、我们先来如何打最为普通的jar包，即不依赖其他的jar包，也不需要直接运行main函数的，pom.xml：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.   <groupId>services</groupId>
  5.   <artifactId>jarservice</artifactId>
  6.   <version>0.0.1-SNAPSHOT</version>
  7.   <packaging>jar</packaging>
  8. </project>

说白了，你啥也不写，使用新建好的maven工程默认的pom.xml,然后运行maven打包命令"maven package"，最终在target目录下将会生产名为“jarservice-0.0.1-SNAPSHOT.jar”的jar包，这个jar包只包含项目的class文件和资源文件（如果有的话），不能直接运行。

试着运行一下这个jar包会报什么错误呢？

  1. D:\workspace2\jarservice\target>java -jar jarservice-0.0.1-SNAPSHOT.jar jarservice.ReadJson
  2. jarservice-0.0.1-SNAPSHOT.jar中没有主清单属性

其中jarservice.ReadJson是我这个项目里面唯一的一个类：

  1. package jarservice;
  2. public class ReadJson {
  3. 	public static void main(String[] args) {
  4. 		System.out.println("readjson");
  5. 	}
  6. }

可以看到，main函数并不能运行。因此如果使用默认的pom.xml打包jar的话，最终的结果是不包含依赖的其他jar包（不能直接拿到任何地方去运行），同时也不能直接运行main函数。

二、可以直接运行main函数的jar包

        循序渐进的来吧，现在我们来看如何使打出的jar包能够运行main函数，但是仍然包含依赖的jar包，修改pom.xml，在project标签里面加入如下内容：

  1. <build>
  2. 		<plugins>
  3. 			<plugin>
  4. 			    <groupId>org.apache.maven.plugins</groupId>
  5. 			    <artifactId>maven-jar-plugin</artifactId>
  6. 			    <configuration>
  7. 			        <source>1.7</source>
  8. 			        <target>1.7</target>
  9. 			        <archive>
  10. 			            <manifest>
  11. 			                <mainClass>jarservice.ReadJson</mainClass>
  12. 			            </manifest>
  13. 			        </archive>
  14. 			    </configuration>
  15. 			</plugin>
  16. 		</plugins>    
  17. </build>

上面是配置maven 的打包插件maven-jar-plugin的内容，在manifest的mainClass中指定包含main方法的全类名即可。注意哦，manifest是"清单"的意思，是m--a--n--i,不是main(主要)。运行：

  1. D:\workspace2\jarservice\target>java -jar jarservice-0.0.1-SNAPSHOT.jar jarservice.ReadJson
  2. readjson

查看生成的jarservice-0.0.1-SNAPSHOT.jar中的清单文件MANIFEST.MF的内容：

Manifest-Version: 1.0

Built-By: zhao

Build-Jdk: 1.7.0_79

Created-By: Apache Maven 3.3.3

Main-Class: jarservice.ReadJson

Archiver-Version: Plexus Archiver

Main-Class选项正好印证了我们设定的mainClass。

三、使用maven打出的jar包如何包含依赖的其他jar且可以直接运行main函数

        已经说过了如何配置pom.xml让它支持直接运行main函数，接下来看看如何包含依赖的其他jar包。这种方式又可以分为，是否把项目本身的代码和依赖包的代码放到一个jar包中？

修改下自己项目的代码：

  1. package jarservice;
  2. import java.io.File;
  3. import net.sf.json.JSONArray;
  4. import org.apache.commons.io.FileUtils;
  5. public class ReadJson {
  6. 	public static void main(String[] args)throws Exception {
  7. 	        //文件内容：[1,2,3]
  8. 		String str = FileUtils.readFileToString(new File("D:\\comm_head.html"));
  9. 		JSONArray array = JSONArray.fromObject(str);
  10. 		System.out.println(array);
  11. 	}
  12. }

现在我的项目依赖了json-lib和commons-io这样两个jar：

  1. <dependencies>  
  2. 		  <dependency>
  3. 		    <groupId>net.sf.json-lib</groupId>
  4. 		    <artifactId>json-lib</artifactId>
  5. 		    <version>2.4</version>
  6. 		    <classifier>jdk15</classifier> 
  7. 		</dependency>
  8. 		<dependency>
  9. 		    <groupId>commons-io</groupId>
  10. 		    <artifactId>commons-io</artifactId>
  11. 		    <version>2.4</version>
  12. 		</dependency>
  13.     </dependencies>

下面分两种情况打包，两种情况都可以，你需要哪种方式就用哪种方式就行：

3.1 自己项目的代码与依赖的jar分开放的方式：

    修改pom.xml：

  1. <build>  
  2.     <plugins>  
  3.    		 <plugin>  
  4.             <groupId>org.apache.maven.plugins</groupId>  
  5.             <artifactId>maven-dependency-plugin</artifactId>  
  6.             <version>2.8</version>
  7.             <executions>  
  8.                 <execution>  
  9.                     <id>copy-dependencies</id>  
  10.                     <phase>package</phase>  
  11.                     <goals>  
  12.                         <goal>copy-dependencies</goal>  
  13.                     </goals>  
  14.                     <configuration>  
  15.                         <outputDirectory>${project.build.directory}/lib</outputDirectory>  
  16.                     </configuration>  
  17.                 </execution>  
  18.             </executions>  
  19.         </plugin>
  20.         
  21.         <plugin>  
  22.             <groupId>org.apache.maven.plugins</groupId>  
  23.             <artifactId>maven-jar-plugin</artifactId>  
  24.             <version>2.3.2</version>
  25.             <configuration>  
  26.           	    <source>1.7</source>
  27. 		        <target>1.7</target>
  28.                 <archive>  
  29.                     <manifest>  
  30.                         <mainClass>jarservice.ReadJson</mainClass>  
  31.                         <addClasspath>true</addClasspath>  
  32.                         <classpathPrefix>lib/</classpathPrefix>  
  33.                     </manifest>  
  34.                 </archive>  
  35.             </configuration>  
  36.         </plugin>  
  37.     </plugins>  
  38. </build>

先看第一个插件的配置：

maven-dependency-plugin这个插件用来拷贝jar包到你指定的目录。

<id>copy-dependencies</id>

表示的是给要excution配置个名字，唯一标识，你可以随便叫。project.build.directory是maven的内置隐藏变量，指的是你项目的target目录。第一个插件maven-dependency-plugin的配置表示把项目依赖的jar包都拷贝到target目录的lib目录下。

第二个maven插件的配置：

maven-jar-plugin这里比前边使用的时候增加了两个属性：

<addClasspath>true</addClasspath>  

<classpathPrefix>lib/</classpathPrefix>  

addClasspath表示在最终生成的清单文件MANIFEST.MF中加入Class-Path这个属性，这个属性的作用是用来指定依赖的jar所在的位置的。

classpathPrefix表示相对于当前项目生成的jar包（这里是jarservice-0.0.1-SNAPSHOT.jar）来说，依赖的jar放在哪里，比如放在当前目录下的abc目录下，那么这里的值就是abc/，因为maven-dependency-plugin把项目依赖的jar包都拷贝到了当前target目录的lib目录下，因此这里写的是lib/。

运行“maven  package”命令：

image.png

  1. D:\workspace2\jarservice\target>java -jar jarservice-0.0.1-SNAPSHOT.jar jarservice.ReadJson
  2. [1,2,3]

好，这种分离项目自身的jar包与依赖jar包的方法运行成功。

mainfest.mf:

  1. Manifest-Version: 1.0
  2. Archiver-Version: Plexus Archiver
  3. Created-By: Apache Maven
  4. Built-By: zhao
  5. Build-Jdk: 1.8.0_151
  6. Main-Class: jarservice.ReadJson
  7. Class-Path: lib/json-lib-2.4-jdk15.jar lib/commons-beanutils-1.8.0.jar
  8.   lib/commons-collections-3.2.1.jar lib/commons-lang-2.5.jar lib/commo
  9.  ns-logging-1.1.1.jar lib/ezmorph-1.0.6.jar lib/commons-io-2.4.jar

3.2 把所有依赖jar和项目本身的jar都打在一个jar包里，继续看下面。

项目本身代码与依赖jar合并打包并可以运行main函数

 前边说了如何将项目本身的jar包与其所依赖的jar包分离开来打包，并可以运行项目的main函数，我们已经验证过了，没有任何问题，但是上面的方式是不是有个缺点：就是你要想运行这个项目，还要多出一份精力来管理那个lib文件夹，其实也就一个文件夹，拷贝走就可以了，但是位置不能放错，因为在项目的MANIFEST.MF文件的Class-Path中指定了Class-Path这个属性，这里面定义了你的依赖的jar包在哪个位置，如果你修改了或者转移了这个lib文件夹，项目通过java -jar jarservice-0.0.1-SNAPSHOT.jar jarservice.ReadJson  自然就不能再运行了。   因此我们来看看如何把所有的东西一股脑打入一个jar包里，我们就不需要留意那么多细节了。想运行项目，直接拷走这个jar包即可。

修改pom.xml文件，修改后的整个pom文件：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.   <groupId>services</groupId>
  5.   <artifactId>jarservice</artifactId>
  6.   <version>0.0.1-SNAPSHOT</version>
  7.   <packaging>jar</packaging>
  8.   <dependencies>  
  9. 		  <dependency>
  10. 		    <groupId>net.sf.json-lib</groupId>
  11. 		    <artifactId>json-lib</artifactId>
  12. 		    <version>2.4</version>
  13. 		    <classifier>jdk15</classifier> 
  14. 		</dependency>
  15. 		<dependency>
  16. 		    <groupId>commons-io</groupId>
  17. 		    <artifactId>commons-io</artifactId>
  18. 		    <version>2.4</version>
  19. 		</dependency>
  20. 		
  21.     </dependencies>  
  22. <build>  
  23.     <plugins>  
  24.         <plugin>  
  25.             <groupId>org.apache.maven.plugins</groupId>  
  26.             <artifactId>maven-assembly-plugin</artifactId>  
  27.             <version>2.5.5</version>  
  28.             <configuration>  
  29.                 <archive>  
  30.                     <manifest>  
  31.                         <mainClass>jarservice.ReadJson</mainClass>  
  32.                     </manifest>  
  33.                 </archive>  
  34.                 <descriptorRefs>  
  35.                     <descriptorRef>jar-with-dependencies</descriptorRef>  
  36.                 </descriptorRefs>  
  37.             </configuration>  
  38.             <executions>  
  39.                 <execution>  
  40.                     <id>one_jar</id>  
  41.                     <phase>package</phase>  
  42.                     <goals>  
  43.                         <goal>single</goal>  
  44.                     </goals>  
  45.                 </execution>  
  46.             </executions>  
  47.         </plugin>  
  48.     </plugins>  
  49. </build>   
  50. </project>

如此，配置好之后，再运行“package”命令，我们到target目录下查看生成的文件：

image.png

多了一个名字叫做“jarservice-0.0.1-SNAPSHOT-jar-with-dependencies.jar”的jar包，看这个jar包的大小，就知道它就是我们要的，它里面确实包含了所有的jar包依赖：

image.png

我们看到所有依赖的jar包都被作为项目的内容按照自己的包结构解压后放到了jarservice-0.0.1-SNAPSHOT-jar-with-dependencies.jar这个jar包里面。

把这个jar包任意拷贝到一个位置都是可以运行的。

image.png

好了，至此，项目本身与依赖jar合并打包并可以运行main函数这种方式也介绍完了。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/308201?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号