Apache Maven是一个（特别是Java编程）项目管理及自动构建工具，由Apache软件基金会所提供。基于项目对象模型（缩写：POM）概念，Maven利用一个中央信息片断能管理一个项目的构建、报告和文档等步骤。作为最流行的构建工具之一，maven在打包方面有着众多的插件支持，每种方式都有其优缺点及适用场景，本文主要介绍maven的各种打包方式及区别，希望你可以找到适合自己项目的。

1、maven命令打包

1.1 maven打包命令

Maven可以使用 mvn package 指令对项目进行打包，另外mvn install 及 mvn deploy 命令也有打包功能，下面是它们之间的却别：

mvn package 命令完成了项目编译、单元测试、打包功能，但没有把打好的jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库
mvn install 命令完成了项目编译、单元测试、打包功能，同时把打好的jar包（war包或其它形式的包）布署到本地maven仓库，但没有布署到远程maven私服仓库
mvn deploy 命令完成了项目编译、单元测试、打包功能，同时把打好的jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库

1.2 maven命令打包的缺点

使用 mvn package 指令对项目进行打包后，如果使用 java -jar xxx.jar 运行jar文件，会出现"no main manifest attribute, in xxx.jar"（没有设置Main-Class）、ClassNotFoundException（找不到依赖包）等错误。这时候因为我们在打包之前没有设置好程序的入口，直接运行jar包时程序无法识别入口引起的。要想让jar包能直接通过 java -jar xxx.jar 命令运行，需满足以下2个条件：

在jar包中的META-INF/MANIFEST.MF中指定Main-Class，这样才能确定程序的入口在哪里；
要能加载到依赖包。

manifest

1.3 maven命令打包适用场景

可以将项目/模块打包为两类：一类是作为依赖提供给他人使用（可以称为打“小包”），一类是作为独立服务使用，即打好的jar包能直接通过 java -jar xxx.jar 命令运行（可以称为打“大包”）。

如果想让一个项目/模块作为一个依赖包提供给他人使用，则可以使用 mvn package 命令将项目打“小包”，这种打包方式只打包了项目/模块中的代码到 JAR 包中，并没有打包它的依赖包。

如果希望项目打出来 Jar 包可以作为一个独立服务运行（即该jar包可以直接运行），一种方式是通过 maven package 命令打包，但需要在 META-INF/MANIFEST.MF 中指定Main-Class；另一种方式是通过maven打包插件进行打包，而打包插件也有很多种，下面将分别介绍。

注：将项目打包为“小包”的做法很简单，就是在 pom.xml 文件中 build 标签下的 plugins 标签给注释掉即可，也就是不做任何打包插件的配置，然后使用 mvn package 命令打包即可。

pom文件配置

<build>
    <!-- 项目最终打包成的名字 -->
    <finalName>community</finalName>
</build>

然后执行打包命令

# 先执行 clean，再执行 package，并且跳过测试用例的执行
mvn clean package -Dmaven.test.skip=true

执行完打包命令后会在项目的target目录下生成对应的jar包。

2、maven插件打包

使用Maven打包插件可以生成能直接运行的jar包，主要有以下几种：

jar：默认的打包方式，用来打普通的project JAR包；可以使用maven-jar-plugin 和 maven-dependency-plugin 插件。
assembly：自定义的打包结构，也可以定制依赖项等；可以使用 maven-assembly-plugin 插件。
shade：用来打可执行jar包，也就是所谓的fat JAR包；可以使用 maven-shade-plugin 插件。

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

默认的打包方式，用来打普通的project JAR包。

maven-jar-plugin 插件的思想就是：指定启动类、指定依赖包相对于项目最终 Jar 包所在的路径、给 MANIFEST.MF 文件添加 Class-Path 属性（运行项目 Jar 包时会根据 Class-Path 属性来找到具体依赖 Jar 包的路径）。

使用maven-jar-plugin插件打包，生成的jar文件只包括当前模块的jar,不包含依赖模块的jar,无法单独启动，需要有依赖包才可以运行。

maven仓库的插件介绍地址：https://maven.apache.org/plugins/maven-jar-plugin/jar-mojo.html

maven-dependency-plugin 插件的主要思想就是：指定所有依赖打为 Jar 包后的存放路径。 maven-dependency-plugin 是处理与依赖相关的插件。它有很多可用的goal，大部分是和依赖构建、分析和解决相关的goal，这部分goal可以直接用maven的命令操作。最常用到的是 dependency:copy，dependency:copy-dependencies，dependency:unpack，dependency:unpack-dependencies 这四个。

一般情况下，这2个插件会结合使用。

这种方式生成jar包有个缺点，就是生成的jar包太多不便于管理。但同时也是他的优点，想一想，要是把所有的依赖包都打包进最终运行jar包，如果依赖包少还好说，要是依赖包很多，导致最终生成的jar包特别大，有时可能达到几百兆，这对于部署/拷贝来说肯定是一个噩梦。

若每次打包都包括lib，部署拷贝文件的时候会非常慢，而且lib每次都一样，所以可以把lib包独立出来放在服务器固定目录，每次只打包不包括lib的jar包。此种情况就适合该打包方式。
其它两种方式只生成一个jar文件，包含项目本身的代码、资源以及所有的依赖包。

pom.xml 文件中关于打包的配置信息如下：

<build>
   <plugins>
      <!-- 配置打包，并配置MainClass， 但不将依赖包打包，会出现找不到依赖的异常 -->
      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-jar-plugin</artifactId>
         <!-- 版本号 -->
         <version>3.2.2</version>
         <configuration>
            <archive>
               <!-- 生成的jar中，包含pom.xml和pom.properties这两个文件，非必须 -->
               <addMavenDescriptor>true</addMavenDescriptor>
               <!-- 生成MANIFEST.MF的设置 -->
               <manifest>
                  <!-- 非必须 -->
                  <useUniqueVersions>false</useUniqueVersions>
                  <!-- 为依赖包添加路径, 这些路径会写在MANIFEST文件的Class-Path下 -->
                  <addClasspath>true</addClasspath>
                  <!-- MANIFEST.MF 中 Class-Path，依赖的jar包存放位置，和生成的jar放在同一级目录下 -->
                  <classpathPrefix>lib/</classpathPrefix>
                  <mainClass>cn.kongzi.Application</mainClass>
               </manifest>
            </archive>
            <!-- jar包的位置，非必须 -->
            <outputDirectory>${project.build.directory}/lib</outputDirectory>
            <!-- jar包含的文件，非必须 -->
            <includes>
               <!-- 打jar包时，打包class文件和 properties文件 -->
               <include>**/*.class</include>
               <include>**/*.properties</include>
            </includes>
            <!-- jar剔除的文件，非必须 -->
            <excludes>
               <!-- 打jar包时，不打包config开头目录下的文件和bin目录下的文件 -->
               <exclude>config**/**</exclude>
               <exclude>bin/**</exclude>
            </excludes>
         </configuration>
      </plugin>
      
      <!--  配置依赖包  -->
      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-dependency-plugin</artifactId>
         <!-- 版本号 -->
         <version>3.3.0</version>
         <executions>
            <execution>
               <id>copy-dependencies</id>
               <phase>package</phase>
               <goals>
                  <goal>copy-dependencies</goal>
               </goals>
               <configuration>
                  <!--  将依赖包打包至target下的libs目录  -->
                  <outputDirectory>${project.build.directory}/lib</outputDirectory>
                  <excludeTransitive>false</excludeTransitive>
                  <stripVersion>false</stripVersion>
               </configuration>
            </execution>
         </executions>
      </plugin>
   </plugins>
</build>

maven-jar-plugin 插件可以用于生成 META-INF/MANIFEST.MF 文件的部分内容， <mainClass>com.kongzi.Application</mainClass>指定 MANIFEST.MF 中的 Main-Class，<addClasspath>true</addClasspath> 会在 MANIFEST.MF 加上 Class-Path 项并配置依赖包，<classpathPrefix>lib/</classpathPrefix> 指定依赖包所在目录。

只是生成 MANIFEST.MF 文件还不够，这种情况下如果运行生成的jar包还是会报错，原因是该jar包的依赖包没有关联上，所以需要使用 maven-dependency-plugin插件，该插件用于将依赖包拷贝到 <outputDirectory>${project.build.directory}/lib</outputDirectory> 指定的位置，即target/lib 目录下。执行 mvn package 打包命令之后，在target目录下会多出lib目录，该目录下包含一系列在此插件内列出的artifacts。

可以看到，在 MANIFEST.MF 文件中生成了 Class-Path 属性，该属性的值是当前项目的所有依赖 Jar 包的路径（即 lib 目录中的 Jar 包）；当然还有 MainClass 属性，由于图片尺寸的原因，没有截到。

这种方式打包出来的 Jar 包，在代码层面只包含了项目本身的代码。而项目的依赖都以 Jar 包的形式放在了项目 Jar 包同级别目录下的 lib 目录中，这些依赖 Jar 包的路径在 MANIFEST.MF 文件中都以路径的方式指明了。所以可以直接通过 java -jar xxx.jar 运行jar包。

2.1.1 jar包版本号指定方式

version：jar包的版本号，可以如上所示在插件配置文件中指定 <version> 属性，也可以在 pom.xml（或多模块的父pom.xml） 文件的 <properties> 属性中指定，如下代码：

以上2种方式指定一种即可。

<properties>
	<maven-jar-plugin.version>3.2.2</maven-jar-plugin.version>
	<maven-dependency-plugin.version>3.3.0</maven-dependency-plugin.version>
</properties>

2.1.2 插件配置属性详解

1）maven-jar-plugin插件属性详解：

addMavenDescriptor：生成的jar中，包含pom.xml和pom.properties这两个文件，非必须配置。
manifest：生成MANIFEST.MF的设置
- useUniqueVersions：这个属性特别关键，如果没有这个属性，有时候我们引用的包maven库下面可能会有多个包，并且只有一个是正确的，其余的可能是带时间戳的，此时会在classpath下面把那个带时间戳的给添加上去，然后我们在依赖打包的时候，打的是正确的，所以两头会对不上，报错，非必须配置。
- addClasspath：为依赖包添加路径, 这些路径会写在MANIFEST文件的Class-Path下。
- classpathPrefix：MANIFEST.MF 中的Class-Path，即这个jar包所依赖的其他jar包添加classPath的时候的前缀，如果这个jar本身和依赖包在同一级目录，则不需要添加。
- mainClass：jar启动入口类。
outputDirectory：生成jar包的存放位置，非必须，project.build.directory 标识 target目录。
includes：打jar需要包含的文件，非必须
- include：打jar包时，需要包含哪些文件，如例子中只打包 class文件和 properties文件，可以有多个配置。
excludes：jar剔除的文件，非必须
- exclude：打jar包时，需要排除在外的文件，即这些文件不会打包到jar包内，可以有多个配置。

2）maven-dependency-plugin插件属性详解：

<execution>：执行单元
  id: 标识
  phase: 在哪个阶段执行，如 package
  goals-goal: 执行的操作：copy、copy-dependencies、unpack、unpack-dependencies 四种
<configuration>: 执行单元内的配置
  type: 类型 jar
  includeTypes: jar
  outputDirectiry:存放的路径 project.build.directory标识 target目录
  excludeTransitive:是否排除间接依赖 默认false 不排除
  stripVersion:是否消除依赖jar包后缀的版本信息 默认是false 不取消版本信息

goals-goal：指定依赖包的处理方式，为 copy 或者 unpack 的话，configuration中可以加多个artifactItem 信息进行打包，有以下几种方式：
- copy：拷贝指定jar包到指定目录，这个包需要具体指定要拷哪个包，与当前工程的依赖没有关系。即将一系列在此插件内列出的artifacts ，将他们copy到一个特殊的地方，重命名或者去除其版本信息。这个可以解决远程仓库存在但是本地仓库不存在的依赖问题，copy操作可以用来将某个（些）maven artifact(s)拷贝到某个目录下。
- unpack：unpack和copy类似，只不过它会把拷来的包解开，即解压指定jar包到指定目录。
- copy-dependencies：拷贝依赖jar包到指定目录，是用来拷贝当前工程的依赖包的，典型的，例如我们有一个web应用，当打成war包的时候，它所有的依赖也需要被打到应用中。
- unpack-dependencies：和copy-dependencies类似，只不过它会把拷来的包解开，即解压依赖jar包到指定目录。
configuration：依赖包的配置信息。
- outputDirectory：依赖包存放的位置，project.build.directory 标识 target目录。${project.build.directory}/libs 表示依赖包放在target下的libs目录。
- excludeTransitive：是否排除间接依赖默认为false，不排除，非必须配置。
- stripVersion：是否消除依赖jar包后缀的版本信息，默认是false，不取消版本信息，非必须配置。

copy方式示例

<plugin>
   <groupId>org.apache.maven.plugins</groupId>
   <artifactId>maven-dependency-plugin</artifactId>
   <version>2.8</version>
   <executions>
      <execution>
         <phase>package</phase>
         <goals>
            <goal>copy</goal>
         </goals>
         <configuration>
         	  <artifactItems>
         			<artifactItem>
         				<groupId>junit</groupId>
         				<artifactId>junit</artifactId>
         				<version>4.11</version>
         				<outputDirectory>${project.build.directory}/libs</outputDirectory>
         			</artifactItem>
         	  </artifactItems>
         </configuration>
      </execution>
   </executions>
</plugin>

执行mvn package打包命令之后，会多出libs目录：

unpack方式示例

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-dependency-plugin</artifactId>
  <version>2.8</version>
  <executions>
    <execution>
      <phase>package</phase>
      <goals>
        <goal>unpack</goal>
      </goals>
      <configuration>
        <artifactItems>
          <artifactItem>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
          </artifactItem>
          <artifactItem>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <outputDirectory>${project.build.directory}/libs</outputDirectory>
          </artifactItem>
        </artifactItems>
        <outputDirectory>lib</outputDirectory>
      </configuration>
    </execution>
  </executions>
</plugin>

执行mvn package打包命令之后,slf4j复制到lib目录下,junit复制到libs目录下：

2.2 使用 maven-assembly-plugin 插件

使用 maven-assembly-plugin 插件打出来的包只有一个 Jar 包，这个 Jar 包中包含了项目代码以及依赖的代码。也就意味着此种方式打出来的 Jar 包可以直接通过 java -jar xxx.jar 的命令来运行。

这个插件的配置思想是：首先还是指定启动类；然后配置描述符参数，这个是插件提供的预置参数，不用更改；接下来就是打包时追加的命令了。

方式一：使用mvn package assembly:single命令打包

pom.xml 文件中关于打包的配置信息如下：

<build>
	<!-- 项目最终打包成的名字 -->
	<finalName>community</finalName>
    
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-assembly-plugin</artifactId>
  			<version>2.5.5</version>
			<configuration>
				<archive>
					<!-- 指定启动类 -->
					<manifest>
						<mainClass>com.kongzi.CommunityApplication</mainClass>
					</manifest>
				</archive>
           <!-- Maven预配置的描述符 -->
				<descriptorRefs>
					<descriptorRef>jar-with-dependencies</descriptorRef>
				</descriptorRefs>
			</configuration>
		</plugin>
	</plugins>
</build>

然后执行 Maven 打包命令：

mvn package assembly:single

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

方式二：使用mvn package命令打包，不需要加assembly:single

pom.xml 文件中关于打包的配置信息如下，与上面的配置不同之处在于多了executions配置，这段配置相当于在执行 package 打包时，在后面加上 assembly:single：

配置中的 <phase>package</phase>、<goal>single</goal> 即表示在执行 package 打包时，执行 assembly:single，所以可以直接使用 mvn package 打包。
重点：如果项目中用到Spring Framework，用这种方式打出来的包运行时会出错，使用下面的方法三可以处理。

<build>
	<!-- 项目最终打包成的名字 -->
	<finalName>community</finalName>

	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-assembly-plugin</artifactId>
  			<version>2.5.5</version>
			<configuration>
				<archive>
					<!-- 指定启动类 -->
					<manifest>
						<mainClass>com.ronz.community.CommunityApplication</mainClass>
					</manifest>
				</archive>
				<!-- 追加在生成的打包文件名称的后面 -->
				<descriptorRefs>
					<descriptorRef>jar-with-dependencies</descriptorRef>
				</descriptorRefs>
			</configuration>
			<!-- 相当于在执行 package 打包时，在后面加上 assembly:single  -->
			<executions>
				<execution>
					<id>make-assembly</id>
					<phase>package</phase>
					<goals>
						<goal>single</goal>
					</goals>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>

然后执行 Maven 打包命令：

# 先后执行 clean、package，并跳过测试文件的执行
mvn clean package -Dmaven.test.skip=true

打包完成之后，会在 target 目录下生成一个 Jar 包：

使用反编译工具查看 Jar 包：

从上图中可以清楚的看到：项目的所有依赖都以源码文件的形式整合在了一起。

方式三：同方式二，引入了assembly.xml描述文件

pom.xml 文件中关于打包的配置信息如下：

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-assembly-plugin</artifactId>
	<configuration>
		<descriptors>
			<descriptor>src/main/assembly/assembly.xml</descriptor>
		</descriptors>
	</configuration>
	<executions>
		<execution>
			<id>make-assembly</id>
			<phase>package</phase>
			<goals>
				<goal>single</goal>
			</goals>
		</execution>
	</executions>
</plugin>

不同于方式二的地方是<configuration>下的<descriptor>标签里配置的是 assembly.xml 描述文件，按照上述配置，我们需要新建 assembly 文件夹，并且加入 assembly.xml 描述文件，打包时需要用到这个文件描述的规则，官方给出的示例如下：

<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
    <id>bin</id>
    <formats>
        <format>tar.gz</format>
        <format>tar.bz2</format>
        <format>zip</format>
    </formats>
    <fileSets>
        <fileSet>
            <directory>${project.basedir}</directory>
            <outputDirectory>/</outputDirectory>
            <includes>
                <include>README*</include>
                <include>LICENSE*</include>
                <include>NOTICE*</include>
            </includes>
        </fileSet>
        <fileSet>
            <directory>${project.build.directory}</directory>
            <outputDirectory>/</outputDirectory>
            <includes>
                <include>*.jar</include>
            </includes>
        </fileSet>
        <fileSet>
            <directory>${project.build.directory}/site</directory>
            <outputDirectory>docs</outputDirectory>
        </fileSet>
    </fileSets>
</assembly>

字段解析

字段	解析
formats	是assembly插件支持的打包文件格式，有zip、tar、tar.gz、tar.bz2、jar、war。可以同时定义多个format
id	是添加到打包文件名的标识符，用来做后缀。也就是说，如果按上面的配置，生成的文件就是artifactId − {artifactId}-artifactId−{version}-assembly.tar.gz
fileSets/fileSet	用来设置一组文件在打包时的属性
directory	源目录的路径
includes/excludes	设定包含或排除哪些文件，支持通配符
fileMode	指定该目录下的文件属性，采用Unix八进制描述法，默认值是064
outputDirectory	生成目录的路径
files/file	与fileSets大致相同，不过是指定单个文件，并且还可以通过destName属性来设置与源文件不同的名称
dependencySets/dependencySet	用来设置工程依赖文件在打包时的属性，也与fileSets大致相同
dependencySet-unpack	布尔值，false表示将依赖以原来的JAR形式打包，true则表示将依赖解成*.class文件的目录结构打包
dependencySet-scope	表示符合哪个作用范围的依赖会被打包进去。compile与provided都不用管，一般是写runtime

一般来说，这个简单的例子是不够用的，于是我们根据实际的需求可以修改这个文件，参考的说明可以参照官方文档：https://maven.apache.org/plugins/maven-assembly-plugin/assembly.html
里面比较详细，也可以直接参考附录中的xml模板：maven-assembly-plugin 插件的assembly.xml描述文件（最全的包括解释的xml模板）

2.3 使用 maven-shade-plugin 插件（推荐使用）

根据 Maven 的官方文档介绍，maven-shade-plugin 是一个强大的打包插件。它同样可以将项目的依赖以及项目的源码打包成一个可执行 Jar 包。

这个插件的配置思想是：首先指定执行 package 命令时附加命令，这个是固定的，不需要改变；接下来就是指定项目的启动类；然后就是配置一个文件合并操作，主要是因为有的项目可能会有重名的资源文件，为了避免前面的资源文件被后面的覆盖掉，可以将重名的配置文件合并为一个文件，对于无重名资源文件的项目则无需配置。
如果项目中用到Spring Framework，也可以正常打包，可以避免 maven-assembly-plugin 插件失败的问题。

方式一：不配置文件合并操作

该方式的问题在于：如果项目中用到了Spring Framework，将依赖打到一个jar包中，运行时会出现读取XML schema文件出错。原因是Spring Framework的多个jar包中包含相同的文件 spring.handlers 和spring.schemas，如果生成一个jar包会互相覆盖。

pom.xml 文件中关于打包的配置信息如下：

<build>
	<!-- 项目最终打包成的名字 -->
	<finalName>community</finalName>
	<plugins>
      <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-shade-plugin</artifactId>
          <version>3.2.4</version>
          <executions>
              <execution>
                  <phase>package</phase>
                  <goals>
                      <goal>shade</goal>
                  </goals>
                  <configuration>
                      <transformers>
                          <!-- 指定启动类 -->
                          <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                              <mainClass>com.kongzi.CommunityApplication</mainClass>
                          </transformer>
                      </transformers>
                  </configuration>
              </execution>
          </executions>
      </plugin>
	</plugins>
</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 来对文件内容追加合并：

方式二：配置文件合并操作

如果项目中用到了Spring Framework，需要使用 AppendingTransformer 来对文件内容追加合并，这样可以合并Spring Framework的多个jar包中相同的文件 spring.handlers 和spring.schemas。这样将依赖打到一个jar包中时，运行时就不会出现读取XML schema文件错误了。

pom.xml 文件中关于打包的配置信息如下：

<build>
	<!-- 项目最终打包成的名字 -->
	<finalName>community</finalName>
	<plugins>
      <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-shade-plugin</artifactId>
          <version>3.2.4</version>
          <executions>
              <execution>
                  <phase>package</phase>
                  <goals>
                      <goal>shade</goal>
                  </goals>
                  <configuration>
                      <transformers>
                          <!-- 指定启动类 -->
                          <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                              <mainClass>com.kongzi.CommunityApplication</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>

执行 Maven 打包命令：

# 先后执行 clean、package，并跳过测试文件的执行
mvn clean package -Dmaven.test.skip=true

打包完成之后，会在 target 目录下生成一个 xxx.jar 包，此 Jar 包中也是将项目依赖的源码包含进来了，可以通过 java -jar xxx.jar 命令直接运行 Jar 包。

配置属性

可以使用excludes排除部分jar包，例如：

<excludes>
  <exclude>jmock:*</exclude>
  <exclude>*:xml-apis</exclude>
  <exclude>org.apache.maven:lib:tests</exclude>
  <exclude>log4j:log4j:jar:</exclude>
</excludes>

将依赖jar包内部资源添加或排除，例如：

<excludes>
  <exclude>META-INF/*.SF</exclude>
  <exclude>META-INF/*.DSA</exclude>
  <exclude>META-INF/*.RSA</exclude>
</excludes>

自动将所有不使用的类排除，例如

<configuration>
  <minimizeJar>true</minimizeJar>
</configuration>

将依赖的类重命名并打包进来（隔离方案），例如将org.codehaus.plexus.util重命名为org.shaded.plexus.util：

<relocations>
  <relocation>
    <pattern>org.codehaus.plexus.util</pattern>
    <shadedPattern>org.shaded.plexus.util</shadedPattern>
    <excludes>
      <exclude>org.codehaus.plexus.util.xml.Xpp3Dom</exclude>
      <exclude>org.codehaus.plexus.util.xml.pull.*</exclude>
    </excludes>
  </relocation>
</relocations>

修改包的后缀名:

<configuration>
   <shadedArtifactAttached>true</shadedArtifactAttached>
   <shadedClassifierName>jackofall</shadedClassifierName> <!-- Any name that makes sense -->
 </configuration>

3、参考文档

jar打包官方教程： https://maven.apache.org/shared/maven-archiver/examples/classpath.html

assembly打包官方教程：https://maven.apache.org/plugins/maven-assembly-plugin/examples/single/filtering-some-distribution-files.html

shade打包官方教程：https://maven.apache.org/plugins/maven-shade-plugin/examples/attached-artifact.html

4、附录

maven-assembly-plugin 插件的assembly.xml描述文件（最全的包括解释的xml模板）

<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd">
    <!--
        设置此程序集的标识。这是来自此项目的特定文件组合的符号名称。此外，除了用于通过将生成的归档的值附加到组合包以明确命名组合包之外，该ID在部署时用作工件的分类器。
    -->
    <!--string-->
    <id/>
    <!--
        (许多） 指定程序集的格式。通过目标参数而不是在这里指定格式通常会更好。例如，允许不同的配置文件生成不同类型的档案。
        可以提供多种格式，装配体插件将生成每种所需格式的档案。部署项目时，所有指定的文件格式也将被部署。
        通过在<format>子元素中提供以下值之一来指定格式：
        “zip” - 创建一个ZIP文件格式
        “tar” - 创建一个TAR格式
        “tar.gz”或“tgz” - 创建一个gzip'd TAR格式
        “tar.bz2”或“tbz2” - 创建一个bzip'd TAR格式
        “tar.snappy” - 创建一个灵活的TAR格式
        “tar.xz”或“txz” - 创建一个xz'd TAR格式
        “jar” - 创建一个JAR格式
        “dir” - 创建分解的目录格式
        “战争” - 创建一个WAR格式
    -->
    <!--List<String>-->
    <formats/>
    <!--
        在最终归档中包含一个基本目录。例如，如果您正在创建一个名为“your-app”的程序集，则将includeBaseDirectory设置为true将创建一个包含此基本目录的归档文件。
        如果此选项设置为false，则创建的存档将其内容解压缩到当前目录。
        默认值是：true。
    -->
    <!--boolean-->
    <includeBaseDirectory/>
    <!--
        设置生成的程序集归档的基本目录。如果没有设置，并且includeBaseDirectory == true，则将使用$ {project.build.finalName}。（从2.2-beta-1开始）
    -->
    <!--string-->
    <baseDirectory/>
    <!--
        在最终档案中包含一个网站目录。项目的站点目录位置由Assembly Plugin的siteDirectory参数确定。
        默认值是：false。
    -->
    <!--boolean-->
    <includeSiteDirectory/>

    <!--
        （许多） 从常规归档流中过滤各种容器描述符的组件集合，因此可以将它们聚合然后添加。
    -->
    <!--List<ContainerDescriptorHandlerConfig>-->
    <containerDescriptorHandlers>
        <!--
            配置文件头部的过滤器，以启用各种类型的描述符片段（如components.xml，web.xml等）的聚合。
        -->
        <containerDescriptorHandler>
            <!--
                处理程序的plexus角色提示，用于从容器中查找。
            -->
            <!--string-->
            <handlerName/>
            <!--
                处理程序的配置选项。
            -->
            <!--DOM-->
            <configuration/>
        </containerDescriptorHandler>
    </containerDescriptorHandlers>
    <!--
        （许多） 指定在程序集中包含哪些模块文件。moduleSet是通过提供一个或多个<moduleSet>子元素来指定的。
    -->
    <!--List<ModuleSet>-->
    <moduleSets>
        <!--
            moduleSet表示一个或多个在项目的pom.xml中存在的<module>项目。这使您可以包含属于项目<modules>的源代码或二进制文件。
            注意：从命令行使用<moduleSets>时，需要先通过“mvn package assembly：assembly”来传递包阶段。这个bug计划由Maven 2.1解决。
        -->
        <moduleSet>
            <!--
                如果设置为true，则该插件将包含当前反应堆中的所有项目，以便在此ModuleSet中进行处理。这些将被 纳入/排除(includes/excludes) 规则。（从2.2开始）
                默认值是：false。
            -->
            <!--boolean-->
            <useAllReactorProjects/>
            <!--
                如果设置为false，则该插件将从该ModuleSet中排除子模块的处理。否则，它将处理所有子模块，每个子模块都要遵守包含/排除规则。（从2.2-beta-1开始）
                默认值是：true。
            -->
            <!--boolean-->
            <includeSubModules/>
            <!--
                （许多） 当存在<include>子元素时，它们定义一组包含的项目坐标。如果不存在，则<includes>表示所有有效值。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <includes/>
            <!--
                （许多） 当存在<exclude>子元素时，它们定义一组要排除的项目工件坐标。如果不存在，则<excludes>不表示排除。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <excludes/>
            <!--
                当存在这个时，插件将在生成的程序集中包含这个集合中包含的模块的源文件。
                包含用于在程序集中包含项目模块的源文件的配置选项。
            -->
            <!--ModuleSources-->
            <sources>
                <!--
                    在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2-beta-1开始）
                    默认值是：true。
                -->
                <!--boolean-->
                <useDefaultExcludes/>
                <!--
                    设置输出目录相对于程序集根目录的根目录。例如，“日志”将把指定的文件放在日志目录中。
                -->
                <!--string-->
                <outputDirectory/>
                <!--
                    （许多） 当<include>子元素存在时，它们定义一组要包含的文件和目录。如果不存在，则<includes>表示所有有效值。
                -->
                <!--List<String>-->
                <includes/>
                <!--
                    （许多） 当存在<exclude>子元素时，它们定义一组要排除的文件和目录。如果不存在，则<excludes>不表示排除。
                -->
                <!--List<String>-->
                <excludes/>
                <!--
                    与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0644转换为用户读写，组和其他只读。默认值是0644
                -->
                <!--string-->
                <fileMode/>
                <!--
                    与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
                -->
                <!--string-->
                <directoryMode/>
                <!--
                    （许多） 指定包含在程序集中的每个包含模块的哪些文件组。fileSet通过提供一个或多个<fileSet>子元素来指定。（从2.2-beta-1开始）
                -->
                <!--List<FileSet>-->
                <fileSets>
                    <!--
                        fileSet允许将文件组包含到程序集中。
                    -->
                    <fileSet>
                        <!--
                            在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2-beta-1开始）
                            默认值是：true。
                        -->
                        <!--boolean-->
                        <useDefaultExcludes/>
                        <!--
                            设置输出目录相对于程序集根目录的根目录。例如，“日志”将把指定的文件放在日志目录中。
                        -->
                        <!--string-->
                        <outputDirectory/>
                        <!--
                            （许多） 当<include>子元素存在时，它们定义一组要包含的文件和目录。如果不存在，则<includes>表示所有有效值。
                        -->
                        <!--List<String>-->
                        <includes/>
                        <!--
                            （许多） 当存在<exclude>子元素时，它们定义一组要排除的文件和目录。如果不存在，则<excludes>不表示排除。
                        -->
                        <!--List<String>-->
                        <excludes/>
                        <!--
                            与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                            例如，值0644转换为用户读写，组和其他只读。默认值是0644.
                        -->
                        <!--string-->
                        <fileMode/>
                        <!--
                            与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                            例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
                        -->
                        <!--string-->
                        <directoryMode/>
                        <!--
                            设置模块目录的绝对或相对位置。例如，“src / main / bin”会选择定义这个依赖关系的项目的这个子目录。
                        -->
                        <!--string-->
                        <directory/>
                        <!--
                            设置此文件集中文件的行结束符。有效值：
                            “keep” - 保留所有的行结束
                            “unix” - 使用Unix风格的行尾（即“\ n”）
                            “lf” - 使用一个换行符结束符（即“\ n”）
                            “dos” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                            “windows” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                            “crlf” - 使用回车，换行符结尾（即“\ r \ n”）
                        -->
                        <!--string-->
                        <lineEnding/>
                        <!--
                            是否在复制文件时过滤符号，使用构建配置中的属性。（从2.2-beta-1开始）
                            默认值是：false。
                        -->
                        <!--boolean-->
                        <filtered/>
                    </fileSet>
                </fileSets>
                <!--
                    指定模块的finalName是否应该添加到应用于它的任何fileSets的outputDirectory值。（从2.2-beta-1开始）
                    默认值是：true。
                -->
                <!--boolean-->
                <includeModuleDirectory/>
                <!--
                    指定是否应从应用于该模块的文件集中排除当前模块下方的子模块目录。如果仅仅意味着复制与此ModuleSet匹配的确切模块列表的源，忽略（或单独处理）当前目录下目录中存在的模块，这可能会很有用。（从2.2-beta-1开始）
                    默认值是：true。
                -->
                <!--boolean-->
                <excludeSubModuleDirectories/>
                <!--
                    设置此程序集中包含的所有模块基本目录的映射模式。注意：只有在includeModuleDirectory == true的情况下才会使用此字段。
                    缺省值是在 2.2-beta-1中是$ {artifactId}，以及后续版本中是$ {module.artifactId}。（从2.2-beta-1开始）
                    默认值是：$ {module.artifactId}。
                -->
                <!--string-->
                <outputDirectoryMapping/>
            </sources>
            <!--
                    如果存在，插件将在生成的程序集中包含来自该组的所包含模块的二进制文件。
                    包含用于将项目模块的二进制文件包含在程序集中的配置选项。
            -->
            <!--ModuleBinaries-->
            <binaries>
                <!--
                    设置输出目录相对于程序集根目录的根目录。例如，“log”会将指定的文件放在归档根目录下的日志目录中。
                -->
                <!--string-->
                <outputDirectory/>
                <!--
                    （许多） 当存在<include>子元素时，它们定义一组要包含的工件坐标。如果不存在，则<includes>表示所有有效值。
                    工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                    另外，可以使用通配符，如*：maven- *
                -->
                <!--List<String>-->
                <includes/>
                <!--
                    （许多） 当存在<exclude>子元素时，它们定义一组依赖项工件坐标以排除。如果不存在，则<excludes>不表示排除。
                    工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                    另外，可以使用通配符，如*：maven- *
                -->
                <!--List<String>-->
                <excludes/>
                <!--
                    与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0644转换为用户读写，组和其他只读。默认值是0644
                -->
                <!--string-->
                <fileMode/>
                <!--
                    与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
                -->
                <!--string-->
                <directoryMode/>
                <!--
                    指定时，attachmentClassifier将使汇编器查看附加到模块的工件，而不是主工程工件。如果能够找到与指定分类符匹配的附件，则会使用它; 否则，会抛出异常。（从2.2-beta-1开始）
                -->
                <!--string-->
                <attachmentClassifier/>
                <!--
                    如果设置为true，插件将包含这里包含的项目模块的直接和传递依赖关系。否则，它将只包含模块包。
                    默认值是：true。
                -->
                <!--boolean-->
                <includeDependencies/>
                <!--List<DependencySet>-->
                <dependencySets>
                    <!--
                        依赖关系集允许在程序集中包含和排除项目依赖关系。
                    -->
                    <dependencySet>
                        <!--
                                设置输出目录相对于程序集根目录的根目录。例如，“log”会将指定的文件放在归档根目录下的日志目录中。
                            -->
                        <!--string-->
                        <outputDirectory/>
                        <!--
                            （许多） 当存在<include>子元素时，它们定义一组要包含的工件坐标。如果不存在，则<includes>表示所有有效值。
                            工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                            另外，可以使用通配符，如*：maven- *
                        -->
                        <!--List<String>-->
                        <includes/>
                        <!--
                            （许多） 当存在<exclude>子元素时，它们定义一组依赖项工件坐标以排除。如果不存在，则<excludes>不表示排除。
                            工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                            另外，可以使用通配符，如*：maven- *
                        -->
                        <!--List<String>-->
                        <excludes/>
                        <!--
                            与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                            例如，值0644转换为用户读写，组和其他只读。默认值是0644
                        -->
                        <!--string-->
                        <fileMode/>
                        <!--
                            与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                            例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
                        -->
                        <!--string-->
                        <directoryMode/>
                        <!--
                            如果指定为true，那么在程序集创建过程中任何用于过滤实际构件的包含/排除模式都将导致构建失败，并显示错误。这是为了强调过时的包含或排除，或者表示程序集描述符配置不正确。（从2.2开始）
                            默认值是：false。
                        -->
                        <!--boolean-->
                        <useStrictFiltering/>
                        <!--
                            为此程序集中包含的所有依赖项设置映射模式。（从2.2-beta-2开始； 2.2-beta-1使用$ {artifactId} - $ {version} $ {dashClassifier？}。$ {extension}作为默认值）。
                            默认值是：$ {artifact.artifactId} - $ {artifact.version} $ {dashClassifier？}。$ {artifact.extension}。
                        -->
                        <!--string-->
                        <outputFileNameMapping/>
                        <!--
                            如果设置为true，则此属性将所有依赖项解包到指定的输出目录中。设置为false时，依赖关系将被包含为档案（jar）。只能解压jar，zip，tar.gz和tar.bz压缩文件。
                            默认值是：false。
                        -->
                        <!--boolean-->
                        <unpack/>
                        <!--
                            允许指定包含和排除以及过滤选项，以指定从相关性工件解压缩的项目。（从2.2-beta-1开始）
                        -->
                        <unpackOptions>
                            <!--
                                （许多） 文件和/或目录模式的集合，用于匹配将在解压缩时从归档文件中包含的项目。每个项目被指定为<include> some / path </ include>（从2.2-beta-1开始）
                            -->
                            <!--List<String>-->
                            <includes/>
                            <!--
                                （许多） 用于匹配项目的文件和/或目录模式的集合，在解压缩时将其从归档文件中排除。每个项目被指定为<exclude> some / path </ exclude>（从2.2-beta-1开始）
                            -->
                            <!--List<String>-->
                            <excludes/>
                            <!--
                                是否使用构建配置中的属性过滤从档案中解压缩的文件中的符号。（从2.2-beta-1开始）
                                默认值是：false。
                            -->
                            <!--boolean-->
                            <filtered/>
                            <!--
                                设置文件的行尾。（从2.2开始）有效值：
                                “keep” - 保留所有的行结束
                                “unix” - 使用Unix风格的行结尾
                                “lf” - 使用单个换行符结束符
                                “dos” - 使用DOS风格的行尾
                                “ crlf ” - 使用Carraige返回，换行符结束
                            -->
                            <!--string-->
                            <lineEnding/>
                            <!--
                                在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2开始）
                                默认值是：true。
                            -->
                            <!--boolean-->
                            <useDefaultExcludes/>
                            <!--
                                允许指定解压档案时使用的编码，支持指定编码的unarchiver。如果未指定，将使用归档程序默认值。Archiver默认值通常代表理智（modern）的values。
                            -->
                            <!--string-->
                            <encoding/>
                        </unpackOptions>
                        <!--
                            为此dependencySet设置依赖项范围。
                            默认值是：runtime。
                        -->
                        <!--string-->
                        <scope/>
                        <!--
                            确定当前项目构建过程中产生的工件是否应该包含在这个依赖集中。（从2.2-beta-1开始）
                            默认值是：true。
                        -->
                        <!--boolean-->
                        <useProjectArtifact/>
                        <!--
                            确定当前项目构建过程中产生的附件是否应该包含在这个依赖集中。（从2.2-beta-1开始）
                            默认值是：false。
                        -->
                        <!--boolean-->
                        <useProjectAttachments/>
                        <!--
                            确定是否将传递依赖项包含在当前依赖项集的处理中。如果为true，那么include / excludes / useTransitiveFiltering将应用于传递依赖项构件以及主项目依赖项构件。
                            如果为false，则useTransitiveFiltering无意义，并且包含/排除仅影响项目的直接依赖关系。
                            默认情况下，这个值是真的。（从2.2-beta-1开始）
                            默认值是：true。
                        -->
                        <!--boolean-->
                        <useTransitiveDependencies/>
                        <!--
                            确定此依赖项集中的包含/排除模式是否将应用于给定工件的传递路径。
                            如果为真，并且当前工件是由包含或排除模式匹配的另一个工件引入的传递依赖性，则当前工件具有与其相同的包含/排除逻辑。
                            默认情况下，此值为false，以保持与2.1版的向后兼容性。这意味着包含/排除仅仅直接应用于当前的工件，而不应用于传入的工件。（从2.2-beta-1）
                            默认值为：false。
                        -->
                        <!--boolean-->
                        <useTransitiveFiltering/>
                    </dependencySet>
                </dependencySets>
                <!--
                    如果设置为true，则此属性将所有模块包解包到指定的输出目录中。当设置为false时，模块包将作为归档（jar）包含在内。
                    默认值是：true。
                -->
                <!--boolean-->
                <unpack/>
                <!--
                    允许指定包含和排除以及过滤选项，以指定从相关性工件解压缩的项目。（从2.2-beta-1开始）
                -->
                <unpackOptions>
                    <!--
                        （许多） 文件和/或目录模式的集合，用于匹配将在解压缩时从归档文件中包含的项目。每个项目被指定为<include> some / path </ include>（从2.2-beta-1开始）
                    -->
                    <!--List<String>-->
                    <includes/>
                    <!--
                        （许多） 用于匹配项目的文件和/或目录模式的集合，在解压缩时将其从归档文件中排除。每个项目被指定为<exclude> some / path </ exclude>（从2.2-beta-1开始）
                    -->
                    <!--List<String>-->
                    <excludes/>
                    <!--
                        是否使用构建配置中的属性过滤从档案中解压缩的文件中的符号。（从2.2-beta-1开始）
                        默认值是：false。
                    -->
                    <!--boolean-->
                    <filtered/>
                    <!--
                        设置文件的行尾。（从2.2开始）有效值：
                        “keep” - 保留所有的行结束
                        “unix” - 使用Unix风格的行结尾
                        “lf” - 使用单个换行符结束符
                        “dos” - 使用DOS风格的行尾
                        “ crlf ” - 使用Carraige返回，换行符结束
                    -->
                    <!--string-->
                    <lineEnding/>
                    <!--
                        在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2开始）
                        默认值是：true。
                    -->
                    <!--boolean-->
                    <useDefaultExcludes/>
                    <!--
                        允许指定解压档案时使用的编码，支持指定编码的unarchiver。如果未指定，将使用归档程序默认值。Archiver默认值通常代表理智（modern）的values。
                    -->
                    <!--string-->
                    <encoding/>
                </unpackOptions>
                <!--
                    设置此程序集中包含的所有非UNPACKED依赖关系的映射模式。（由于2.2-beta-2; 2.2-beta-1使用$ {artifactId} - $ {version} $ {dashClassifier？}。$ {extension}作为默认值）注意：如果dependencySet指定unpack == true，则outputFileNameMapping将不要使用; 在这些情况下，使用outputDirectory。有关可用于outputFileNameMapping参数的条目的更多详细信息，请参阅插件FAQ。
                    默认值是：$ {module.artifactId} - $ {module.version} $ {dashClassifier？}。$ {module.extension}。
                -->
                <!--string-->
                <outputFileNameMapping/>
            </binaries>
        </moduleSet>
    </moduleSets>
    <!--
        （许多） 指定在程序集中包含哪些文件组。fileSet通过提供一个或多个<fileSet>子元素来指定。
    -->
    <!--List<FileSet>-->
    <fileSets>
        <!--
            fileSet允许将文件组包含到程序集中。
        -->
        <fileSet>
            <!--
                在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2-beta-1开始）
                默认值是：true。
            -->
            <!--boolean-->
            <useDefaultExcludes/>
            <!--
                设置输出目录相对于程序集根目录的根目录。例如，“日志”将把指定的文件放在日志目录中。
            -->
            <!--string-->
            <outputDirectory/>
            <!--
                （许多） 当<include>子元素存在时，它们定义一组要包含的文件和目录。如果不存在，则<includes>表示所有有效值。
            -->
            <!--List<String>-->
            <includes/>
            <!--
                （许多） 当存在<exclude>子元素时，它们定义一组要排除的文件和目录。如果不存在，则<excludes>不表示排除。
            -->
            <!--List<String>-->
            <excludes/>
            <!--
                与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0644转换为用户读写，组和其他只读。默认值是0644.
            -->
            <!--string-->
            <fileMode/>
            <!--
                与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
            -->
            <!--string-->
            <directoryMode/>
            <!--
                设置模块目录的绝对或相对位置。例如，“src / main / bin”会选择定义这个依赖关系的项目的这个子目录。
            -->
            <!--string-->
            <directory/>
            <!--
                设置此文件集中文件的行结束符。有效值：
                “keep” - 保留所有的行结束
                “unix” - 使用Unix风格的行尾（即“\ n”）
                “lf” - 使用一个换行符结束符（即“\ n”）
                “dos” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                “windows” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                “crlf” - 使用回车，换行符结尾（即“\ r \ n”）
            -->
            <!--string-->
            <lineEnding/>
            <!--
                是否在复制文件时过滤符号，使用构建配置中的属性。（从2.2-beta-1开始）
                默认值是：false。
            -->
            <!--boolean-->
            <filtered/>
        </fileSet>
    </fileSets>
    <!--
        （许多） 指定在程序集中包含哪些单个文件。通过提供一个或多个<file>子元素来指定文件。
    -->
    <!--List<FileItem>-->
    <files>
        <!--
            一个文件允许单个文件包含选项来更改不受fileSets支持的目标文件名。
        -->
        <file>
            <!--
                设置要包含在程序集中的文件的模块目录的绝对路径或相对路径。
            -->
            <!--string-->
            <source/>
            <!--
                设置输出目录相对于程序集根目录的根目录。例如，“日志”将把指定的文件放在日志目录中。
            -->
            <!--string-->
            <outputDirectory/>
            <!--
                在outputDirectory中设置目标文件名。默认是与源文件相同的名称。
            -->
            <!--string-->
            <destName/>
            <!--
                与UNIX权限类似，设置所包含文件的文件模式。这是一个八卦价值。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0644转换为用户读写，组和其他只读。默认值是0644
            -->
            <!--string-->
            <fileMode/>
            <!--
                设置此文件中文件的行结束符。有效值是：
                “keep” - 保留所有的行结束
                “unix” - 使用Unix风格的行尾（即“\ n”）
                “lf” - 使用一个换行符结束符（即“\ n”）
                “dos” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                “windows” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                “crlf” - 使用回车，换行符结尾（即“\ r \ n”）
            -->
            <!--string-->
            <lineEnding/>
            <!--
                设置是否确定文件是否被过滤。
                默认值是：false。
            -->
            <!--boolean-->
            <filtered/>
        </file>
    </files>
    <!--List<DependencySet>-->
    <dependencySets>
        <!--
            依赖关系集允许在程序集中包含和排除项目依赖关系。
        -->
        <dependencySet>
            <!--
                    设置输出目录相对于程序集根目录的根目录。例如，“log”会将指定的文件放在归档根目录下的日志目录中。
                -->
            <!--string-->
            <outputDirectory/>
            <!--
                （许多） 当存在<include>子元素时，它们定义一组要包含的工件坐标。如果不存在，则<includes>表示所有有效值。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <includes/>
            <!--
                （许多） 当存在<exclude>子元素时，它们定义一组依赖项工件坐标以排除。如果不存在，则<excludes>不表示排除。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <excludes/>
            <!--
                与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0644转换为用户读写，组和其他只读。默认值是0644
            -->
            <!--string-->
            <fileMode/>
            <!--
                与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
            -->
            <!--string-->
            <directoryMode/>
            <!--
                如果指定为true，那么在程序集创建过程中任何用于过滤实际构件的包含/排除模式都将导致构建失败，并显示错误。这是为了强调过时的包含或排除，或者表示程序集描述符配置不正确。（从2.2开始）
                默认值是：false。
            -->
            <!--boolean-->
            <useStrictFiltering/>
            <!--
                为此程序集中包含的所有依赖项设置映射模式。（从2.2-beta-2开始； 2.2-beta-1使用$ {artifactId} - $ {version} $ {dashClassifier？}。$ {extension}作为默认值）。
                默认值是：$ {artifact.artifactId} - $ {artifact.version} $ {dashClassifier？}。$ {artifact.extension}。
            -->
            <!--string-->
            <outputFileNameMapping/>
            <!--
                如果设置为true，则此属性将所有依赖项解包到指定的输出目录中。设置为false时，依赖关系将被包含为档案（jar）。只能解压jar，zip，tar.gz和tar.bz压缩文件。
                默认值是：false。
            -->
            <!--boolean-->
            <unpack/>
            <!--
                允许指定包含和排除以及过滤选项，以指定从相关性工件解压缩的项目。（从2.2-beta-1开始）
            -->
            <unpackOptions>
                <!--
                    （许多） 文件和/或目录模式的集合，用于匹配将在解压缩时从归档文件中包含的项目。每个项目被指定为<include> some / path </ include>（从2.2-beta-1开始）
                -->
                <!--List<String>-->
                <includes/>
                <!--
                    （许多） 用于匹配项目的文件和/或目录模式的集合，在解压缩时将其从归档文件中排除。每个项目被指定为<exclude> some / path </ exclude>（从2.2-beta-1开始）
                -->
                <!--List<String>-->
                <excludes/>
                <!--
                    是否使用构建配置中的属性过滤从档案中解压缩的文件中的符号。（从2.2-beta-1开始）
                    默认值是：false。
                -->
                <!--boolean-->
                <filtered/>
                <!--
                    设置文件的行尾。（从2.2开始）有效值：
                    “keep” - 保留所有的行结束
                    “unix” - 使用Unix风格的行结尾
                    “lf” - 使用单个换行符结束符
                    “dos” - 使用DOS风格的行尾
                    “crlf ” - 使用Carraige返回，换行符结束
                -->
                <!--string-->
                <lineEnding/>
                <!--
                    在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2开始）
                    默认值是：true。
                -->
                <!--boolean-->
                <useDefaultExcludes/>
                <!--
                    允许指定解压档案时使用的编码，支持指定编码的unarchiver。如果未指定，将使用归档程序默认值。Archiver默认值通常代表理智（modern）的values。
                -->
                <!--string-->
                <encoding/>
            </unpackOptions>
            <!--
                为此dependencySet设置依赖项范围。
                默认值是：runtime。
            -->
            <!--string-->
            <scope/>
            <!--
                确定当前项目构建过程中产生的工件是否应该包含在这个依赖集中。（从2.2-beta-1开始）
                默认值是：true。
            -->
            <!--boolean-->
            <useProjectArtifact/>
            <!--
                确定当前项目构建过程中产生的附件是否应该包含在这个依赖集中。（从2.2-beta-1开始）
                默认值是：false。
            -->
            <!--boolean-->
            <useProjectAttachments/>
            <!--
                确定是否将传递依赖项包含在当前依赖项集的处理中。如果为true，那么include / excludes / useTransitiveFiltering将应用于传递依赖项构件以及主项目依赖项构件。
                如果为false，则useTransitiveFiltering无意义，并且包含/排除仅影响项目的直接依赖关系。
                默认情况下，这个值是真的。（从2.2-beta-1开始）
                默认值是：true。
            -->
            <!--boolean-->
            <useTransitiveDependencies/>
            <!--
                确定此依赖项集中的包含/排除模式是否将应用于给定工件的传递路径。
                如果为真，并且当前工件是由包含或排除模式匹配的另一个工件引入的传递依赖性，则当前工件具有与其相同的包含/排除逻辑。
                默认情况下，此值为false，以保持与2.1版的向后兼容性。这意味着包含/排除仅仅直接应用于当前的工件，而不应用于传入的工件。（从2.2-beta-1）
                默认值为：false。
            -->
            <!--boolean-->
            <useTransitiveFiltering/>
        </dependencySet>
    </dependencySets>
    <!--
        定义要包含在程序集中的Maven仓库。可用于存储库中的工件是项目的依赖工件。创建的存储库包含所需的元数据条目，并且还包含sha1和md5校验和。这对创建将被部署到内部存储库的档案很有用。
        注意：目前，只有来自中央存储库的工件才被允许。
    -->
    <!--List<Repository>-->
    <repositories>
        <repository>
            <!--
                设置输出目录相对于程序集根目录的根目录。例如，“log”会将指定的文件放在归档根目录下的日志目录中。
            -->
            <!--string-->
            <outputDirectory/>
            <!--
                （许多） 当存在<include>子元素时，它们定义一组包含的项目坐标。如果不存在，则<includes>表示所有有效值。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <includes/>
            <!--
                （许多） 当存在<exclude>子元素时，它们定义一组要排除的项目工件坐标。如果不存在，则<excludes>不表示排除。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <excludes/>
            <!--
                    与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0644转换为用户读写，组和其他只读。默认值是0644
                -->
            <!--string-->
            <fileMode/>
            <!--
                与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
            -->
            <!--string-->
            <directoryMode/>
            <!--
                如果设置为true，则此属性将触发创建存储库元数据，这将允许存储库用作功能性远程存储库。
                默认值是：false。
            -->
            <!--boolean-->
            <includeMetadata/>
            <!--
                （许多） 指定要将一组工件与指定的版本对齐。groupVersionAlignment通过提供一个或多个<groupVersionAlignment>子元素来指定。
                允许一组工件与指定的版本对齐。
            -->
            <!--List<GroupVersionAlignment>-->
            <groupVersionAlignments>
                <groupVersionAlignment>
                    <!--
                        要为其对齐版本的工件的groupId。
                    -->
                    <!--string-->
                    <id/>
                    <!--
                        您想要将该组对齐的版本。
                    -->
                    <!--string-->
                    <version/>
                    <!--
                        （许多） 当存在<exclude>子元素时，它们定义要排除的构件的artifactIds。如果不存在，则<excludes>不表示排除。排除是通过提供一个或多个<exclude>子元素来指定的。
                    -->
                    <!--List<String>-->
                    <excludes/>
                </groupVersionAlignment>
            </groupVersionAlignments>
            <!--
                指定此存储库中包含的工件的范围。（从2.2-beta-1开始）
                默认值是：runtime。
            -->
            <!--string-->
            <scope/>
        </repository>
    </repositories>
    <!--
        （许多） 指定要包含在程序集中的共享组件xml文件位置。指定的位置必须相对于描述符的基本位置。
        如果描述符是通过类路径中的<descriptorRef />元素找到的，那么它指定的任何组件也将在类路径中找到。
        如果通过路径名通过<descriptor />元素找到，则此处的值将被解释为相对于项目basedir的路径。
        当找到多个componentDescriptors时，它们的内容被合并。检查 描述符组件 了解更多信息。
        componentDescriptor通过提供一个或多个<componentDescriptor>子元素来指定。
    -->
    <!--List<String>-->
    <componentDescriptors/>
</assembly>

目录CONTENT

maven打包详解，不同打包插件的区别及适用场景

1、maven命令打包

1.1 maven打包命令

1.2 maven命令打包的缺点

1.3 maven命令打包适用场景

2、maven插件打包

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

2.1.1 jar包版本号指定方式

2.1.2 插件配置属性详解

2.2 使用 maven-assembly-plugin 插件

2.3 使用 maven-shade-plugin 插件（推荐使用）

3、参考文档

4、附录

评论区