Spring Boot出了名的把所有依赖打包成单个可执行的fat jar,同时也被广泛应用于微服务。有时候和fat jar不友好的是,反复包括相同的依赖会成为一种资源浪费。

1.介绍

本教程中,我们将研究如何使用spring-boot-thin-launcher项目来将Spring Boot项目瘦身

Spring Boot出了名的把所有依赖打包成单个可执行的Fat JAR,同时也被广泛应用于微服务。有时候和Fat JAR不一致的是,反复包括相同的依赖会成为一种资源浪费。

2.先决条件

首先,我们当然需要一个Spring Boot项目。在本文中,我们将研究Maven构建和Gradle构建的最常见配置。

这里是不可能覆盖所有构建系统和相应的配置,但是希望我们能够有常用的构建系统配置以便参考。

2.1 Maven 项目

用Maven 构建一个Spring Boot 项目,我们首先要在pom.xml或者它的parent等任何一个祖先添加Spring Boot的Maven插件:

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>    
</plugin>
1
2
3
4

在这里,我们指的是插件的版本2.0.2.RELEASE,这是编写本文时的最新版本。Spring Boot所用的依赖版本通常是用BOM或者从父的POM继承的了:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
    <relativePath/>
</parent>
1
2
3
4
5
6

2.2 Gradle 项目

用Gradle构建Spring Boot项目,我们会有相应的Gradle插件

buildscript {
    ext {
        springBootPlugin = 'org.springframework.boot:spring-boot-gradle-plugin'
        springBootVersion = '2.0.1.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("${springBootPlugin}:${springBootVersion}")
    }
} 
// elided
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
springBoot {
    mainClassName = 'DemoApplication'
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

请注意,本文只考虑Spring Boot 2.x或者更高的版本,Thin Launcher也支持旧的版本,但是可能有稍微不同的版本,具体请查看项目的主页。

3.怎么创建一个Thin Jar

Spring Boot Thin Launcher是一个比较小的类库,它从打包的文件中读取项目工程的依赖关系,然后从maven仓库下载这些依赖,最后启动应用程序。所以在第一次启动下载相应依赖的时候会消耗一定的时间。

所以,当我们用库构建一个项目时,我们会得到一个包含代码的JAR文件,一个包含依赖关系的文件,以及执行入口的主类。

当然,事情会比我们简单的解析微妙得多,本文下面会继续探讨。

4.基本用法

现在让我们看下如何构建一个thin jar的Spring Boot 项目。

我们将使用通常的java -jar 启动应用程序,并使用可选的附加命令行参数来控制 Thin Launcher。

我们将在以下部分中看到其中使用参数的几个例子; 该项目的主页包含完整参数列表。

4.1 Maven 项目

在Maven项目中,我们必须修改SpringBoot的插件,添加相应的依赖:

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <dependencies>
        <!-- The following enables the "thin jar" deployment option. -->
        <dependency>
            <groupId>org.springframework.boot.experimental</groupId>
            <artifactId>spring-boot-thin-layout</artifactId>
            <version>1.0.11.RELEASE</version>
        </dependency>
    </dependencies>
</plugin>
1
2
3
4
5
6
7
8
9
10
11
12

Thin Launcher将会从Maven存储在JAR下的META-INF/maven`目录中生成的pom.xml文件读取依赖关系。

我们像往常一样执行构建就行,例如使用 mvn install

如果我们需要同时打包fat jarthin jar,我们可以在maven的profile中定义springboot插件。

4.2 Maven依赖:thin.properties

除了pom.xml之外,我们也可以让maven生产thin.properties。在这种情况下,该文件会包含完整的依赖列表,包括可传递的依赖列表,但是相对pom.xml来说,thin Launcher对thin.properties更加友好。

默认情况下,插件在src/main/resources/META-INF中输出thin.properties,但是我们可以用thin.output属性来指定它的位置:

mvn org.springframework.boot.experimental:spring-boot-thin-maven-plugin:properties -Dthin.output=.
1

4.3 Gradle项目

不同的是,在Gradle项目中,我们需要添加了一个专用的插件:

buildscript {
    ext {
        //...
        thinPlugin = 'org.springframework.boot.experimental:spring-boot-thin-gradle-plugin'
        thinVersion = '1.0.11.RELEASE'
    }
    //...
    dependencies {
        //...
        classpath("${thinPlugin}:${thinVersion}")
    }
}
//elided
apply plugin: 'maven'
apply plugin: 'org.springframework.boot.experimental.thin-launcher'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

为了获取thin jar, 我们需要执行 thinJar 任务:

./gradlew thinJar
1

4.4 Graldle依赖:pom.xml

在前一小节的代码示例中,除了Thin Launcher之外,我们还声明了Maven插件(我们已经事先看到Spring Boot的依赖管理插件)

这是因为和我们之前的Maven案例一样,打包后的文件包含了一个pom.xml来列举应用程序所需要的依赖关系。pom.xml文件是由thinPom任务生成。

我们可以用专门的一个任务来定制生成pom.xml, 在这里,我们复制下插件已经做的东西:

task createPom {
    def basePath = 'build/resources/main/META-INF/maven'
    doLast {
        pom {
            withXml(dependencyManagement.pomConfigurer)
        }.writeTo("${basePath}/${project.group}/${project.name}/pom.xml")
    }
}
1
2
3
4
5
6
7
8

为了使用我们的自定义pom.xml文件,我们将上述任务添加到jar任务的依赖项中:

bootJar.dependsOn = [createPom]
1

4.5 Gralde依赖:thin.properties

和前面的maven项目已于,我们也可以让Gradle生成thin.properties而不是pom.xml, 生成thin.properties文件的任务叫做thinProperties,默认情况下是不使用它的。我们也可以把它添加到任务的依赖中:

bootJar.dependsOn = [thinProperties]
1

5.保存依赖

thin jar的目的是为了避免依赖项和应用程序绑在一起,然后依赖是不会消失的,这些依赖只是存储在其他地方而已。

特别地,Thin Launcher是使用maven的基础架构来解决依赖的,所以:

  • 会检查本地的Maven仓库,默认是指 ~/.m2/repository,当然也可以移到其他地方。
  • 会从maven中央仓库中下载缺失的依赖
  • 最后会缓存所下载的依赖到本地maven仓库中,下次启动的时候就不会再继续下载了。

当然,下载依赖阶段是比较缓慢而且容易出错的部分,主要是因为是通过网络访问maven中央仓库来下载依赖,总之这些是不可靠的。

幸运的是,有很多种方式将依赖和应用程序一起部署,例如可以预打包在容器中。

5.1 运行预热的程序

缓存依赖的最简单方法就是在目标环境中对程序进行预热运行。正如前面所说的,预热运行会把所依赖的文件缓存到本地的maven仓库中去。如果我们运行了多个应用程序,maven仓库中已经饱和了所依赖的库的话,就没有必要重复下载了。

由于运行应用程序可能会导致不必要的副作用,我们还可以执行“试运行”,它只解析和下载依赖项,而不运行任何用户代码:

java -Dthin.dryrun=true -jar my-app-1.0.jar
1

5.2 在构建的时候打包依赖

另外一个选择就是在构建的时候打包依赖,当然,这不是把依赖打包到JAR中,然后我们可以复制这些依赖到目标的环境中。

通常这会更加简单,因为没必要在目标环境中运行应用程序。但是,如果我们部署多个环境,就必须手动或用脚本合并他们的依赖关系。

在构建过程中,Maven和Gradle的Thin 插件打包的依赖格式与maven的本地仓库是一样的:

root/
    repository/
        com/
        net/
        org/
        ...
1
2
3
4
5
6

实际上,我们还可以在运行的时候使用 thin.root参数来指定依赖的目录:

$ java -jar my-app-1.0.jar --thin.root=my-app/deps
1

5.3 用maven打包依赖

为了能让maven帮我们打包依赖,我们需要添加 spring-boot-thin-maven插件

<plugin>
    <groupId>org.springframework.boot.experimental</groupId>
    <artifactId>spring-boot-thin-maven-plugin</artifactId>
    <version>${thin.version}</version>
    <executions>
        <execution>
        <!-- Download the dependencies at build time -->
        <id>resolve</id>
        <goals>
            <goal>resolve</goal>
        </goals>
        <inherited>false</inherited>
        </execution>
    </executions>
</plugin>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

构建项目后,我们将找到一个目录target/thin/root/会出现上一节讨论的结构。

5.4 用Gradle打包依赖

如我们用thin-launcher插件,我们会有thinResolve任务可以用。这个任务会保存应用和它的依赖在build/thin/root/ 目录中,跟maven的一样:

gradlew thinResolve
1

6.总结和进一步阅读

在这篇文章中,我们学习了如何制作Spring Boot的thin jar,同时也看到了如何使用maven的架构来下载和存储应用的依赖关系。

项目主页 也有一些其他的使用指导,好比如一些命令参数等。