Maven打包方式

已于 2025-01-05 21:57:08 修改
阅读量1.6k 收藏 27
点赞数 23
分类专栏： 工具环境 # Java 文章标签： maven java
于 2024-12-29 23:11:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_55629186/article/details/144811909
版权

Maven打包方式






1、背景描述


Maven可以使用mvn package指令对项目进行打包，如果使用java -jar执行jar文件，会出现没有设置Main-Class、ClassNotFoundException（找不到依赖包）等错误

要想jar包能直接通过java -jar运行，需要满足：

  • 在jar包中的META-INF/MANIFEST.MF中指定Main-Class，以确定程序入口
  • 要能加载到jar包中所依赖的其它依赖包

使用Maven有以下几种方式可以生成能直接运行的jar包：

2、使用maven-jar-plugin和maven-dependency-plugin插件打包


maven-jar-plugin和maven-dependency-plugin是默认的打包方式，用来将普通的Project打成jar包

<build>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-jar-plugin</artifactId>
			<version>2.6</version>
			<configuration>
				<archive>
					<manifest>
					    <!-- 是否添加依赖的jar路径配置 -->
						<addClasspath>true</addClasspath>
						<!-- 依赖的jar包存放未知，和生成的jar放在同一级目录下 -->
						<classpathPrefix>lib/</classpathPrefix>
						<!-- 指定入口类 -->
						<mainClass>com.cc.Main</mainClass>
					</manifest>
				</archive>
				<!-- 不打包com.cc.excludes下面的所有类 -->
                <excludes>com/cc/excludes/*</excludes>
			</configuration>
		</plugin>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-dependency-plugin</artifactId>
			<version>2.10</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>
	</plugins>
</build>

可以使用includes或excludes选择只打包的部分内容

maven-jar-plugin用于生成META-INF/MANIFEST.MF文件的部分内容：

  • <mainClass>com.cc.Main</mainClass>：指定META-INF/MANIFEST.MF中的Main-Class
  • <addClasspath>true</addClasspath>：在META-INF/MANIFEST.MF中加上Class-Path并配置依赖包
  • <classpathPrefix>lib/</classpathPrefix>：指定依赖包所在的目录

例如，下面是一个通过maven-jar-plugin插件生成的MANIFEST.MF文件片段：

Class-Path: lib/commons-logging-1.2.jar lib/commons-io-2.4.jar
Main-Class: com.cc.Main

只是生成MANIFEST.MF文件还不够，maven-dependency-plugin插件用于将依赖包拷贝到<outputDirectory>${project.build.directory}/lib</outputDirectory>指定的位置，即lib目录下

配置完成后，通过mvn package指令打包，会在target目录下生成jar包，并将依赖包拷贝到target/lib目录下：

target
  lib
     commons-logging-1.2.jar
     commons-io-2.4.jar
  test.jar

指定了Main-Class，有了依赖包，那么就可以直接通过java -jar运行jar包

详见官方文档：https://maven.apache.org/shared/maven-archiver/examples/classpath.html

这种方式生成jar包有个缺点，就是生成的jar包太多不便于管理，下面两种方式只生成一个jar文件，包含项目本身的代码、资源以及所需的依赖包

3、使用maven-assembly-plugin插件打包


maven-assembly-plugin是使用最多的打包方式，可以自定义打包结构，也可以定制依赖项等

例如，大数据项目中往往有很多Shell脚本、SQL脚本、Properties及XML配置等，使用maven-assembly-plugin插件可以让输出的结构清晰并标准化

<build>
	<plugins>
 		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-assembly-plugin</artifactId>
			<version>2.5.5</version>
			<configuration>
				<archive>
					<manifest>
						<mainClass>com.cc.Main</mainClass>
					</manifest>
				</archive>
				<!-- 使用Maven预配置的描述符 -->
				<descriptorRefs>
					<descriptorRef>jar-with-dependencies</descriptorRef>
				</descriptorRefs>
			</configuration>
		</plugin>
	</plugins>
</build>

打包方式为：mvn package assembly:single

assembly:single是Maven插件的一个目标（goal），用于创建一个包含所有依赖的单一可执行jar文件‌。当执行mvn assembly:single命令时，Maven会使用maven-assembly-plugin来创建一个包含项目所有依赖的jar文件，这个jar文件可以直接运行而不需要额外的依赖库‌

打包结果会在target目录下生成一个xx-jar-with-dependencies.jar的jar文件，这个文件不但包含了自己项目中的代码和资源，还包含了所有依赖包的内容。所以可以直接通过java -jar来运行

此外还可以直接通过mvn package来打包，无需assembly:single，只需要额外添加一些配置：

<build>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-assembly-plugin</artifactId>
			<version>2.5.5</version>
			<configuration>
				<archive>
					<manifest>
						<mainClass>com.cc.Main</mainClass>
					</manifest>
				</archive>
				<!-- 使用Maven预配置的描述符 -->
				<descriptorRefs>
					<descriptorRef>jar-with-dependencies</descriptorRef>
				</descriptorRefs>
			</configuration>
			<executions>
				<execution>
					<id>make-assembly</id>
					<!-- 绑定到package生命周期 -->
					<phase>package</phase>
					<goals>
					    <!-- 只运行一次 -->
						<goal>single</goal>
					</goals>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>

其中<phase>package</phase>和<goal>single</goal>即表示在执行mvn package打包时使用assembly:single方式，所以可以直接使用mvn package打包

详见官方文档：https://maven.apache.org/plugins/maven-assembly-plugin/examples/single/filtering-some-distribution-files.html

值得注意的是，如果项目中使用到Spring Framework，用该方式打出来的jar包运行时会报错，使用如下方式可以处理

4、使用maven-shade-plugin插件打包


maven-shade-plugin用来打可执行的jar包，也就是所谓的fat jar包

maven-shade-plugin插件提供了两大基本功能：一是将依赖jar包打包到当前jar包，二是对依赖的jar包进行重命名，以用于类的隔离

<build>  
    <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-shade-plugin</artifactId>  
            <version>2.4.1</version>  
            <executions>  
                <execution>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>shade</goal>  
                    </goals>  
                    <configuration>  
                        <transformers>  
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
                                <mainClass>com.cc.Main</mainClass>  
                            </transformer>  
                        </transformers>  
                    </configuration>  
                </execution>  
            </executions>  
        </plugin>  
    </plugins>  
</build>

配置完成后，执行mvn package即可打包。在target目录下会生成两个jar包，注意不是original-xx.jar文件，而是另外一个。与maven-assembly-plugin相同，生成的jar文件包含了所有依赖，所以可以直接运行

如果项目中使用了Spring Framework，将依赖打到一个jar包中，运行时会出现读取XML Schema文件出错。原因是Spring Framework的多个jar包中包含相同的文件spring.handlers和spring.schemas，如果生成一个jar包会互相覆盖。为了避免互相影响，可以使用AppendingTransformer来对文件内容追加合并：

<build>  
    <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-shade-plugin</artifactId>  
            <version>2.4.1</version>  
            <executions>  
                <execution>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>shade</goal>  
                    </goals>  
                    <configuration>  
                        <transformers>  
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
                                <mainClass>com.cc.Main</mainClass>  
                            </transformer>  
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
                                <resource>META-INF/spring.handlers</resource>  
                            </transformer>  
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
                                <resource>META-INF/spring.schemas</resource>  
                            </transformer>  
                        </transformers>  
                    </configuration>  
                </execution>  
            </executions>  
        </plugin>  
    </plugins>  
</build>

详见官方文档：https://maven.apache.org/plugins/maven-shade-plugin/examples/attached-artifact.html

5、Maven自定义打包方式


Maven自定义打包方式示例如下：

<build>
    <finalName>${project.artifactId}</finalName>
    <plugins>
        <!-- 解决资源文件编码问题 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <version>3.0.2</version>
            <configuration>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        <!-- 设置编译版本 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
                <skip>true</skip>
            </configuration>
        </plugin>
        <!-- 打包 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.6</version>
            <configuration>
				<archive>
					<manifest>
						<mainClass>com.cc.Main</mainClass>
					</manifest>
				</archive>
				<!-- 使用Maven预配置的描述符 -->
				<descriptorRefs>
					<descriptorRef>jar-with-dependencies</descriptorRef>
				</descriptorRefs>
			</configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <!-- 绑定到package生命周期 -->
                    <phase>package</phase>
                    <goals>
                        <!-- 只运行一次 -->
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

其中，我们也可以配置描述符文件自定义打包内容，详情参考文末参考文章

<configuration>
    <!-- 配置描述符文件 -->
    <descriptors>
        <descriptor>src/main/assembly/assembly.xml</descriptor>
    </descriptors>
</configuration>


参考文章：
https://cloud.tencent.com/developer/article/2089955
https://developer.aliyun.com/article/1378456

Maven 三种项目打包方式：POM、JAR 和 WAR 的区别详解
fudaihb的博客
10-09 2358
在 Java 项目开发中，Maven 是一个广泛使用的构建工具。它提供了标准的项目结构、依赖管理和打包机制，帮助开发者轻松管理复杂的 Java 项目。在 Maven 中，项目的打包方式有多种，常见的有 `pom`、`jar` 和 `war` 三种打包类型。每种打包类型都有其独特的用途和场景，理解它们的区别有助于我们选择最适合当前项目的打包方式。 本文将详细介绍 Maven 中这三种项目打包方式的区别及其应用场景，帮助你深入理解如何根据项目需求选择合适的打包方式。
maven打包的5种方式总有一款适合你【超赞】
热门推荐
健康平安的活着的专栏
08-07 5万+
1.用于生成META-INF/MANIFEST.MF文件的部分内容，com.xxg.Main指定MANIFEST.MF中的Main-Class，true会在MANIFEST.MF加上Class-Path项并配置依赖包，lib/指定依赖包所在目录。2.maven-dependency-plugin插件。
Maven生成可以直接运行的jar包的多种方式
weixin_34351321的博客
01-12 100
2019独角兽企业重金招聘Python工程师标准>>> ...
使用 IntelliJ IDEA 进行 Maven 配置与打包全流程指南
最新发布
常回来看看呀！！
04-18 2390
指定主类（仅适用于可执行 Jar 包）：如果要创建一个可执行的 Jar 包，需要在pom.xml文件中指定主类。在<build>标签内添加如下插件配置：</</</</</</</</</</</</</</</将的值替换为项目的主类全限定名。这样生成的 Jar 包就可以通过命令直接运行。2.排除依赖（可选）：有时候，可能不希望某些依赖被打包进最终的包中。可以在依赖的标签内使用标签来排除依赖。例如，排除log4j依赖中的传递依赖：</</</</</</</</
6.Maven打包操作
qq_51274606的博客
04-07 2449
对于企业级项目，无论是进行本地测试，还是测试环境测试以及最终的项目上线，都会涉及项目的打包操作。对于每个环境下的项目打包，对应的项目所需要的配置资源都会有所区别，实现打包的方式有很多种，可以通过ant，或者通过idea 自带的打包功能实现项目打包，但当项目很大并且需要的外界配置很多时，此时打包的配置就会异常复杂，对于maven 项目，我们可以用过 pom.xml 配置的方式来实现打包时的环境选择，相比较其他形式打包工具，通过maven 只需要通过简单的配置，就可以轻松完成不同环境下项目的整体打包。 使用i
maven打包
weixin_33812433的博客
12-04 203
1. 背景 工程中免不了要通过maven打包。 2. maven三种打包插件 plugin function site maven-jar-plugin maven 默认打包插件，用来创建 project jar maven-shade-plugin 用来打可执行包，executable(fat) jar http://maven.apache...
如何将Maven项目打包
来都来了
12-21 3887
在resources下创建三个不同的文件夹，分别代表本地环境、测试环境以及正式环境，创建配置文件可以右击文件夹，选择New一个File，在File内新建properties和xml文件，创建完后如下图。在打包时可能未指定打包环境，此时默认打包dev，一般都放在dev下，test也可以，product不建议。此时如果点进war包内看是能看到写的配置文件的，说明之前打的包已经被清除且被新的打包文件覆盖。步骤如上，创建⽂件夹，命名为 resources，并标记为 Resources Root。
maven打包 maven打jar包详细步骤
01-04
本文将详细讲解如何使用Maven来打包一个Java项目，并创建JAR文件。 首先，Maven有三个主要生命周期阶段：`clean`、`default`（也称为`compile`）和`install`。每个阶段包含一系列的阶段（或者称为目标，如`compile`...
maven 打包时间戳问题
08-25
maven 打包时间戳问题 Maven 打包时间戳问题是 Maven 项目中的一個常见问题，即如何在打包过程中生成时间戳属性并将其应用于资源文件中。通过示例代码，我们可以详细了解这个问题的解决方案。 首先，我们可以在 ...
Maven3种打包方式中maven-assembly-plugin的使用详解
08-18
Maven3种打包方式中maven-assembly-plugin的使用详解 Maven 作为一个流行的项目管理工具，提供了多种方式来打包项目。其中，maven-assembly-plugin 是一个非常强大和灵活的插件，支持自定义的打包结构，并且可以...
Maven三种打包方式，看看你都掌握了没？
欢迎来到我的博客
07-13 1万+
Maven可以使用mvn package指令对项目进行打包，如果使用java -jar xxx.jar执行运行jar文件，会出现"no main manifest attribute, in xxx.jar"（没有设置Main-Class）、ClassNotFoundException（找不到依赖包）等错误。1 方法一：使用maven-jar-plugin和maven-dependency-plugin插件打包。使用maven-jar-plugin和maven-dependency-plugin插件打包。
Maven 的打包方式
Ronz 的博客
08-24 2万+
一、前言 刚开始实习不到一个月的时候，从师兄手中接手了团队的项目，当时第一次听到了 “大包”、“小包” 的概念，只见师兄一顿操作，使用 Maven 将项目进行了打包。当时不太理解，只是记得两点： 如果想让项目作为一个依赖提供给他人使用，则将项目打为 “小包”； 如果希望项目打出来 Jar 包可以作为一个独立服务运行，则将项目打为 “大包”。 也就是说，可以将项目打包为两类：一类是作为依赖提供给他人使用，一类是作为独立服务使用。 下面将从这两类来讲解使用 Maven 将项目打包的方式。 二、将项目打为小包
maven的5种打包方式：springboot-maven-plugin详解
qq_48508157的博客
08-27 3342
spring-boot-maven-plugin插件，会将依赖的jar包全部打包进去。该文件包含了所有的依赖和资源文件，可以直接在命令行或者传统的 Java Web 服务器上启动运行。--使用的插件列表。-->--plugin元素包含描述插件所需要的信息。-->--插件在仓库里的group ID -->--插件在仓库里的artifact ID -->--被使用的插件的版本（或版本范围） -->
Maven 打包方式
hhb910的博客
06-21 180
maven-shade-pluginhttps://blog.youkuaiyun.com/Shenshaoqiu/article/details/78736458Spring Boot的Maven插件Spring Boot Maven pluginhttps://blog.youkuaiyun.com/taiyangdao/article/details/75303181常用的其他方式https://www.jians...
maven打包方式
涛博
03-06 207
[maven的打包方式详解]http://blog.youkuaiyun.com/defonds/article/details/43233131
使用maven打包
w_t_y_y的博客
01-24 376
本地安装maven后，可以使用maven命令打包，依赖的jdk版本配置在maven的settings.xml文件中。 打包有两种方法，一个是在编辑器里面打包，一个是手动打包。 手动打包方法： 进入项目跟目录：按住Shift，点击鼠标右键，选择  在此处打开命令窗口： 输入mvn clean package回车，打完包后在target下可以看到打包的zip文件。...
maven 打包方式详解
05-09
Maven是一个常用的项目管理和自动化构建工具，它使用POM（Project Object Model，项目对象模型）描述项目信息和配置，通过插件化的架构提供了诸如项目依赖管理、编译、测试、打包等一系列构建过程的统一管理和自动化执行的功能。 Maven的打包方式是指打包项目的输出文件类型和格式，在Maven中，打包方式通过在POM文件中指定packaging元素来确定。常见的打包方式有jar、war、ear、pom等几种。 1. jar打包方式 jar是Java Archive的缩写，是一种基于ZIP格式的归档文件，jar包通常用于打包单个可执行程序或类库，被广泛应用于Java开发中。在Maven中，使用jar打包方式会将项目的源代码编译为class文件，然后打包成一个jar文件并输出到target目录中。 2. war打包方式 war是Web Application Archive的缩写，是一种基于ZIP格式的Web应用程序归档文件，war包包含了Web应用程序所需要的所有资源和配置文件。在Maven中，使用war打包方式会将项目的WEB-INF目录、Web.xml文件和相关类库打包成一个war文件并输出到target目录中。 3. ear打包方式 ear是Enterprise Archive的缩写，是一种基于ZIP格式的企业级应用程序归档文件，ear包含了由多个war、jar和可能的其他组件（如数据库脚本等）组成的企业级应用程序。在Maven中，使用ear打包方式会将多个项目的jar、war等资源打包成一个ear文件并输出到target目录中。 4. pom打包方式 pom打包方式是一种特殊的打包方式，它通常被用于父项目或聚合项目。在Maven中，使用pom打包方式不会生成任何输出文件。 总的来说，Maven的打包方式可以根据项目的需要进行选择和配置，能够实现项目快速构建、统一管理和自动化部署等一系列优秀的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值