maven命令打war包 maven怎么打war包

转载

mob64ca1401b651 2024-02-17 08:50:41

文章标签 maven命令打war包 java maven jar jar包 文章分类 架构后端开发

maven怎么打war包

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

<project 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/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.roadjava</groupId>
  <artifactId>fraud</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>fraud</name>
  <description>反欺诈_群组</description>
  <properties>
  	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  	<spring.version>4.0.0.RELEASE</spring.version>
  	<java.version>1.7</java.version>
		<java.encoding>UTF-8</java.encoding>
  </properties>
  <dependencies>  
		  <dependency>
		    <groupId>net.sf.json-lib</groupId>
		    <artifactId>json-lib</artifactId>
		    <version>2.4</version>
		    <classifier>jdk15</classifier> 
		</dependency>
		<!--这里很多依赖我省略了...-->
    </dependencies>  
</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，怎么指定？

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

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

<build>
     	<finalName>xfraud</finalName>
	    <plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>${java.version}</source>
					<target>${java.version}</target>
					<encoding>${java.encoding}</encoding>
				</configuration>
			</plugin>
	    </plugins>
</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：

<project 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/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>services</groupId>
  <artifactId>jarservice</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>
</project>

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

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

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

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

package jarservice;
public class ReadJson {
	public static void main(String[] args) {
		System.out.println("readjson");
	}
}

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

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

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

<build>
		<plugins>
			<plugin>
			    <groupId>org.apache.maven.plugins</groupId>
			    <artifactId>maven-jar-plugin</artifactId>
			    <configuration>
			        <source>1.7</source>
			        <target>1.7</target>
			        <archive>
			            <manifest>
			                <mainClass>jarservice.ReadJson</mainClass>
			            </manifest>
			        </archive>
			    </configuration>
			</plugin>
		</plugins>    
</build>

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

D:\workspace2\jarservice\target>java -jar jarservice-0.0.1-SNAPSHOT.jar jarservice.ReadJson
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包中？

修改下自己项目的代码：

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

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

<dependencies>  
		  <dependency>
		    <groupId>net.sf.json-lib</groupId>
		    <artifactId>json-lib</artifactId>
		    <version>2.4</version>
		    <classifier>jdk15</classifier> 
		</dependency>
		<dependency>
		    <groupId>commons-io</groupId>
		    <artifactId>commons-io</artifactId>
		    <version>2.4</version>
		</dependency>
    </dependencies>

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

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

修改pom.xml：

<build>  
    <plugins>  
   		 <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-dependency-plugin</artifactId>  
            <version>2.8</version>
            <executions>  
                <execution>  
                    <id>copy-dependencies</id>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>copy-dependencies</goal>  
                    </goals>  
                    <configuration>  
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>  
                    </configuration>  
                </execution>  
            </executions>  
        </plugin>
        
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-jar-plugin</artifactId>  
            <version>2.3.2</version>
            <configuration>  
          	    <source>1.7</source>
		        <target>1.7</target>
                <archive>  
                    <manifest>  
                        <mainClass>jarservice.ReadJson</mainClass>  
                        <addClasspath>true</addClasspath>  
                        <classpathPrefix>lib/</classpathPrefix>  
                    </manifest>  
                </archive>  
            </configuration>  
        </plugin>  
    </plugins>  
</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表示在最终生成的清单文件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”命令：

maven命令打war包 maven怎么打war包_maven命令打war包

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

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

mainfest.mf:

Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Created-By: Apache Maven
Built-By: zhao
Build-Jdk: 1.8.0_151
Main-Class: jarservice.ReadJson
Class-Path: lib/json-lib-2.4-jdk15.jar lib/commons-beanutils-1.8.0.jar
  lib/commons-collections-3.2.1.jar lib/commons-lang-2.5.jar lib/commo
 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文件：

<project 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/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>services</groupId>
  <artifactId>jarservice</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>
  <dependencies>  
		  <dependency>
		    <groupId>net.sf.json-lib</groupId>
		    <artifactId>json-lib</artifactId>
		    <version>2.4</version>
		    <classifier>jdk15</classifier> 
		</dependency>
		<dependency>
		    <groupId>commons-io</groupId>
		    <artifactId>commons-io</artifactId>
		    <version>2.4</version>
		</dependency>
		
    </dependencies>  
<build>  
    <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-assembly-plugin</artifactId>  
            <version>2.5.5</version>  
            <configuration>  
                <archive>  
                    <manifest>  
                        <mainClass>jarservice.ReadJson</mainClass>  
                    </manifest>  
                </archive>  
                <descriptorRefs>  
                    <descriptorRef>jar-with-dependencies</descriptorRef>  
                </descriptorRefs>  
            </configuration>  
            <executions>  
                <execution>  
                    <id>one_jar</id>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>single</goal>  
                    </goals>  
                </execution>  
            </executions>  
        </plugin>  
    </plugins>  
</build>   
</project>

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

maven命令打war包 maven怎么打war包_jar_02