【Maven】Maven打包构建完全指南和最佳实践

最新推荐文章于 2024-05-01 21:23:35 发布
最新推荐文章于 2024-05-01 21:23:35 发布
阅读量3.8k 收藏 7
点赞数 1
分类专栏： Maven 文章标签： Maven 打包构建
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fmy_happy/article/details/84034240
版权

【Maven】Maven打包构建完全指南和最佳实践

前言

Apache Maven是一个软件项目管理和构建工具。基于项目对象模型（POM）的概念，Maven可以从一个核心配置文件管理项目的构建，报告和文档。

虽然近年来Gradle作为后起之秀借着Android的东风大肆扩张，Maven作为主流构建工具的地位还是不可动摇的。我们可以看到很多明星项目都是基于Maven构建的，如Spring Boot。

Maven的适用范围非常广，可以用来编译、构建、管理依赖、打包、运行测试用例形成测试报告、甚至借助插件直接发布到远程Tomcat等。阅读本文需要你对Maven已经有了大体的了解，本文将从Maven的常见使用场景切入，介绍笔者使用过程中的经验和总结，最终提出最佳实践。

第一个Maven项目

脚手架

安装并配置好Maven后，我们可以用Maven的脚手架命令工具来生成第一个Maven项目。

mvn -B archetype:generate \
  -DarchetypeGroupId=org.apache.Maven.archetypes \
  -DgroupId=com.mycompany.app \
  -DartifactId=my-app

上面的archetype是Maven仓库中内置的脚手架工具，所谓脚手架就是执行这个预置命令就会初始化好一个项目框架，生成一个项目部模板的工具。在模板中可以定义pom.xml预制的依赖项、构建选项等，你也可以自己创建一个Maven项目脚手架发布到Maven仓库中供他人使用。

当然大多数情况下我们用的是IDE的Maven插件来创建的。在Eclipse中我们创建Maven工程时也可以选择预置的脚手架，这通常需要联网下载，由于某些原因国内访问Maven中央仓库非常慢，因此强烈建议配置为阿里云的Maven镜像。

image

最佳实践

笔者在创建项目时一般会在上图勾选create simple project，跳过一些花里胡哨的脚手架模板，自己一步步配置的pom才会真正了如指掌。

在接下来的界面上，Eclipse会提供三个选项：

  • pom，Maven父工程项目，可以向其中添加Module。
  • jar，Java的控制台项目。
  • war，Java的Web项目。

选择你需要的项目类型就可以了。

image

Maven依赖管理

Maven依赖管理可能是最常用的功能之一了，在pom.xml中，通过Maven坐标来引用依赖的jar包，这个坐标的groupId、artifactId和version可唯一确定一个jar包，然后Maven会从配置好的远程仓库中进行下载构建。

<dependencies>
		<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz</artifactId>
			<version>2.3.0</version>
			<scope>compile</scope>
		</dependency>
</dependencies>

依赖的作用域

上面代码段中的<scope>选项标识该依赖的作用域，默认scope是compile，scope提供以下选项：

  1. compile （编译范围）

compile是默认的范围；如果没有提供一个范围，那该依赖的范围就是编译范围。编译范围依赖在所有的classpath 中可用，同时它们也会被打包。

  1. provided （已提供范围）

provided 依赖只有在当JDK 或者一个容器已提供该依赖之后才使用。例如， 如果你开发了一个web 应用，你可能在编译 classpath 中需要可用的Servlet API 来编译一个servlet，但是你不会想要在打包好的WAR 中包含这个Servlet API；这个Servlet API jar 由你的应用服务器或者servlet 容器提供。已提供范围的依赖在编译classpath （不是运行时）可用。它们不是传递性的，也不会被打包。

  1. runtime （运行时范围）

runtime 依赖在运行和测试系统的时候需要，但在编译的时候不需要。比如，你可能在编译的时候只需要JDBC API jar，而只有在运行的时候才需要JDBC驱动实现。

  1. test （测试范围）

test范围依赖 在一般的编译和运行时都不需要，它们只有在测试编译和测试运行阶段可用。

  1. system （系统范围）划重点，后面踩过坑

system范围依赖与provided 类似，但是你必须显式的提供一个对于本地系统中jar 文件的路径。这么做是为了允许基于本地对象编译，而这些对象是系统类库的一部分。这样的构件应该是一直可用的，Maven 也不会在仓库中去寻找它。如果你将一个依赖范围设置成系统范围，你必须同时提供一个 systemPath 元素。注意该范围是不推荐使用的（你应该一直尽量去从公共或定制的 Maven 仓库中引用依赖）

  1. import

此范围仅支持<dependencyManagement>中的pom类型。它表示要使用指定POM的<dependencyManagement>中的有效依赖项列表替换的依赖项，即预先定义以依赖列表，按需引用，需要Maven2.9版本以上支持。
示例：

打包构建

开发阶段我们一般都是在IDE里面直接运行Java代码，在项目发布部署时如何导出jar包或war包呢？

非Maven项目

以Eclipse为例，右击项目名，选择Export选择JAR file、Runnable JAR file或WAR file即可

image

Maven项目

Maven的打包策略有很多，在此一打可执行jar包为例进行探讨。首要步骤是需要在pom的<build>节点下添加Maven的打包插件，常见的打包插件有：

  1. 核心插件Maven-compiler-plugin，用于指定编译级别，默认使用jdk1.5编译
  2. 打包可执行jar的Maven-jar-plugin，用于指定本项目生成的jar包中的MANIFEST.MF文件中的配置，如Class-Path和Main-Class
  3. Maven-assembly-plugin，支持定制化打包方式，负责将整个项目按照自定义的目录结构打成最终的压缩包，方便实际部署，可在此处设置打包拷贝路径，配置，以及打包好的jar文件等。
  4. Maven-shade-plugin，用来打可执行包，包含依赖，以及对依赖进行取舍过滤，当你只想将项目打成一个可执行包时，Maven-shade-plugin非常适合。

打包策略选择：

  1. 直接打包，不打包依赖包，仅打包出项目中的代码到jar包中。在POM中添加Maven-compiler-plugin即可，随后执行Maven package。直接打包意义不大，首先Pass。
  2. 将项目和依赖打包成一整个可执行jar包，用到的就是Maven-shade-plugin了。这是常规的做法，由于包含了所有依赖jar包，封装了内部细节，包容一且。
  3. 将依赖jar包输出到lib目录方式，Tomcat就是采用的这种打包策略。这种方案属于将项目结构重新组装，因此要用到的核心打包插件是Maven-assembly-plugin。通过配置，将依赖jar输出到lib目录，与构建后的主项目包分离，若程序需要升级仅需替换主程序jar即可，不必连同lib目录一起替换，大大提高了网络传输效率；结构分离整体上也够直观。

在提出最佳实践之前我们先来了解一下打包策略2需要的配置：

<build>  
    <plugins>  
        <plugin>  
            <groupId>org.apache.Maven.plugins</groupId>  
            <artifactId>Maven-shade-plugin</artifactId>  
            <version>1.4</version>  
            <executions>  
                <execution>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>shade</goal>  
                    </goals>  
                    <configuration>  
                        <filters>  
                            <filter>  
                                <artifact>*:*</artifact>  
                                <excludes>  
                                    <exclude>META-INF/*.SF</exclude>  
                                    <exclude>META-INF/*.DSA</exclude>  
                                    <exclude>META-INF/*.RSA</exclude>  
                                </excludes>  
                            </filter>  
                        </filters>  
                        <transformers>  
                            <transformer  
                                implementation="org.apache.Maven.plugins.shade.resource.ManifestResourceTransformer">  
                                <mainClass>com.cat.Application</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>

shade插件绑定的是package生命周期目标，并设置com.cat.Application为Main-Class，以及将META-INF/spring.*文件合并(追加而非覆盖)，并过滤掉所有依赖的META/INF中SF,DSA,RSA后缀文件。这里涉及到filter配置和transformer配置。

最佳实践

综上所述，我们选择策略3作为最佳实践（向Tomcat看齐），首先看一下打包后的项目结构：

D:\BANKSERVER //根目录
│  bankServer.jar //主程序包
│  README.md      //说明文档
│  startup.bat    //启动脚本
│  
├─conf //配置文件目录
│      config.properties //配置文件
│      database.properties //数据库配置文件
│        
├─lib //依赖目录
│      aopalliance-1.0.jar
│      bankServer-0.0.1-SNAPSHOT.jar
│      c3p0-0.9.5.2.jar
│      my-Entry-1.0.jar
│      commons-lang3-3.8.1.jar
│      druid-1.1.8.jar

这里用到了三个插件，Maven-compiler-plugin指定编译级别；Maven-jar-plugin主要就是配置了MANIFEST.MF这个文件而已，就是让可执行文件知道自己怎么执行，加载哪些文件执行的描述，剩下的工作交由Maven-assembly-plugin来处理。

贴上来pom.xml的配置：

<build>
		<finalName>bankServer</finalName>
		<plugins>
			<plugin>
				<groupId>org.apache.Maven.plugins</groupId>
				<artifactId>Maven-compiler-plugin</artifactId>
				<version>3.7.0</version>
				<configuration>
					<source>1.7</source>
					<target>1.7</target>
					<encoding>utf-8</encoding>
				</configuration>
			</plugin>

			<plugin>
				<groupId>org.apache.Maven.plugins</groupId>
				<artifactId>Maven-jar-plugin</artifactId>
				<configuration>
					<archive>
						<addMavenDescriptor>false</addMavenDescriptor>
						<!-- 指定main信息 -->
						<manifest>
						    <!--指定添加项目中使用的外部jar的classpath项-->
							<addClasspath>true</addClasspath>
							<classpathPrefix>lib/</classpathPrefix>
							<!-- 此处指定main方法入口的class -->
							<mainClass>com.cat.bank.main.Luncher</mainClass>
						</manifest>
					</archive>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>Maven-assembly-plugin</artifactId>
				<configuration>
					<appendAssemblyId>false</appendAssemblyId>
					<descriptors>
					    <!--指定详细的外部配置，读取这个文件，防止pom.xml过于臃肿-->
						<descriptor>packconf/package.xml</descriptor>
					</descriptors>

				</configuration>
				<!--下面是为了使用 mvn package命令，如果不加则使用mvn assembly -->
				<executions>
					<execution>
						<id>make-assembly</id>
						<phase>package</phase>
						<goals>
							<goal>assembly</goal>
						</goals>
					</execution>
				</executions>
			</plugin>

		</plugins>
	</build>

Maven-assembly-plugin引用的package.xml:

<?xml version="1.0" encoding="UTF-8"?>
<assembly>
	<id>bin</id>
	<!-- 最终打包成一个用于发布的zip文件 -->
	<formats>
		<format>zip</format>
	</formats>
	<!-- Adds dependencies to zip package under lib directory -->
	<dependencySets>
		<dependencySet>
			<!-- 不使用项目的artifact，第三方jar不要解压，打包进zip文件的lib目录 -->
			<useProjectArtifact>true</useProjectArtifact>
			<outputDirectory>lib</outputDirectory>
			<unpack>false</unpack>
		</dependencySet>
	</dependencySets>
	<fileSets>
		<!-- 把项目相关的说明文件，打包进zip文件的根目录 -->
		<fileSet>
			<directory>${project.basedir}</directory>
			<outputDirectory>/</outputDirectory>
			<includes>
				<include>README*</include>
				<include>LICENSE*</include>
				<include>NOTICE*</include>
			</includes>
		</fileSet>

		<!-- 把项目的配置文件，打包进zip文件的conf目录 -->
		<fileSet>
			<directory>${project.basedir}/conf</directory>
			<outputDirectory>conf</outputDirectory>
			<includes>
				<include>*</include>
			</includes>
		</fileSet>

		<!-- 把项目的脚本文件目录（ src/main/scripts ）中的启动脚本文件，打包进zip文件的跟目录 -->
		<fileSet>
			<directory>${project.build.scriptSourceDirectory}</directory>
			<outputDirectory></outputDirectory>
			<includes>
				<include>startup.*</include>
			</includes>
		</fileSet>

		<!-- 把项目自己编译出来的jar文件，打包进zip文件的根目录 -->
		<fileSet>
			<directory>${project.build.directory}</directory>
			<outputDirectory></outputDirectory>
			<includes>
				<include>*.jar</include>
			</includes>
		</fileSet>
	</fileSets>
</assembly>

问题记录：

  1. Java代码读取不到jar包外部配置文件

项目发布的时候通常会修改配置文件，这种情况下就需要把配置文件放到jar外部读取而不能直接打到jar包内。默认的config.properties文件是放在src/main/resources路径，即classpath下的，采用如下代码读取，构建后config.properties文件被打到了conf下，尝试多种方案，即使将"config.properties"加上相对路径也读取不到，若用System.getProperty("user.dir")这种方法在IDE下就不能运行了，因此亟需找到一个两全其美的办法同时支持在IDE下读取和构建后的外部目录读取。

原读取方法：

InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("conf/config.properties");   
Properties p = new Properties();   
try {   
   p.load(inputStream);   
} catch (IOException e1) {   
   e1.printStackTrace();   
}

解决方案：

1）. 将config.properties和database.properties从src/main/resources移到项目根目录的普通文件夹conf

2）. 修改读取方式为文件流

try {
	Properties properties = new Properties();
	// 1.加载properties文件
	InputStream is =new FileInputStream("conf/config.properties");
	// 2.加载输入流
	properties.load(is);
} catch (Exception e) {
	logger.error("读取配置文件config.properties错误");
}
  1. 本地jar包打包后Maven无法加载

项目中需要引入一个my-Entry.jar的加密jar包，这个包Maven仓库中是没有的。回忆一下前面提到的依赖的system作用域，因此采用如下方式导入了该jar包，但是打包后调用该包内方法时提示Class Not Found。

<dependency>
	<groupId>com.cat</groupId>
	<artifactId>my-Entry</artifactId>
	<!--注意这个版本号，下面会用到-->
	<version>1.0</version>
	<scope>system</scope>
	<systemPath>${project.basedir}/libs/my-Entry.jar</systemPath>
</dependency>

这是因为scope为system作用域时不参与运行时，解决这个问题有两种方案：

解决方案：

1）将该jar安装到本地仓库

执行以下命令，发布到本地仓库，然后修改pom.xml将scope标签去掉即可。

mvn install:install-file -Dfile=D:\my-Entry.jar -DgroupId=com.cat -DartifactId=ccb-Entry -Dversion=1.0 -Dpackaging=jar

2）将外部包加入主jar包META-INF下的MANIFEST.MF文件

这个MANIFEST.MF里指定了外部依赖的jar包查找路径，需要在在Maven-jar-plugin 里配置Class-Path。

<plugin>
	<groupId>org.apache.Maven.plugins</groupId>
	<artifactId>Maven-jar-plugin</artifactId>
	<configuration>
		<archive>
			<addMavenDescriptor>false</addMavenDescriptor>
			<!-- Manifest specific configuration -->
			<manifest>
				<addClasspath>true</addClasspath>
				<classpathPrefix>lib/</classpathPrefix>
				<!-- 此处指定main方法入口的class -->
				<mainClass>com.cat.bank.main.Luncher</mainClass>
			</manifest>
			<manifestEntries>
			    <!--注意这里要加上-1.0版本号，就是你引入本地依赖时指定的那个version-->
                <Class-Path>lib/my-Entry-1.0.jar</Class-Path>
            </manifestEntries>
		</archive>
	</configuration>
</plugin>

现在用解压软件打开bankServer.jar主jar文件会发现MANIFEST.MF文件中已经加上了my-Entry.jar。但是这时这个my-Entry.jar并没有发布到lib文件夹下，我们需要再配置Maven-assembly-plugin将scope为system的依赖也发布到lib目录，或者可以直接拷贝过去。

在package.xml中追加一行配置，这样就可以正常打包运行啦~

	<dependencySets>
		<dependencySet>
			<!-- 不使用项目的artifact，第三方jar不要解压，打包进zip文件的lib目录 -->
			<useProjectArtifact>true</useProjectArtifact>
			<outputDirectory>lib</outputDirectory>
			<unpack>false</unpack>
		</dependencySet>
		<!--将<scope>system</scope>也发布到lib-->
		<dependencySet>
			<useProjectArtifact>true</useProjectArtifact>
			<outputDirectory>lib</outputDirectory>
			<unpack>false</unpack>
			<scope>system</scope>
		</dependencySet>
	</dependencySets>
fmy_happy
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Maven权威指南中文版(完整).pdf
06-06
Maven权威指南中文版(完整).pdf
[maven] 实战笔记 - 构建、打包和安装maven
weixin_33895604的博客
08-18 86
  ① 手工构建自己的maven项目 Maven 项目的核心是 pom.xml。POM (Project Object Model,项目对象模型)定义了项目的基本信息,用于描述项目如何构建,声明项目依赖等等。 你需要提前知道一些Maven 的约定: 1、在项目的根目录中放置 pom.xml 2、在 src/main/java 目录中放置项目的主代码 3、在 src/test/java 中放...
从零教你使用Maven，从此项目打包不用愁
最新发布
jiameih的博客
05-01 425
看完美团、字节、腾讯这三家的一二三面试问题，是不是感觉问的特别多，可能咱们真的又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。开篇有提及我可是足足背下了Java互联网工程师面试1000题，多少还是有点用的呢，换汤不换药，不管面试官怎么问你，抓住本质即可！能读到此处的都是真爱Java互联网工程师面试1000题。
Maven最佳实践
weixin_30646315的博客
04-12 105
一、在eclipse.ini中指定vm参数 Eclipse默认是运行在JRE上的，而m2eclipse的一些功能要求使用JDK，解决方法是配置Eclipse安装目录的eclipse.ini文件，添加vm配置指向JDK，如： --launcher.XXMaxPermSize 256m-vmD:\java\jdk1.6.0_07\bin\javaw.exe-vmargs-Dosgi.require...
maven 完整版打包
weixin_33874713的博客
03-08 306
所有项目都依赖这个父项目 父项目 <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....
Maven 打包实战
Be yourself.
03-13 1654
前言 上一章,我们介绍了Maven内的常见插件.Maven的主要作用是用于包的管理和依赖.其次,根据Maven的生命周期可以知道, 它还可以作为一个运维和打包、部署的工具而存在. 本章我们将详细的介绍Maven打包以及打包的各种情况. PS: 本文所用的Maven例子可以在我的Github仓库内找到 https://github.com/SeanYanxml/maven-train Jar包 所...
maven3.5.4打包文件
04-04
2. **标准化构建过程**：Maven 提供了一套预定义的生命周期和构建阶段，如 `clean`、`compile`、`test`、`package`、`install` 和 `deploy`，使得开发者可以遵循统一的构建流程。 3. **插件系统**：Maven 插件机制...
Maven权威指南_maven_
10-01
**Maven权威指南** 《Maven权威指南》是Java开发者...通过阅读《Maven权威指南》，开发者不仅能掌握Maven的基本使用，还能深入理解其背后的原理和最佳实践，从而在实际项目中发挥出Maven的最大价值，提升开发效率。
maven权威指南英文原版
03-10
本篇文章将基于"Maven权威指南英文原版"，结合"Maven_the_reference_guide.pdf"和"Maven_By_Example_-_eBook.pdf"，深入解析Maven的核心概念、配置以及实际应用。 1. **Maven基础** Maven通过XML格式的POM...
maven3和maven权威指南.zip
05-14
** Maven3和Maven权威指南 ** Maven是Apache软件基金会开发的一款强大的Java项目管理和集成工具，它简化了构建过程，使得开发人员可以专注于代码编写，而非构建配置。Maven3是其最新版本，相较于早期版本，它带来了...
apache-maven-3.3.3-bin和maven指南.zip
06-09
书中不仅解释了如何配置和使用Maven，还讨论了最佳实践和常见问题的解决方案，对于初学者和有经验的开发者来说都是宝贵的参考资料。 在实际开发中，Maven可以与版本控制系统（如Git）、持续集成工具（如Jenkins）和...
maven3实战之maven使用入门(打包和运行)
fhd001的专栏
06-18 108
maven3实战之maven使用入门(打包和运行) ----------   将项目进行编译，测试之后，下一个重要步骤就是打包。pom.xml中如果没有指定打包类型，默认打包类型为：jar。我们可以简单地执行命令打包： mvn clean pachage。 类似地，maven会在打包之前执行编译，测试等操作。如以打jar包为例，jar:jar任务负责打包，实际上就是jar插件的jar目标将...
如何创建Maven项目
song的博客
12-28 2万+
maven maven是一个构建工具 功能：把编译好的.class文件打包成一个.jar文件 maven的其他功能：依赖管理（一个复杂的程序通常会依赖第三方库） 使用的时候，需要把对应的jar包下载下来，导入工程中 maven不需要安装，idea自带 将maven源改为国内阿里云镜像 maven的路径一般不要改，如果要改，一定不要有中文，也不要带特殊符号 maven如何使用 IDEA在创建项目的时候，选择创建一个maven项目 第一次创建maven的时候，要有耐心，第一次创建可能非常慢（30分钟-几个小
maven的5种打包方式，终有一款适合你1
热门推荐
健康平安的活着的专栏
08-07 4万+
1.用于生成META-INF/MANIFEST.MF文件的部分内容，com.xxg.Main指定MANIFEST.MF中的Main-Class，true会在MANIFEST.MF加上Class-Path项并配置依赖包，lib/指定依赖包所在目录。2.maven-dependency-plugin插件。
如何使用Maven打包成一个完整可执行的Jar包
qq_40602271的博客
07-23 729
Maven提供了这么一个plugin，Apache Maven Shade Plugin。他的作用就是用来打包一个超级Jar包（被称作uber-jar），其中包含了他依赖的其他Jar包。 使用也是非常简单：在pom.xml中，build 节点下plugins下新增一个就好了注意修改《mainClass》 <plugin> <groupId>org.apac...
maven build打包java项目为可运行的jar包
jamesssemaj的专栏
11-11 8274
上个星期帮人做一个考勤统计的小项目，用的是java的swing。做是做完了，但是想像其它的软件一样双击就可以运行它，这就要用maven打成可运行的jar包，这可是个问题呀？还好只用了一天就搞定了，但是觉得有点蛋疼，所以想它记录下来，以免下次会用到，好了，废话不多说了。当然你的eclipse里面要装有maven插件，没装的话去百度一下很简单。 第一步：先在pom.xml文件里加上如下配置 &l...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值