打包jar一共有两种方式
第一种：

1.1 创建Artifacts

快捷键（Ctrl+Alt+Shift+S）打开项目的Project Structure。在Artifacts创建

屏幕截图(4).png

接着，指定main class，如下：

屏幕截图(5).png

最后，得到创建得到的artifacts

屏幕截图(6).png

注：这里可以通过“+”或者“-”选择那些需要打入artifacts的第三方jar文件，也可以将maven中的包都导入进来；

屏幕截图(7).png 屏幕截图(8).png

1.2 打包Artifacts

在菜单栏目选Build，最后一栏Build Artifacts

屏幕截图(9).png

最后，在出现的窗口创建

屏幕截图(10).png

得到打包结果：

屏幕截图(11).png

去执行

屏幕截图(17).png

一般会执行成功如果执行出错查看是什么错误排查即可；

2. maven打包方式（单模块）

maven打包的步骤：

• 先mvn clean，再 package即可
• 如需把项目编译成jar包，打进maven仓库里面，可以运行install命令

[图片上传中...(image-784a61-1649340624814-14)]

2.1 maven-jar-plugins 无依赖第三方jar的打包

maven 默认打包插件，用来创建 project jar

pom.xml配置如下：

屏幕截图(18).png

2.1 maven-jar-plugins 无依赖第三方jar的打包
　　 maven 默认打包插件，用来创建 project jar

pom.xml配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<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">

    <parent>
        <artifactId>erlangshen</artifactId>
        <groupId>erlangshendata</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>mok</artifactId>

    <properties>
        <maven.compiler.source>18</maven.compiler.source>
        <maven.compiler.target>18</maven.compiler.target>
    </properties>

    <!--①无依赖其他任何jar打包-->
    <build>
        <resources>
            <resource>
                <targetPath>${project.build.directory}/classes</targetPath>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.conf</include>
                </includes>
            </resource>
        </resources>

        <plugins>
            <!--scala编译打包插件-->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.1</version>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!--java编译打包插件-->
            <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>
                </configuration>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.4</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                            <!-- 这里输入man主程序的报名 -->
                            <mainClass>com.MokRun</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

运行：在target中找到打包出来的xxx.jar包，运行java -jar xxx.jar即可，但是如果程序有依赖其他包，比如程序依赖jdbc去查询db，这时候再执行就会出现找不到jdbc依赖，因为我们并没有将依赖包打进去。

2.2 maven-assembly-plugins 解决依赖第三方jar包，并可执行jar的打包

支持定制化打包方式，更多是对项目目录的重新组装。以下方式用的比较少，因为我们依赖的jar，也会打进到我们最终生成的jar中，会导致一个jar文件过大，而且如果要给第三方使用，最好给一个纯净的。

pom.xml配置如下：

<!--②解决依赖第三方，可执行jar的打包，全量打包-->
    <build>
        <resources>
            <resource>
                <targetPath>${project.build.directory}/classes</targetPath>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.conf</include>
                </includes>
            </resource>
        </resources>

        <plugins>
            <!--scala编译打包插件-->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.1</version>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!--java编译打包插件-->
            <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>
                </configuration>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <appendAssemblyId>false</appendAssemblyId>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.swordfall.restserver.base.WebServer</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>assembly</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2.3 maven-assembly-plugins zip打包

支持定制化打包方式，更多是对项目目录的重新组装。在2.2基础上，我们还可以利用assembly，将我们依赖的jar归类，打包成一个zip。发布项目的时候，将zip包copy到服务器上，直接unzip xxx.zip，里面包含要运行的jar以及依赖的lib，还有配置的config文件，还可以包括执行脚本，可以直接启动服务。

<!-- ③maven-assembly-plugin -->
    <build>
         <resources>
             <resource>
                 <directory>src/main/resources</directory>
                 <includes>
                     <include>**/*.properties</include>
                     <include>**/*.xml</include>
                 </includes>
                 <!-- 排除外置的配置文件（运行时注释上，使IDE能读到配置文件；打包时放开注释让配置文件外置，方便修改）可以不配置，maven-jar-plugin下面已配置 -->
                 <!--<excludes>
                     <exclude>config.properties</exclude>
                 </excludes>-->
             </resource>
             <!-- 配置文件外置的资源（存放到conf目录，也是classpath路径，下面会配置）-->
             <!--<resource>
                 <directory>src/main/resources</directory>
                 <includes>
                     <include>config.properties</include>
                 </includes>
                 <targetPath>${project.build.directory}/conf</targetPath>
             </resource>-->
         </resources>

        <plugins>
            <!--scala编译打包插件-->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.1</version>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!--java编译打包插件-->
            <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>
                </configuration>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!--
                ③打成一个zip包，发布项目的时候，将zip包copy到服务器上，直接unzip xxx.zip，里面包含要运行到的jar以及依赖的lib，还有配置的config文件，即可直接启动服务
            -->

            <!--The configuration of maven-jar-plugin-->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jar-plugin</artifactId>
                 <version>2.4</version>
                 <!--The configuration of the plugin-->
                 <configuration>
                     <!-- 不打包资源文件（配置文件和依赖包分开） -->
                     <excludes>
                         <exclude>*.properties</exclude>
                         <exclude>*.xml</exclude>
                         <exclude>*.txt</exclude>
                     </excludes>
                     <!--Configuration of the archiver-->
                     <archive>
                         <!--生成的jar中，不要包含pom.xml和pom.properties这两个文件-->
                         <addMavenDescriptor>false</addMavenDescriptor>
                         <!--Manifest specific configuration-->
                         <manifest>
                             <!--是否把第三方jar放到manifest的classpath中-->
                             <addClasspath>true</addClasspath>
                             <!--生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，所以classpath的前缀是lib/-->
                             <classpathPrefix>lib/</classpathPrefix>
                             <!--应用的main class-->
                             <mainClass>com.swordfall.restserver.base.WebServer</mainClass>
                         </manifest>
                         <!-- 给清单文件添加键值对，增加classpath路径，这里将conf目录也设置为classpath路径 -->
                         <manifestEntries>
                             <Class-Path>conf/</Class-Path>
                         </manifestEntries>
                     </archive>
                     <!--过滤掉不希望包含在jar中的文件-->
                    <!-- <excludes>
                         <exclude>${project.basedir}/xml/*</exclude>
                     </excludes>-->
                 </configuration>
             </plugin>

             <!--The configuration of maven-assembly-plugin-->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-assembly-plugin</artifactId>
                 <version>2.4</version>
                 <!--The configuration of the plugin-->
                 <configuration>
                     <!--Specifies the configuration file of the assembly plugin-->
                     <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>
        </plugins>
    </build>

maven-assembly-plugin还需要配置一个assembly.xml文件，用于过滤不必要的第三方jar包文件，或者确定自己编译的项目文件路径、项目的启动脚本文件目录，打包的类型格式zip或者tar.gz等。
　　assembly.xml文件内容为：

<assembly>
    <id>bin</id>
    <includeBaseDirectory>false</includeBaseDirectory>
    <!-- 最终打包成一个用于发布的zip文件 -->
    <formats>
        <format>zip</format>
    </formats>

    <!-- Adds dependencies to zip package under lib directory -->
    <dependencySets>
        <dependencySet>
            <!-- 不使用项目的artifact，第三方jar不要解压，打包进zip文件的lib目录 -->
            <useProjectArtifact>false</useProjectArtifact>
            <outputDirectory>lib</outputDirectory>
            <unpack>false</unpack>
        </dependencySet>
    </dependencySets>

    <fileSets>
        <!-- 把项目相关的说明文件，打包进zip文件的根目录 -->
        <!--<fileSet>
            <directory>${project.basedir}</directory>
            <outputDirectory>/</outputDirectory>
        </fileSet>-->

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

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

        <!-- 把项目的脚本文件目录(src/main/scripts)中的启动脚本，打包进zip文件的根目录 -->
        <fileSet>
            <directory>${project.basedir}/src/main/scripts</directory>
            <outputDirectory>bin</outputDirectory>
            <includes>
                <include>startup.*</include>
            </includes>
        </fileSet>
    </fileSets>
</assembly>

打包结果为：

image.png

2.4 maven-shade-plugin 打包

用来打可执行包，包含依赖，以及对依赖进行取舍过滤。使用这种方式打出来的是揉合在一起，成为一个jar文件。这种打包方式的优点是可以利用transformer把第三方jar相同的配置文件组合成一个文件，如reference.conf文件等等。

pom.xml配置如下：

<!--④ maven-shade-plugin-->
    <build>
         <!--资源文件路径配置-->
         <resources>
             <resource>
                 <targetPath>${project.build.directory}/classes</targetPath>
                 <directory>src/main/resources</directory>
                 <filtering>true</filtering>
                 <includes>
                     <include>**/*.xml</include>
                     <include>**/*.conf</include>
                 </includes>
             </resource>
         </resources>

         <plugins>
             <!--scala编译打包插件-->
             <plugin>
                 <groupId>net.alchim31.maven</groupId>
                 <artifactId>scala-maven-plugin</artifactId>
                 <version>3.2.1</version>
                 <executions>
                     <execution>
                         <id>scala-compile-first</id>
                         <phase>process-resources</phase>
                         <goals>
                             <goal>add-source</goal>
                             <goal>compile</goal>
                         </goals>
                     </execution>
                 </executions>
             </plugin>

             <!--java编译打包插件-->
             <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>
                 </configuration>
                 <executions>
                     <execution>
                         <phase>compile</phase>
                         <goals>
                             <goal>compile</goal>
                         </goals>
                     </execution>
                 </executions>
             </plugin>

             <!-- ④ maven-shade-plugin -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
                 <version>2.4.3</version>
                 <executions>
                     <execution>
                         <phase>package</phase>
                         <goals>
                             <goal>shade</goal>
                         </goals>
                         <configuration>
                             <!--资源转换 在打包时，存在将多个构件中的class文件或资源文件聚合的需求。shade插件提供了丰富的Transformer工具类。这里介绍一些常用的Transformer-->
                             <transformers>
                                 <!--ManifestResourceTransformer可以轻松实现往MANIFEST文件中写入Main-Class，这是可执行包的必要条件-->
                                 <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                     <mainClass>com.hongshan.bdp.restserver.base.WebServer</mainClass>
                                 </transformer>
                                 <!--AppendingTransformer用来处理多个jar包中存在重名的配置文件的合并，尤其是spring-->
                                 <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                     <resource>reference.conf</resource>
                                 </transformer>
                                 <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                     <resource>version.conf</resource>
                                 </transformer>
                                 <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                     <resource>akka-http-version.conf</resource>
                                 </transformer>
                                 <!--ServicesResourceTransformer JDK的服务发现机制是基于META-INF/services/目录的，如果同一接口存在多个实现需要合并 ，则可以使用此Transformer-->
                                 <!--<transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>-->
                             </transformers>
                             <shadedArtifactAttached>true</shadedArtifactAttached>
                             <shadedClassifierName>jar-with-dependencies</shadedClassifierName>

                             <!--过滤不需要的jar包-->
                             <artifactSet>
                                 <excludes>
                                     <exclude>io.spray:spray-json_2.11:jar:</exclude>
                                     <exclude>org.slf4j:slf4j-api:jar:</exclude>
                                     <exclude>org.slf4j:slf4j-log4j12:jar:</exclude>
                                     <exclude>log4j:log4j:jar:</exclude>
                                     <exclude>commons-logging:commons-logging:jar:</exclude>
                                     <exclude>commons-lang:commons-lang:jar:</exclude>
                                 </excludes>
                             </artifactSet>
                             
                             <!--配置<minimizeJar>将项目中没有使用的依赖自动移除，使项目最小化-->
                             <minimizeJar>true</minimizeJar>
                         </configuration>
                     </execution>
                 </executions>
             </plugin>
         </plugins>
     </build>

打包结果：

image.png

2.5 其他插件

2.5.1 maven-surefire-plugin

该插件主要用于项目maven编译打包时，跳过单元测试，pom.xml配置为：

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.22.2</version>
        <configuration>
          <skipTests>true</skipTests>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>

文献：
IntelliJ IDEA自身以及maven项目打包方式（单模块） - 牧梦者 - 博客园 (cnblogs.com)