Spring Boot Maven Plugin -- repackage目标；spring-boot-maven-plugin的executable配置

不念不忘少年蓝@ 2023-10-16 10:34 16阅读 0赞

### Spring Boot Maven Plugin – repackage目标 ###

Spring Boot Maven Plugin插件提供spring boot在maven中的支持。允许你打包可运行的jar包或war包。

插件提供了几个maven目标和Spring Boot 应用一起工作。总的有：

spring-boot:repackage
    spring-boot:run
    spring-boot:start and spring-boot:stop 
    spring-boot:build-info

repackage：创建一个自动可执行的jar或war文件。它可以替换常规的artifact，或者用一个单独的classifier附属在maven构建的生命周期中。

下面我们详细看下repackage这个目标。  
一、简单引用

用了重新打包应用程序，我们需要在pom.xml文件中加一个简单的引用到Spring Boot Maven Plugin插件中，代码如下：repaceage 最简单的结构

1 <build>
     2   ...
     3   <plugins>
     4     ...
     5     <plugin>
     6       <groupId>org.springframework.boot</groupId>
     7       <artifactId>spring-boot-maven-plugin</artifactId>
     8       <version>1.5.7.RELEASE</version>
     9       <executions>
    10         <execution>
    11           <goals>
    12             <goal>repackage</goal>
    13           </goals>
    14         </execution>
    15       </executions>
    16     </plugin>
    17     ...
    18   </plugins>
    19   ...
    20 </build>

repaceage 最简单的结构  
二、剔除不需要的依赖

**这个例子重新打包了一个jar包或war包，这个jar包或war包被构建于maven生命周期的package阶段，包括定义在工程中的任何依赖（包括scope为provided）。如果有一些依赖模块需要被排除掉，可以使用一个exclude的选项。**

默认情况下，repackage和run这两个maven目标会包括定义在工程中的任何依赖。一些依赖被要求从可执行jar包中排除。下面有三种方式可以在包运行时排除依赖模块。

方式1：:排除一个具体的maven 模块，通过唯一的groupId和artifactId组合来实现。（如果有必要，可以加入classifier来唯一确认。）

1 <project>
     2   ...
     3   <build>
     4     ...
     5     <plugins>
     6       ...
     7       <plugin>
     8         <groupId>org.springframework.boot</groupId>
     9         <artifactId>spring-boot-maven-plugin</artifactId>
    10         <version>1.5.6.RELEASE</version>
    11         <configuration>
    12           <excludes>
    13             <exclude>
    14               <groupId>com.foo</groupId>
    15               <artifactId>bar</artifactId>
    16             </exclude>
    17           </excludes>
    18         </configuration>
    19         ...
    20       </plugin>
    21       ...
    22     </plugins>
    23     ...
    24   </build>
    25   ...
    26 </project>

排除一个具体的maven模块

方式2：排除和“指定的artifactId”相符的所有maven模块。

1 <project>
     2   ...
     3   <build>
     4     ...
     5     <plugins>
     6       ...
     7       <plugin>
     8         <groupId>org.springframework.boot</groupId>
     9         <artifactId>spring-boot-maven-plugin</artifactId>
    10         <version>1.5.6.RELEASE</version>
    11         <configuration>
    12           <excludeArtifactIds>my-lib,another-lib</excludeArtifactIds>
    13         </configuration>
    14         ...
    15       </plugin>
    16       ...
    17     </plugins>
    18     ...
    19   </build>
    20   ...
    21 </project>

排除和指定的artifactId项目的所有maven模块

方式3：排除属于“指定的groupId”的所有maven模块。

1 <project>
     2   ...
     3   <build>
     4     ...
     5     <plugins>
     6       ...
     7       <plugin>
     8         <groupId>org.springframework.boot</groupId>
     9         <artifactId>spring-boot-maven-plugin</artifactId>
    10         <version>1.5.6.RELEASE</version>
    11         <configuration>
    12           <excludeGroupIds>com.foo</excludeGroupIds>
    13         </configuration>
    14         ...
    15       </plugin>
    16       ...
    17     </plugins>
    18     ...
    19   </build>
    20   ...
    21 </project>

排除属于指定的groupId的所有maven模块  
三、重写manifest

这个插件还可以重写项目的manifest （可运行jar包的MANIFEST.MF），特别是管理Main-Class和Start-Class启动类。如果默认的配置不能满足需求，我们可以在这里做配置。通过插件的layout属性可以确实地控制Main-Class。

1 <build>
     2   ...
     3   <plugins>
     4     ...
     5     <plugin>
     6       <groupId>org.springframework.boot</groupId>
     7       <artifactId>spring-boot-maven-plugin</artifactId>
     8       <version>1.5.7.RELEASE</version>
     9       <configuration>
    10         <mainClass>${start-class}</mainClass>
    11         <layout>ZIP</layout>
    12       </configuration>
    13       <executions>
    14         <execution>
    15           <goals>
    16             <goal>repackage</goal>
    17           </goals>
    18         </execution>
    19       </executions>
    20     </plugin>
    21     ...
    22   </plugins>
    23   ...
    24 </build>

repackage mainClass

执行打包命令：mvn package spring-boot:repackage。注意：这里不能写成mvn spring-boot:repackage。否则会报Source must refer to an existing file异常。

layout属性默认根据archive type（jar or war）而定。总的有5中类型：

JAR：常规的可执行jar包的布局。
    WAR：可执行war包的布局。
    ZIP（和DIR一样）：和使用PropertiesLauncher的jar包布局一样。
    MODULE:包括依赖包（排除scope为provided的依赖包）和项目资源
    NONE:包括所有的依赖包和项目资源。

四、利用classifier分离代码包和依赖包

当自己写项目需要发布出去给别人依赖时，就只需要自己写的代码打包，依赖的包不能打进来。否则最后别人在用你提供的包时，就会出现重复包，导致最后打包时包会非常巨大。

在这个Spring Boot Maven Plugin这个插件下，我们只需要提供classifier即可实现这个功能。具体如下：

1 <project>
     2   ...
     3   <build>
     4     ...
     5     <plugins>
     6       ...
     7       <plugin>
     8         <groupId>org.springframework.boot</groupId>
     9         <artifactId>spring-boot-maven-plugin</artifactId>
    10         <version>1.5.7.RELEASE</version>
    11         <executions>
    12           <execution>
    13             <goals>
    14               <goal>repackage</goal>
    15             </goals>
    16             <configuration>
    17               <classifier>exec</classifier>
    18             </configuration>
    19           </execution>
    20         </executions>
    21         ...
    22       </plugin>
    23       ...
    24     </plugins>
    25     ...
    26   </build>
    27   ...
    28 </project>

**spring-boot-maven插件的repackage（goal）有如下两个作用：**

**1、在原始Maven打包形成的jar包基础上，进行重新打包，新形成的jar包不但包含应用类文件和配置文件，而且还会包含应用所依赖的jar包以及Springboot启动相关类（loader等），以此来满足Springboot独立应用的特性；  
2、将原始Maven打包的jar重命名为XXX.jar.original作为原始文件；**

打包插件pom：

<build>
            <finalName>${project.artifactId}</finalName>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>2.6.7</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
            <resources>
                <resource>
                    <directory>src/main/resources</directory>
                </resource>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>false</filtering>
                </resource>
            </resources>
        </build>

**注意：  
1：pom中加入repackage打的是可执行的包，MANIFEST.MF有启动类，但是可执行的包不能作为依赖引入，引入这样的jar会报错找不到类。报错：com.oceansite.system.config.ShipImoConfig  
2：pom中不加repackage打的是依赖包，不可执行，MANIFEST.MF中没有启动类，但是可以当作依赖jar包引入其他项目中。  
3：打包插件版本应该和springboot版本一致，否则会报版本报错。如果子模块有引入其他模块。直接子模块打包会报错找不到这个依赖（因为会从仓库里去找），需要整个项目一起打包，才能打成功。  
4：若依cloud 项目中，只需要的对应的模块的pom文件中加入打包插件就可以，比如：file，像models模块下就不需要（file是models模块下的子模块），因为只是起到文件夹的作用。而且pom文件的生效是由内而外的，如果本模块下pom没有引入，并在外层pom中找  
5：如果你在没有主类的公共包的pom文件中强行加入repackage，打包时会报错：Unable to find main class**

### spring-boot-maven-plugin的executable配置 ###

将这个配置设置为 true，打包出来的 jar/war 就是 可执行 的

完全可执行 的 jar/war 在文件前面嵌入了个 额外的脚本，这就使得有些命令会执行失败，比如 jar -xf 等。