JAVA Spring Boot JAR 启动慢？Layered JAR 与 classpath 优化方法

JAVA Spring Boot JAR 启动慢？Layered JAR 与 classpath 优化方法

大家好，今天我们来聊聊Spring Boot JAR启动慢的问题，以及如何利用Layered JAR和Classpath优化来解决这个问题。Spring Boot以其快速开发和便捷部署的特性深受开发者喜爱，但随着项目规模的增大，启动速度慢往往成为一个痛点。希望通过今天的分享，大家能够掌握一些实用的技巧，提升Spring Boot应用的启动效率。

为什么Spring Boot JAR启动会慢？

在深入优化之前，我们需要先了解导致启动慢的几个常见原因：

1. 庞大的依赖关系: Spring Boot项目通常依赖大量的第三方库，这些库都需要在启动时加载和初始化。
2. Classpath扫描: Spring Boot需要扫描Classpath下的所有类，以找到需要自动配置的Bean、组件和服务等。
3. 自动配置: Spring Boot的自动配置机制虽然方便，但也会带来额外的启动开销，因为它需要分析和应用大量的配置。
4. 数据库连接: 数据库连接的建立和初始化也需要时间，特别是当数据库服务器负载较高时。
5. JVM预热: JVM需要时间来预热，才能达到最佳的运行状态。
6. 大型静态资源: 如果你的JAR包包含大量的静态资源（例如图片、CSS、JavaScript文件），这些资源也会增加JAR包的大小，进而影响启动速度。

Layered JAR: 解决依赖变化频率差异

Layered JAR是一种将Spring Boot JAR文件分解成多个层，并允许Docker等容器只更新发生变化的层的优化技术。 核心思想是: 将JAR包中变化频率不同的内容进行分层，这样每次修改代码后，只需要重新构建发生变化的层，减少了整体镜像的大小，也加快了启动速度。

不使用Layered JAR的问题:

默认情况下，Spring Boot构建的JAR文件是一个单一的可执行文件。 每次修改代码后，都需要重新构建整个JAR文件，并重新部署。即使只修改了一行代码，也需要上传整个JAR文件到服务器，浪费带宽和时间。

Layered JAR的优势:

• 增量更新: 只更新发生变化的层，减少镜像大小和部署时间。
• 更快的启动速度: 容器可以更快地加载和启动应用。
• 更高效的资源利用: 减少了磁盘空间和带宽的占用。

如何使用Layered JAR:

Spring Boot 2.3及以上版本原生支持Layered JAR。只需要在 pom.xml 或 build.gradle 中进行简单配置。

Maven 配置 (pom.xml):

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <layers>
                    <enabled>true</enabled>
                </layers>
            </configuration>
        </plugin>
    </plugins>
</build>

Gradle 配置 (build.gradle):

plugins {
    id 'org.springframework.boot' version 'your-spring-boot-version'
    id 'io.spring.dependency-management' version 'your-dependency-management-version'
    id 'java'
}

springBoot {
    buildInfo()
    layered()
}

添加上述配置后，重新构建项目，生成的JAR文件将会包含一个 layers.idx 文件，该文件描述了JAR文件的分层结构。

Layered JAR 结构:

默认情况下，Layered JAR会将JAR文件分成以下几个层：

1. dependencies: 包含第三方依赖库。
2. spring-boot-loader: 包含Spring Boot Loader类。
3. snapshot-dependencies: 包含SNAPSHOT版本的依赖库。
4. application: 包含应用程序代码（例如Controller、Service等）。

定制 Layered JAR:

可以通过 layers.idx 文件定制Layered JAR的分层结构。 可以在 pom.xml 或 build.gradle 中配置 layers 元素来修改默认的分层规则。

Maven 配置 (pom.xml) – 定制 Layered JAR:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <layers>
                    <enabled>true</enabled>
                    <configuration>${project.basedir}/src/layers.xml</configuration>
                </layers>
            </configuration>
        </plugin>
    </plugins>
</build>

创建一个 src/layers.xml 文件，内容如下：

<layers>
    <application>
        <into layer="spring-boot-loader"/>
        <into layer="application"/>
    </application>
    <dependencies>
        <into layer="dependencies"/>
        <into layer="configuration">
            <include>**/application*.yml</include>
            <include>**/application*.properties</include>
        </into>
    </dependencies>
</layers>

这个例子将配置文件(application*.yml 和 application*.properties) 移动到了一个新的 configuration 层。 这样做的好处是，如果只修改了配置文件，只需要更新 configuration 层，而不需要更新 application 层。

Docker 集成:

Layered JAR与Docker的集成非常简单。只需要在 Dockerfile 中按照Layered JAR的分层结构，依次复制各个层到Docker镜像中。

FROM openjdk:17-jdk-slim

ARG JAR_FILE=target/*.jar

# 提取 Layered JAR
COPY ${JAR_FILE} app.jar

# 提取 Layers
RUN java -Djarmode=layertools -jar app.jar extract

# 定义工作目录
WORKDIR /app

# 复制 Layers
COPY layers/dependencies /app/
COPY layers/spring-boot-loader /app/
COPY layers/snapshot-dependencies /app/
COPY layers/application /app/

# 启动应用
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]

这个 Dockerfile 首先提取Layered JAR，然后按照分层结构，依次复制各个层到Docker镜像中。最后，使用 org.springframework.boot.loader.JarLauncher 启动应用。

Layered JAR 的一些注意事项:

• 分层结构需要根据项目的实际情况进行调整。 应该将变化频率高的内容放在单独的层中，以便能够更高效地进行增量更新。
• Layered JAR可能会增加构建的复杂度。 需要仔细规划分层结构，并确保 Dockerfile 正确地复制各个层。
• 并不是所有的项目都适合使用Layered JAR。 对于小型项目，使用Layered JAR可能带来的收益并不明显。

Classpath 优化

Classpath扫描是Spring Boot启动过程中耗时较多的环节之一。 优化Classpath可以显著提升启动速度。

1. 排除不需要的组件扫描:

Spring Boot 默认会扫描所有包含 @SpringBootApplication 注解的类所在的包及其子包。 如果你的项目结构比较复杂，可能会扫描到一些不需要进行组件扫描的类。 可以使用 excludeFilters 属性来排除这些类。

@SpringBootApplication(excludeFilters = {
        @ComponentScan.Filter(type = FilterType.REGEX, pattern = "com.example.unnecessary.*")
})
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

}

这个例子排除了 com.example.unnecessary 包及其子包下的所有类。

2. 使用 Indexable:

Indexable 是 Spring Boot 提供的一个接口，用于优化Classpath扫描。 实现 Indexable 接口的类会被Spring Boot索引，从而避免了全Classpath扫描。

首先，创建一个 META-INF/spring.factories 文件，并添加以下内容：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=
com.example.MyAutoConfiguration

然后，创建一个自动配置类 MyAutoConfiguration，并实现 Indexable 接口：

@Configuration
public class MyAutoConfiguration implements Indexable {

    @Bean
    public MyService myService() {
        return new MyService();
    }

    @Override
    public String getIndexableType() {
        return "com.example.MyService";
    }
}

这个例子将 MyService 类标记为 Indexable，Spring Boot 在启动时会直接索引 MyService 类，而不需要扫描整个Classpath。

3. 使用 spring.autoconfigure.exclude 属性:

可以通过 spring.autoconfigure.exclude 属性来排除不需要的自动配置类。 可以在 application.properties 或 application.yml 文件中配置该属性。

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

这个例子排除了 DataSourceAutoConfiguration 和 HibernateJpaAutoConfiguration 自动配置类。

4. 懒加载 Bean:

对于一些非关键的Bean，可以使用 @Lazy 注解进行懒加载。 懒加载的Bean只会在第一次被使用时才会被初始化，从而减少了启动时的开销。

@Component
@Lazy
public class MyLazyBean {

    public MyLazyBean() {
        System.out.println("MyLazyBean initialized");
    }

}

*5. 避免使用 `` 通配符:**

在 @ComponentScan 注解中，尽量避免使用 * 通配符。 明确指定需要扫描的包，可以减少Classpath扫描的范围。

6. 使用静态资源处理优化:

如果应用包含大量静态资源，可以考虑使用CDN来分发静态资源，或者使用缓存来减少静态资源的加载次数。

其他优化手段

除了Layered JAR和Classpath优化之外，还有一些其他的优化手段可以提升Spring Boot应用的启动速度。

1. JVM 优化:

可以通过调整JVM参数来优化启动速度。 例如，可以使用 -Xms 和 -Xmx 参数来设置JVM的初始堆大小和最大堆大小。 还可以使用 -XX:+UseG1GC 参数来启用G1垃圾回收器。

2. 使用 Profile:

可以使用Spring Boot的Profile功能，将不同的配置分组，并根据不同的环境激活不同的Profile。 这样可以避免加载不需要的配置，从而减少启动时的开销。

3. 异步初始化:

可以将一些耗时的初始化任务放在异步线程中执行，从而避免阻塞主线程。 可以使用 @Async 注解来标记异步方法。

@Service
public class MyService {

    @Async
    public void initializeData() {
        // 耗时的初始化任务
        System.out.println("Initializing data...");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Data initialized");
    }

}

4. 使用代码分析工具:

可以使用代码分析工具（例如JProfiler、YourKit）来分析Spring Boot应用的启动过程，找出性能瓶颈。

5. 数据库连接池优化:

使用高性能的数据库连接池（例如HikariCP），并合理配置连接池参数，可以减少数据库连接的建立和初始化时间。

优化手段总结

优化手段	描述	适用场景
Layered JAR	将JAR文件分解成多个层，允许Docker等容器只更新发生变化的层。	项目需要频繁更新，且部署在Docker容器中。
排除不需要的组件扫描	使用 excludeFilters 属性来排除不需要进行组件扫描的类。	项目结构复杂，包含大量不需要进行组件扫描的类。
使用 Indexable	实现 Indexable 接口的类会被Spring Boot索引，从而避免了全Classpath扫描。	项目中包含大量的自动配置类，且Classpath扫描耗时较长。
使用 spring.autoconfigure.exclude 属性	排除不需要的自动配置类。	项目中不需要某些自动配置功能。
懒加载 Bean	使用 @Lazy 注解进行懒加载。	项目中包含一些非关键的Bean，可以延迟初始化。
避免使用 * 通配符	在 @ComponentScan 注解中，尽量避免使用 * 通配符。	项目中使用了 @ComponentScan 注解，且扫描范围过大。
使用静态资源处理优化	使用CDN或缓存来减少静态资源的加载次数。	项目中包含大量静态资源。
JVM 优化	调整JVM参数来优化启动速度。	所有Spring Boot项目。
使用 Profile	使用Spring Boot的Profile功能，将不同的配置分组。	项目需要在不同的环境中部署，且配置差异较大。
异步初始化	将一些耗时的初始化任务放在异步线程中执行。	项目中包含一些耗时的初始化任务。
使用代码分析工具	使用代码分析工具来分析Spring Boot应用的启动过程，找出性能瓶颈。	所有Spring Boot项目，特别是启动速度较慢的项目。
数据库连接池优化	使用高性能的数据库连接池，并合理配置连接池参数。	项目需要连接数据库。

总结: 选择合适的优化方案

今天我们讨论了Spring Boot JAR启动慢的原因，以及如何利用Layered JAR和Classpath优化来解决这个问题。 Layered JAR 通过分层构建，减少镜像大小和部署时间； Classpath 优化则侧重于减少启动时扫描和加载的类，提高效率。 选择合适的优化方案，并结合实际情况进行调整，才能有效地提升Spring Boot应用的启动速度，优化用户体验。