maven的5种打包方式小结，

maven的5种打包方式小结，

目录

• 一 问题阐述
• 1.1 概述 
• 1.2 原因
• 1.3 解决办法
• 二 Maven常用打包插件
• 2.1 maven-assembly-plugin插件打包
• 2.2 maven-shade-plugin插件打包
• 2.3 maven-jar-plugin和maven-dependency-plugin插件打包
• 2.3.1 插件功能介绍
• 2.3.2 pom文件的配置
• 2.4 appassembler-maven-plugin插件打包 
• 2.5 Springboot+Maven：spring-boot-maven-plugin
• 2.6 总结

一 问题阐述

1.1 概述 

在讲打包方式之前，首先来说最近踩到的坑，在idea新建的maven项目，在pom文件中会自动生成一段插件的管理器：

2.我使用maven打包插件maven-assembly-plugin,将其配置添加到<plugManagement><plugs>.. ..</plugs></plugManagement>中间。

3.执行maven 打包后：报没有主清单，如下图所示：

将网上查找了个遍，痛苦到怀疑人生，也没有发现什么端倪，感觉配置的很正确，并且在eclipse中都在项目中用过。

1.2 原因

先来了解一下pluginManagement：

pluginManagement是表示插件声明，即你在项目中的pluginManagement下声明了插件，Maven不会加载该插件，pluginManagement声明可以被继承。

pluginManagement一般是用来在父POM中定义，提供给子POM使用，子POM也可以覆盖这个定义，而且你在父POM中定义了版本之后，子模块中直接应用groupId和artifactId，而不用指定版本，同时也方便统一管理；而在父POM中的pluginManagement并不会介入到Maven的生命周期。

plugins就是直接引入一个plugin，而且可以绑定到Maven相关的生命周期上。

pluginManagement主要是为了统一管理插件，确保所有子POM使用的插件版本保持一致，类似dependencies和dependencyManagement。

总结一句话：pluginManagement标签中声名的plug插件不参与maven的生命周期，不会被加载，但可以通过子类继承后，子类应用来使用。

这就是为何在plugManagemnet中配置maven-assembly-plugin插件后不起作用，找不到主类的原因。

https://www.jb51.net/program/322128g7x.htm

1.3 解决办法

1.将plugManagement标签里内容清空，自定义的的打包插件配置在</plugmanagement>标签之外。

2.重新打包，执行jar包

执行成功ok！

二 Maven常用打包插件

2.1 maven-assembly-plugin插件打包

作用：将自己项目中的代码和资源，还包含了所有依赖包的内容打成一个jar包。

1.pom文件的配置：如果有plugManagemnet则在其外面添加如下代码

<!--自定义打包方式-->
<plugins>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.5.5</version>
    <configuration>
      <archive>
        <manifest>
          <mainClass>com.ljf.test.Ha</mainClass>
        </manifest>
      </archive>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
    </configuration>
    <executions>
      <execution>
        <id>make-assembly</id>
        <phase>package</phase>
        <goals>
          <goal>single</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
</plugins>

2.截图如下： 

2.生成jar包的结构

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

2.2 maven-shade-plugin插件打包

作用：和maven-assembly-plugin插件的作用一样，将自己项目的代码资源以及依赖第三方的资源一起打成一个jar包，不过如果项目中用到spring Framework，用maven-assembly-plugin这种方式打出来的包运行时会出错，使用maven-shade-plugin插件可以处理这个问题

1.pom文件的配置：如果有plugManagemnet则在标签外，添加如下代码

<!--自定义打包方式-->
<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.ljf.test.Ha</mainClass>
            </transformer>
          </transformers>
        </configuration>
      </execution>
    </executions>
  </plugin>
</plugins>

2..执行jar包后的结构

3.执行打包后在target目录下会生成两个jar包，注意不是original-xxx.jar文件，而是另外一个。和maven-assembly-plugin一样，生成的jar文件包含了所有依赖，所以可以直接运行。

2.3 maven-jar-plugin和maven-dependency-plugin插件打包

作用：将执行jar包和依赖包分开（依赖包放在lib目录下），且位于同一级目录

2.3.1 插件功能介绍

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

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

2.3.2 pom文件的配置

1.pom文件的配置：如果有plugManagemnet标签，则在标签后面添加如下代码

<!--自定义打包方式-->
<plugins>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.6</version>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <classpathPrefix>lib/</classpathPrefix>
          <mainClass>com.ljf.test.Ha</mainClass>
        </manifest>
      </archive>
    </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>

注意：${project.build.directory}/lib 这个配置不需要修改，拿来即用。这个地方是配置依赖包存储的位置。“${project.build.directory}“ maven内置的设置无需理会。

2.执行jar包后的结构：执行jar包后会在target目录下生成jar包，并将依赖包拷贝到target/lib目录下

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

2.4 appassembler-maven-plugin插件打包 

作用： 利用Maven的appassembler-maven-plugin插件，就可以实现自动打包成可运行的脚本，还可以跨平台。（Windows/linux）

1.pom文件的配置

<plugins>
  <!-- 支持java1.8 -->
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
      <source>1.8</source>
      <target>1.8</target>
    </configuration>
  </plugin>
  <!-- -使用UTF-8编码处理资源文件 -->
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <configuration>
      <encoding>UTF-8</encoding>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>appassembler-maven-plugin</artifactId>
    <version>1.2</version>
    <executions>
      <execution>
        <id>make-assembly</id>
        <phase>package</phase>
        <goals>
          <goal>assemble</goal>
        </goals>
      </execution>
    </executions>
    <configuration>
      <repositoryLayout>flat</repositoryLayout>
      <configurationDirectory>conf</configurationDirectory>
      <configurationSourceDirectory>src/main/resources</configurationSourceDirectory>
      <copyConfigurationDirectory>true</copyConfigurationDirectory>
      <includeConfigurationDirectoryInClasspath>true</includeConfigurationDirectoryInClasspath>
      <assembleDirectory>${project.build.directory}/${projectname}</assembleDirectory>
      <extraJvmArguments>-Xms256m -Xmx1024m -Xss1024k -XX:PermSize=128M
        -XX:MaxNewSize=256m -XX:MaxPermSize=128m</extraJvmArguments>
      <binFileExtensions>
        <unix>.sh</unix>
      </binFileExtensions>
      <platforms>
        <platform>windows</platform>
        <platform>unix</platform>
      </platforms>
      <repositoryName>lib</repositoryName>
      <programs>
        <program>
          <mainClass>${mainfunction}</mainClass>
          <name>startup</name>
        </program>
      </programs>
    </configuration>
  </plugin>
</plugins>

2.执行mave package操作

3. 查看打包结果：

4.进入bin目录下

5.Windows 下执行startup.bat，linux下执行startup.sh,如下图：

6.执行脚本时候 后面可以添加参数。

2.5 Springboot+Maven：spring-boot-maven-plugin

 针对springboot和maven集成的项目，打成jar包，则需要使用springboot和maven集成好的打包插件：spring-boot-maven-plugin，例如特别是含有@SpringBootApplication注解的入口启动程序。截图如下：

2.pom文件的配置

<plugins>
  <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>1.3.5.RELEASE</version>
    <configuration>
      <mainClass>com.springboot.data.es.App</mainClass>
    </configuration>
    <executions>
      <execution>
        <goals>
          <goal>repackage</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
</plugins>

3.截图

 4.使用maven打成jar包：mvn clean package

5.打成jar包的结构，如下

6.执行jar包：

参考网址：   https://www.jb51.net/article/197968.htm

2.6 总结

不管通过何种方式打成jar包执行，要想jar包能直接通过java -jar xxx.jar运行，需要满足：

1、在jar包中的META-INF/MANIFEST.MF中指定Main-Class，这样才能确定程序的入口在哪里；

2、要能加载到依赖包。

到此这篇关于maven的5种打包方式小结的文章就介绍到这了,更多相关maven 打包 内容请搜索3672js教程以前的文章或继续浏览下面的相关文章希望大家以后多多支持3672js教程！

您可能感兴趣的文章:

• maven打包所有依赖对外提供sdk.jar
• Maven打包的三种方式小结
• Maven打包所有依赖到一个可执行jar中遇到的问题
• maven自动将源码打包并发布的实现步骤
• Maven及Springboot配置JDK版本,编码,源码打包等方式
• maven插件maven-assembly-plugin打包归纳文件zip/tar使用
• maven工程打包引入本地jar包的实现