所有文章 分类 标签 笔记 文档 关于 简体中文

目录

SpringCloud/SpringBoot分离依赖打包

KKKPSJKEY 收录于 Back 笔记
   约 5782 字   预计阅读 12 分钟    次阅读  
/springserver-maven-exclude-lib-note/featured-image.jpg

需求

由于公司Gitlab服务器和部署服务器之间似乎无法内网访问，找了IT部门好几次没有什么结果。但是紧急的需求增加或者变更需要使用公司提供连接方式手动上传jar包，一个jar包有个几十到几百M不等，重新部署一次各个微服务需要很久时间。于是项目组下定决心搭一下CI/CD，我由于学校有事情，就远程完成开发。技术组长就将这个不是那么着急的事情给我了，并提了一个开头的需求，及分离jar包中的依赖部分。因为依赖部分所占内存很大，并且更新并不会很频繁，于是打算“懒更新”。

说做就做，技术组长提供的技术参考是Maven下的assembly插件，于是开始学习插件。

打包步骤

完事开头难，其实也还行。查阅相关资料，网上关于SpringCloud和assembly二者的笔记寥寥无几。于是转战单独assembly插件研究和SpringBoot和assembly插件组合的研究，毕竟每个微服务其实还是SpringBoot。跟据相关的笔记自己创建了一个SpringBoot项目进行测试(Assembly官方文档)

Pom

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

<plugins>
    <!--            <plugin>-->
    <!--                <groupId>org.springframework.boot</groupId>-->
    <!--                <artifactId>spring-boot-maven-plugin</artifactId>-->
    <!--            </plugin>-->
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <configuration>
            <archive>
                <manifest>
                    <!-- 项目启动类，这里需要替换成启动类 -->
                    <mainClass>cn.edu.hubu.lhy.assembly_test.AssemblyTestApplication</mainClass>
                    <!-- 依赖的jar的目录前缀 -->
                    <classpathPrefix>../lib</classpathPrefix>
                    <addClasspath>true</addClasspath>
                </manifest>
            </archive>
            <excludes>
                <exclude>assembly.xml</exclude>
                <exclude>application.properties</exclude>
                <exclude>application.yml</exclude>
            </excludes>
        </configuration>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
            <appendAssemblyId>true</appendAssemblyId>
            <descriptors>
                <descriptor>src/main/resources/assembly.xml</descriptor>
            </descriptors>
        </configuration>
        <executions>
            <!-- 配置执行器 -->
            <execution>
                <id>make-assembly</id>
                <!-- 绑定到 package 生命周期阶段上 -->
                <phase>package</phase>
                <goals>
                    <!-- 只运行一次 -->
                    <goal>single</goal>
                </goals>
                <configuration>
                    <finalName>skywalking</finalName>
                    <descriptors>
                        <!-- 配置描述文件路径 -->
                        <descriptor>src/main/resources/assembly.xml</descriptor>
                    </descriptors>
                </configuration>
            </execution>
        </executions>
    </plugin>
</plugins>
<!-- 以下是多环境中的配置 -->
<profiles>
    <profile>
        <id>local</id>
        <properties>
            <env>local</env>
        </properties>
        <!-- 如果不指定ID，默认是本地环境-->
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
    <profile>
        <id>test</id>
        <properties>
            <env>test</env>
        </properties>
    </profile>
    <profile>
        <id>product</id>
        <properties>
            <env>product</env>
        </properties>
    </profile>
</profiles>

assembly配置文件

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

<?xml version="1.0" encoding="UTF-8"?>
<assembly>
    <!-- 可自定义-->
    <id>assembly-${project.version}</id>

    <!-- 打包的类型，如果有N个，将会打N个类型的包 -->
    <formats>
        <format>zip</format>
        <!-- <format>tar.gz</format> -->
    </formats>
    <!-- tar.gz 压缩包下是否生成和项目名相同的根目录，有需要请设置成 true -->
    <includeBaseDirectory>false</includeBaseDirectory>
    <!-- 将依赖jar打包到lib文件夹中 -->
    <dependencySets>
        <dependencySet>
            <!-- 是否把本项目添加到依赖文件夹下，有需要请设置成 true -->
            <useProjectArtifact>false</useProjectArtifact>
            <outputDirectory>lib</outputDirectory>
            <!-- 将 scope 为 runtime 的依赖包打包 -->
            <scope>runtime</scope>
            <excludes>
                <exclude>${groupId}:${artifactId}</exclude>
            </excludes>
        </dependencySet>
        <!--        也可以配置在下面-->
        <!--        <fileSets>-->
        <!--            <fileSet>-->
        <!--                &lt;!&ndash; 设置需要打包的文件路径 &ndash;&gt;-->
        <!--                <directory>agent</directory>-->
        <!--                &lt;!&ndash; 打包后的输出路径 &ndash;&gt;-->
        <!--                <outputDirectory></outputDirectory>-->
        <!--            </fileSet>-->
        <!--        </fileSets>-->
    </dependencySets>

    <fileSets>
        <!-- 0755->即用户具有读/写/执行权限，组用户和其它用户具有读写权限； 0644->即用户具有读写权限，组用户和其它用户具有只读权限； -->
        <!-- 将src/bin目录下的所有文件输出到打包后的bin目录中 -->
        <fileSet>
            <directory>${basedir}/bin</directory>
            <outputDirectory>bin</outputDirectory>
            <fileMode>0755</fileMode>
            <includes>
                <include>**.sh</include>
                <include>**.bat</include>
            </includes>
        </fileSet>

        <!-- 指定输出target/classes中的配置文件到config目录中 -->
        <fileSet>
            <directory>${basedir}/target/classes</directory>
            <outputDirectory>bin</outputDirectory>
            <fileMode>0644</fileMode>
            <includes>
                <include>application.properties</include>
                <include>application.yml</include>
            </includes>
        </fileSet>

        <!-- 将第三方依赖打包到lib目录中 -->
        <fileSet>
            <directory>${basedir}/target/lib</directory>
            <outputDirectory>lib</outputDirectory>
            <fileMode>0755</fileMode>
        </fileSet>

        <!-- 将项目启动jar打包到bin目录中 -->
        <fileSet>
            <directory>${basedir}/target</directory>
            <outputDirectory>bin</outputDirectory>
            <fileMode>0755</fileMode>
            <includes>
                <include>${project.build.finalName}.jar</include>
            </includes>
        </fileSet>

        <!-- 包含根目录下的文件 -->
        <!--        <fileSet>-->
        <!--            <directory>${basedir}</directory>-->
        <!--            <includes>-->
        <!--                <include>NOTICE</include>-->
        <!--                <include>LICENSE</include>-->
        <!--                <include>*.md</include>-->
        <!--            </includes>-->
        <!--        </fileSet>-->
        <!-- 以下是多环境中的配置 -->
        <!--需要包含的文件与输出的路径-->
        <fileSet>
            <directory>src/main/bin</directory>
            <outputDirectory>bin/</outputDirectory>
        </fileSet>
        <fileSet>
            <directory>src/main/resources</directory>
            <outputDirectory>/</outputDirectory>
            <!-- 去除需要多环境配置的文件-->
            <excludes>
                <exclude>application.properties</exclude>
            </excludes>
        </fileSet>
        <!--多环境配置-->
        <fileSet>
            <!--${env} 可以获取打包命令里的参数-->
            <directory>src/main/resources/env/${env}/</directory>
            <outputDirectory>/</outputDirectory>
        </fileSet>
        <fileSet>
            <directory>${project.build.directory}</directory>
            <outputDirectory>/</outputDirectory>
            <includes>
                <include>*.jar</include>
            </includes>
        </fileSet>
    </fileSets>
</assembly>

跑完的结果

./1.jpg

和项目组长交流后，需求变更。。。

需要将所有微服务的lib包放置到一个外部文件夹，并将jar包单独放置，个人见解，assembly是一个能将jar包各种自定义的插件，而我们的需求比较简单，并且spring-boot-maven-plugin插件可以将lib排除于是转换思路，放弃assembly插件，修改原来的spring-boot-maven-plugin为排除lib依赖，并使用maven-dependency-plugin插件将lib库重定向，就很好的解决了问题。（spring-boot-maven-plugin这个插件的笔记点我）

SpringCloud父工程Pom或者SpringBoot同一个Pom:

上面可以指定输出路径，指定的好处是多个微服务、多个插件都可以使用

下面是使用${project.parent.basedir}属性获得父目录路径，最终打包在项目根目录的target中。但是由于maven插件的生命周期原因，传递给子模块basedir属性为子模块属性，类似懒加载，传递至子目录才读取值，故需要添加parent，且忽略编译异常。此属性禁止在父POM工程中使用，仅允许传递给子模块使用。

1
2
3
4
5
6

<jar.target>D:/tmp/target</jar.target>

<!--suppress UnresolvedMavenProperty -->
<jar.target>${project.parent.basedir}/target/</jar.parent.target>
<!--suppress UnresolvedMavenProperty -->
<jar.target1>${project.parent.parent.basedir}/target/</jar.parent2.target>

子工程Pom:

打可直接运行的Jar包

spring boot repackage，依赖 maven-jar-plugin 打包的jar包 重新打包成 spring boot 的jar包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

 <plugin>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-maven-plugin</artifactId>
     <configuration>
         <executable>true</executable>
         <!-- 指定项目启动类 -->
         <mainClass>cn.edu.hubu.lhy.assembly_test.AssemblyTestApplication</mainClass>
         <layout>ZIP</layout>
         <!--使用外部配置文件，jar包里没有资源文件-->
         <!--<addResources>true</addResources>-->
         <!--重写包含依赖，包含不存在的依赖，jar里没有pom里的依赖-->
         <!-- 加了这个includes就可以排除第三方依赖 -->
         <!-- 也此处可以指定包含jar包 -->
         <includes>
             <include>
                 <!-- 可以null，也可以non-exists，或者nothing -->
                 <groupId>null</groupId>
                 <artifactId>null</artifactId>
             </include>
         </includes>
         <!--或者填写groupId、artifactId，只包含自己-->
         <!-- <include> -->
         <!--     <groupId>${groupId}</groupId> -->
         <!--     <artifactId>${artifactId}</artifactId> -->
         <!-- </include> -->
         <!--不包含哪些-->
         <!--<excludeGroupIds>-->
         <!--com.hundsun.jrescloud,-->
         <!--org.springframework.boot,-->
         <!--org.springframework-->
         <!--</excludeGroupIds>-->
         <!-- 包含根目录下的文件 -->
         <outputDirectory>${jar.target}</outputDirectory>
     </configuration>
     <executions>
         <execution>
             <!-- repackage的目的是将jar包重新打包为能直接运行的jar包，原来的编译连接为代码class文件的包被命名*.jar.original -->
             <!--配置jar包特殊标识 配置后，保留原文件，生成新文件 *-run.jar -->
             <!--配置jar包特殊标识 不配置，原文件命名为 *.jar.original，生成新文件 *.jar -->
             <!--<classifier>run</classifier>-->
             <goals>
                 <goal>repackage</goal>
             </goals>
         </execution>
     </executions>
</plugin>

也可以用maven-jar-plugin插件替换spring-boot-maven-plugin进行打包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

<resources>
    <!-- Resource Filter -->
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.xml</include>
        </includes>
    </resource>
    <!--指定资源的位置-->
    <resource>
        <directory>src/main/resources</directory>
    </resource>
    <!--无法分离的jar包如果jar包不大可以选择直接打入源码jar包-->
    <!--<resource>
        &lt;!&ndash;jar包路径&ndash;&gt;
        <directory>${project.basedir}/libs</directory>
        <targetPath>BOOT-INF/lib/</targetPath>
        <includes>
            <include>**/*.jar</include>
        </includes>
    </resource>-->
</resources>
<plugins>
    <!--打包jar-->
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <configuration>
            <!--不打包资源文件-->
            <excludes>
                <exclude>*.**</exclude>
            </excludes>
            <archive>
                <manifest>
                    <addClasspath>true</addClasspath>
                    <!--MANIFEST.MF 中 Class-Path 加入前缀-->
                    <classpathPrefix>lib/</classpathPrefix>
                    <!--jar包不包含唯一版本标识-->
                    <useUniqueVersions>false</useUniqueVersions>
                    <!--指定入口类-->
                    <mainClass>com.seawater.mybatisPlus.MybatisPlusApplication.java</mainClass>
                </manifest>
                <!--不打包资源文件-->
                <manifestEntries>
                    <!--MANIFEST.MF 中 Class-Path 加入资源文件目录-->
                    <!--本地依赖包需要手动 加入Class-Path ，否则无法找到-->
                    <Class-Path>./resources/</Class-Path>
                </manifestEntries>
            </archive>
            <excludes>
                <exclude>*/*.xml</exclude>
                <exclude>*/*/*.xml</exclude>
            </excludes>
            <outputDirectory>${project.build.directory}</outputDirectory>
        </configuration>
    </plugin>

拷贝第三方依赖文件到指定目录

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

    <!--拷贝依赖 copy-dependencies-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <!--target/lib是依赖jar包的输出目录-->
                <outputDirectory>D:/workspace/demo-service/target/lib</outputDirectory>
                <!--<excludeTransitive>false</excludeTransitive>
                <stripVersion>false</stripVersion>
                <includeScope>compile</includeScope>-->
                <resources>
                    <resource>
                        <!-- 文件地址 -->
                        <directory>${basedir}/src/main/docker</directory>
                        <includes>
                            <include>*</include>
                        </includes>
                    </resource>
                </resources>
            </configuration>
        </execution>
    </executions>
    <configuration>
        <!-- 本地Jar包不进行分离,不输出到outputDirectory -->
        <excludeGroupIds>cn.edu.hubu.lhy.assembly_test.AssemblyTestApplication</excludeGroupIds>
    </configuration>
</plugin>

拷贝资源文件（可选）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

<!--拷贝资源文件 copy-resources-->
<plugin>
    <artifactId>maven-resources-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-resources</id>
            <phase>package</phase>
            <goals>
                <goal>copy-resources</goal>
            </goals>
            <configuration>
                <resources>
                    <resource>
                        <directory>src/main/resources</directory>
                    </resource>
                </resources>
                <outputDirectory>${project.build.directory}/resources</outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

启动指令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Windows平台
## -Dloader.path
### 绝对路径
java -Dloader.path=D:/tmp/target/libs -jar xxx.jar
### 相对路径
java -Dloader.path=libs -jar xxx.jar

# Windows平台
## -Djava.ext.dirs
### 绝对路径
java -Djava.ext.dirs=D:/tmp/target/libs -jar xxx.jar
### 相对路径
java -Djava.ext.dirs=libs -jar xxx.jar

# Linux平台 TODO

注意：spring-boot-maven-plugin下没有这句话，经测试无法使用-Dloader.path指定外部依赖进行运行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<!--拷贝资源文件 copy-resources-->
<plugin>
    <artifactId>maven-resources-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-resources</id>
            <phase>package</phase>
            <goals>
                <goal>copy-resources</goal>
            </goals>
            <configuration>
                <resources>
                    <resource>
                        <directory>src/main/resources</directory>
                    </resource>
                </resources>
                <outputDirectory>${mzservice.path}/config</outputDirectory>
            </configuration>
        </execution>
        <!--copy 脚本，把bin目录下的文件复制到，打包目录下-->
        <execution>
            <id>copy-bin</id>
            <phase>package</phase>
            <goals>
                <goal>copy-resources</goal>
            </goals>
            <configuration>
                <resources>
                    <resource>
                        <directory>bin/</directory>
                    </resource>
                </resources>
                <outputDirectory>${mzservice.path}</outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

一些说明

1、通常，一个工程项目架构确定后，引入的jar包基本上不会变，改变的大部分是业务逻辑；

2、后面如果需要变更业务逻辑，只需要轻量地编译工程，大大提高项目部署的效率。

3、之前都是直接在idea里改好再打包了，所以没有直接引用外部文件过，通过查看SpringBoot官网，得知有下面的几种方法：

1
2
3
4
5
6

24.3 Application Property Files
SpringApplication loads properties from application.properties files in the following locations and adds them to the Spring Environment:
1、A /config subdirectory of the current directory //  大概意思是：放在jar包同级目录下的子目录config
2、The current directory  //大概意思是：放在jar包目录同级
3、A classpath /config package // 大概意思是在classpath下的config目录
4、The classpath root // classpath中

引用的优先级和上面的顺序是一样的。

其中springboot对于配置文件读取中文解释有如下方式：

1、读取jar包同级目录下的config目录中的properties文件，优先级最高； 2、读取jar包同级目录下的properties文件，优先级次之； 3、读取classpath下的config文件夹中的properties文件，优先级第三； 4、在classpath下直接放配置文件，优先级最低。

还有一种是用命令行

1

java -jar bootdemo-0.0.1-SNAPSHOT.jar --spring.config.location=./test.properties //此时test.properties和jar是同级目录

未验证知识

将项目resources下的文件，复制到config下。将bin下的启动脚本复制到打包目录，可根据自己的需求修改。

配置清理插件，每次打包前，清理之前生成的打包目录。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

<plugin>
    <artifactId>maven-clean-plugin</artifactId>
    <version>2.5</version>
    <executions>
        <execution>
            <id>auto-clean</id>
            <phase>initialize</phase>
            <goals>
                <goal>clean</goal>
            </goals>
            <configuration>
                <skip>false</skip>
                <filesets>
                    <fileset>
                        <directory>${mzservice.path}</directory>
                    </fileset>
                </filesets>
            </configuration>
        </execution>
    </executions>
</plugin>

跳过测试

1
2
3
4
5
6
7
8

<!--maven打包时，跳过测试-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <skip>true</skip>
    </configuration>
</plugin>

其它说明

网上有些其它文章会使用spring-boot-maven-plugin 这个插件打包项目jar，个人觉得这个插件是对其它插件的一些封装，打包的jar会包含spring boot的一些东西,测试之后觉得和maven-jar-plugin打包的jar，使用上没什么区别。

启动时省略-Dloader.path

另外一种启动方案是可以不加-Dloader.path=“D:develop/shared/fjar"来指定路径，直接使用如下指令启动

1

java -jar mytest.jar

使用上述启动的话需要添加maven-jar-plugin插件，配置<classpathPrefix>属性，另外在处理一些读取可执行jar中的文件时，可以使用maven-jar-plugin插件替换spring-boot-maven-plugin进行打包操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <!--addClasspath表示需要加入到类构建路径-->
                <addClasspath>true</addClasspath>
                <!--classpathPrefix指定生成的Manifest文件中Class-Path依赖lib前面都加上路径,构建出lib/xx.jar-->
                <classpathPrefix>lib/</classpathPrefix>
                <mainClass>com.common.util.CommonUtilsApplication</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

上述插件效果就是在打成的包里META_INF目录下的MANIFEST.MF文件里增加Class-path对应jar,这样在后面应用刚启动时就会根据Class-Path的只去加载需要的版本依赖（解决在共享目录里存在多版本加载引用冲突问题），这个效果就等效加参数-classpath xxx（具体的jar）。此时就是将需要的jar目录lib放在和要运行的xxx.jar同级目录即可，启动时就可以不加-Dloader.path参数了，如果lib目录和要运行的xxx.jar不在同级目录的话，则需要使用-Dloader.path来启动

./2.png

如下：在同一级目录启动

./3.png

不在同一级目录启动：

./4.png

其中**-Dloader.path可以指定多个目录**，这样在存在多个微服务情况下可将一些公共用到的jar放在一个共享目录中，每个微服务独有的jar可以放在微服务私有的目录下（解决jar版本冲突问题）,示例如下：

./5.png

注意：

1、使用-Dloader.path需要在打包的时候增加<layout>ZIP</layout>，不指定的话-Dloader.path不生效。对于多个微服务瘦身打包建议使用maven-jar-plugin打包，避免因为spring-boot-maven-plugin打包机制导致的一些应用启动问题（已踩坑）

2、若存在不同版本依赖：比如项目A依赖Y库的1.0版本，项目B依赖Y库的2.0版本，那么可能会出现版本依赖冲突（两个版本不兼容的情况下），解决方案：

　　2.1、能做到版本一致就保持使用同一个版本，保证版本一致。可以使用maven的版本依赖管理进行处理，即在父pom文件使用<dependencyManagement>统一管理依赖版本

　　2.2、让项目各自依赖所需的版本并打进war包中，把其他同版本的jar包放在同一个共享包下

测试发现依赖在查找时从上往下找，匹配到就用第一个，如下图会使用comm-0.0.1.jar版本的

./6.png

附注：

使用spring-boot-maven-plugin插件，会将依赖的jar包全部打包进去，这样就可以直接运行生成的 JAR 包，简化了我们开发操作。

使用spring-boot-maven-plugin插件如果不指定程序主运行入口类的话默认为Main-Class: org.springframework.boot.loader.JarLauncher

./7.png

这个可以自定义执行主入口类，有以下几种方式：

1.POM继承spring-boot-starter-parent

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
<properties>
        <!-- The main class to start by executing java -jar -->
        <start-class>ccom.notes.JavaNotesApplication</start-class>
</properties>

2.POM不是继承spring-boot-starter-parent时需指定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>2.1.9.RELEASE</version>
    <configuration>
        <mainClass>com.notes.JavaNotesApplication</mainClass>
        <layout>ZIP</layout>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal>
            </goals>
        </execution>
    </executions>
</plugin>

3.POM不是继承spring-boot-starter-paren，且使用maven-jar-plugin插件来指定执行的类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
    <archive>
        <manifest>
            <addClasspath>true</addClasspath>
            <useUniqueVersions>false</useUniqueVersions>
            <classpathPrefix>lib/</classpathPrefix>
            <mainClass>com.notes.JavaNotesApplication</mainClass>
        </manifest>
        <manifestEntries>
            <version>${project.version}</version>
        </manifestEntries>
    </archive>
</configuration>
</plugin>
更新于 2021-10-26
阅读原始文档
 Maven, SpringCloud, SpringBoot
返回 | 主页