Spring Boot 启动优化实践

于 2025-07-09 10:22:00 发布
阅读量16 收藏
点赞数
文章标签： spring boot github 后端 java spring

作者：vivo 互联网服务器团队- Liu Di

 

本文系统性分析并优化了一个Spring Boot项目启动耗时高达 280 秒的问题。通过识别瓶颈、优化分库分表加载逻辑、异步初始化耗时任务等手段，最终将启动耗时缩短至 159 秒，提升近 50%。文章涵盖启动流程分析、性能热点识别、异步初始化设计等关键技术细节，适用于大型Spring Boot项目的性能优化参考。

 

文章太长？1分钟看图抓住核心观点👇

图片

 

一、前言

随着业务的发展，笔者项目对应的Spring Boot工程的依赖越来越多。随着依赖数量的增长，Spring 容器需要加载更多组件、解析复杂依赖并执行自动装配，导致项目启动时间显著增长。在日常开发或测试过程中，一旦因为配置变更或者其他热部署不生效的变更时，项目重启就需要等待很长的时间影响代码的交付。加快Spring项目的启动可以更好的投入项目中，提升开发效率。

 

整体环境介绍：

  • Spring版本：4.3.22

  • Spring Boot版本：1.5.19

  • CPU：i5-9500

  • 内存：24GB

  • 优化前启动耗时：280秒

 

二、Spring Boot项目启动流程介绍

Spring Boot项目主要启动流程都在org.spring-

framework.boot.SpringApplication#run(java.lang.String...)方法中：

 

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    // Spring上下文
    ConfigurableApplicationContext context = null;
    FailureAnalyzers analyzers = null;
    configureHeadlessProperty();
    // 初始化SpringApplicationRunListener监听器
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                args);
        // 环境准备
        ConfigurableEnvironment environment = prepareEnvironment(listeners,
                applicationArguments);
         // 打印banner
        Banner printedBanner = printBanner(environment);
        // 创建上下文
        context = createApplicationContext();
        analyzers = new FailureAnalyzers(context);
        // 容器初始化
        prepareContext(context, environment, listeners, applicationArguments,
                printedBanner);
        // 刷新容器内容
        refreshContext(context);
        afterRefresh(context, applicationArguments);
        // 结束监听广播
        listeners.finished(context, null);
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass)
                    .logStarted(getApplicationLog(), stopWatch);
        }
        return context;
    } catch (Throwable ex) {
        handleRunFailure(context, listeners, analyzers, ex);
        throw new IllegalStateException(ex);
    }
}

可以看到在启动流程中，监听器应用在了应用的多个生命周期中。并且Spring Boot中也预留了针对listener的扩展点。我们可以借此实现一个自己的扩展点去监听Spring Boot的每个阶段的启动耗时，实现如下：

@Slf4j
public class MySpringApplicationRunListener implements SpringApplicationRunListener{
    private Long startTime;
    public MySpringApplicationRunListener(SpringApplication application, String[] args){
    }
    @Override
    public void starting(){
        startTime = System.currentTimeMillis();
        log.info("MySpringListener启动开始 {}", LocalTime.now());
    }
    @Override
    public void environmentPrepared(ConfigurableEnvironment environment){
        log.info("MySpringListener环境准备 准备耗时：{}毫秒", (System.currentTimeMillis() - startTime));
        startTime = System.currentTimeMillis();
    }
    @Override
    public void contextPrepared(ConfigurableApplicationContext context){
        log.info("MySpringListener上下文准备 耗时：{}毫秒", (System.currentTimeMillis() - startTime));
        startTime = System.currentTimeMillis();
    }
    @Override
    public void contextLoaded(ConfigurableApplicationContext context){
        log.info("MySpringListener上下文载入 耗时：{}毫秒", (System.currentTimeMillis() - startTime));
        startTime = System.currentTimeMillis();
    }
   @Override
   public void finished(ConfigurableApplicationContext context, Throwable exception){
        log.info("MySpringListener结束 耗时：{}毫秒", (System.currentTimeMillis() - startTime));
        startTime = System.currentTimeMillis();
    }
}

接着还需要在classpath/META-INF目录下新建spring.factories文件，并添加如下文件内容：

org.springframework.boot.SpringApplicationRunListener=com.vivo.internet.gameactivity.api.web.MySpringApplicationRunListener

至此，借助Listener机制，我们能够追踪Spring Boot启动各阶段的耗时分布，为后续性能优化提供数据支撑。

图片

 

contextLoaded事件是在run方法中的prepareContext()结束时调用的，因此contextLoaded事件和finished事件之间仅存在两个语句：refreshContext(context)和afterRefresh

(context,applicationArguements)消耗了285秒的时间，调试一下就能发现主要耗时在refreshContext()中。

 

三、AbstractApplicationContext#refresh

refreshContext()最终调用到org.spring-framework.context.support.AbstractApplicationContext#refresh方法中，这个方法主要是beanFactory的预准备、对beanFactory完成创建并进行后置处理、向容器添加bean并且给bean添加属性、实例化所有bean。通过调试发现，finishBeanFactoryInitialization(beanFactory) 方法耗时最久。该方法负责实例化容器中所有的单例 Bean，是启动性能的关键影响点。

 

四、找出实例化耗时的Bean

Spring Boot也是利用的Spring的加载流程。在Spring中可以实现InstantiationAwareBeanPost-

Processor接口去在Bean的实例化和初始化的过程中加入扩展点。因此我们可以实现该接口并添加自己的扩展点找到处理耗时的Bean。

 

@Service
public class TimeCostCalBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    private Map<String, Long> costMap = Maps.newConcurrentMap();

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (!costMap.containsKey(beanName)) {
            costMap.put(beanName, System.currentTimeMillis());
        }
        return null;
    }
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return pvs;
    }
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
         if (costMap.containsKey(beanName)) {
            Long start = costMap.get(beanName);
            long cost = System.currentTimeMillis() - start;
            // 只打印耗时长的bean
             if (cost > 5000) {
                System.out.println("bean: " + beanName + "\ttime: " + cost + "ms");
            }
        }
         return bean;
    }
}

具体原理就是在Bean开始实例化之前记录时间，在Bean初始化完成后记录结束时间，打印实例化到初始化的时间差获得Bean的加载总体耗时。结果如图：

图片

 

可以看到有许多耗时在10秒以上的类，接下来可以针对性的做优化。值得注意的是，统计方式为单点耗时计算，未考虑依赖链上下文对整体加载顺序的影响，实际优化还需结合依赖关系分析。

 

五、singletonDataSource

 

@Bean(name = "singletonDataSource")
public DataSource singletonDataSource(DefaultDataSourceWrapper dataSourceWrapper) throws SQLException {
    //先初始化连接
    dataSourceWrapper.getMaster().init();
    //构建分库分表数据源
    String dataSource0 = "ds0";
    Map<String, DataSource> dataSourceMap = new HashMap<>();
    dataSourceMap.put(dataSource0, dataSourceWrapper.getMaster());
    //分库分表数据源
    DataSource shardingDataSource = ShardingDataSourceFactory.createDataSource
    (dataSourceMap,shardingRuleConfiguration, prop);
    return shardingDataSource;    
    }

singletonDataSource是一个分库分表的数据源，连接池采用的是Druid，分库分表组件采用的是公司内部优化后的中间件。通过简单调试代码发现，整个Bean耗时的过程发生在createDataSource方法，该方法中会调用createMetaData方法去获取数据表的元数据，最终运行到loadDefaultTables方法。该方法如下图，会遍历数据库中所有的表。因此数据库中表越多，整体就越耗时。

图片

笔者的测试环境数据库中有很多的分表，这些分表为了和线上保持一致，分表的数量都和线上是一样的。

图片

 

因此在测试环境启动时，为了加载这些分表会更加的耗时。可通过将分表数量配置化，使测试环境在不影响功能验证的前提下减少分表数量，从而加快启动速度。

 

六、初始化异步

activityServiceImpl启动中，主要会进行活动信息的查询初始化，这是一个耗时的操作。类似同样的操作在工程的其他类中也存在。

@Service
public class ActivityServiceImpl implements ActivityService, InitializingBean{
     // 省略无关代码
     @Override
     public void afterPropertiesSet() throws Exception {
        initActivity();
    }
     // 省略无关代码
}

可以通过将afterPropertiesSet()异步化的方式加速项目的启动。

观察Spring源码可以注意到afterPropertiesSet方法是在AbstractAutowireCapableBeanFactory#

invokeInitMethods中调用的。在这个方法中，不光处理了afterPropertiesSet方法，也处理了init-method。

因此我们可以写一个自己的BeanFactory继承AbstractAutowireCapableBeanFactory，将invokeInitMethods方法进行异步化重写。考虑到AbstractAutowireCapableBeanFactory是个抽象类，有额外的抽象方法需要实现，因此继承该抽象类的子类DefaultListableBeanFactory。具体实现代码如下：

public class AsyncInitListableBeanFactory extends DefaultListableBeanFactory{
     public AsyncInitBeanFactory(ConfigurableListableBeanFactory beanFactory){
         super(beanFactory);
    }
     @Override
     protected void invokeInitMethods(String beanName, Object bean, RootBeanDefinition mbd)throws Throwable {
        if (beanName.equals("activityServiceImpl")) {
            AsyncTaskExecutor.submitTask(() -> {
                try {
                      super.invokeInitMethods(beanName, bean, mbd);
                } catch (Throwable throwable) {
                    throwable.printStackTrace();
                }
            });
        } else {
              super.invokeInitMethods(beanName, bean, mbd);
        }
    }
}

 

又因为Spring在refreshContext()方法之前的prepareContext()发放中针对initialize方法提供了接口扩展(applyInitializers())。因此我们可以通过实现该接口并将我们的新的BeanFactory通过反射的方式更新到Spring的初始化流程之前。

public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
     /**
     * Initialize the given application context.
     * @param applicationContext the application to configure
     */
    void initialize(C applicationContext);

}

 

改造后的代码如下，新增AsyncAccelerate-

Initializer类实现ApplicationContextInitializer接口：

public class AsyncBeanFactoryInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @SneakyThrows
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext){
        if (applicationContext instanceof GenericApplicationContext) {
            AsyncInitListableBeanFactory beanFactory = new AsyncInitListableBeanFactory(applicationContext.getBeanFactory());
            Field field = GenericApplicationContext.class.getDeclaredField("beanFactory");
            field.setAccessible(true);
            field.set(applicationContext, beanFactory);
        }
    }
}
public class AsyncBeanInitExecutor{
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final AtomicReference<ThreadPoolExecutor> THREAD_POOL_REF = new AtomicReference<>();
    private static final List<Future<?>> FUTURES = new ArrayList<>();
     /**
      * 创建线程池实例
      */
     private static ThreadPoolExecutor createThreadPoolExecutor(){
         int poolSize = CPU_COUNT + 1;
         return new ThreadPoolExecutor(poolSize, poolSize, 50L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
    /**
     * 确保线程池已初始化（线程安全）
     */
     private static void ensureThreadPoolExists(){
         if (THREAD_POOL_REF.get() != null) {
              return;
        }
        ThreadPoolExecutor executor = createThreadPoolExecutor();
         if (!THREAD_POOL_REF.compareAndSet(null, executor)) {
            executor.shutdown(); // 另一线程已初始化成功
        }
    }
    /**
     * 提交异步初始化任务
     *
     * @param task 初始化任务
     * @return 提交后的 Future 对象
     */
    public static Future<?> submitInitTask(Runnable task) {
        ensureThreadPoolExists();
        Future<?> future = THREAD_POOL_REF.get().submit(task);
        FUTURES.add(future);
        return future;
    }
    /**
     * 等待所有初始化任务完成并释放资源
     */
    public static void waitForInitTasks(){
        try {
            for (Future<?> future : FUTURES) {
                future.get();
            }
        } catch (Exception ex) {
            throw new RuntimeException("Async init task failed", ex);
        } finally {
            FUTURES.clear();
            shutdownThreadPool();
        }
    }
     /**
     * 关闭线程池并重置引用
     */
     private static void shutdownThreadPool(){
        ThreadPoolExecutor executor = THREAD_POOL_REF.getAndSet(null);
         if (executor != null) {
            executor.shutdown();
        }
    }
}

 

实现类后，还需要在META-INF/spring.factories下新增说明org.springframework.context.

ApplicationContextInitializer=com.xxx.AsyncAccelerateInitializer，这样这个类才能真正生效。

 

这样异步化以后还有一个点需要注意，如果该初始化方法执行耗时很长，那么会存在Spring容器已经启动完成，但是异步初始化任务没执行完的情况，可能会导致空指针等异常。为了避免这种问题的发生，还要借助于Spring容器启动中finishRefresh()方法，监听对应事件，确保异步任务执行完成之后，再启动容器。

 

public class AsyncInitCompletionListener implements ApplicationListener<ContextRefreshedEvent>, ApplicationContextAware, PriorityOrdered{
    private ApplicationContext currentContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext)throws BeansException {
         this.currentContext = applicationContext;
    }
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event){
        if (event.getApplicationContext() == currentContext) {
            AsyncBeanInitExecutor.waitForInitTasks();
        }
    }
    @Override
    public int getOrder(){
         return Ordered.HIGHEST_PRECEDENCE;
    }
}

 

七、总结

启动优化后的项目实际测试结果如下：

图片

通过异步化初始化和分库分表加载优化，项目启动时间从 280 秒缩短至 159 秒，提升约 50%。这对于提升日常开发效率、加快测试与联调流程具有重要意义。

原创作者: vivotech 转载于: https://www.cnblogs.com/vivotech/p/18936065
优化Spring Boot项目启动时间：详解与实践
fudaihb的博客
06-18 2260
在现代软件开发中，Spring Boot因其丰富的特性和简便的配置受到广泛欢迎。然而，随着项目规模的扩大，Spring Boot项目的启动时间可能显著增加，影响开发效率和系统响应。本文从多个角度出发，详尽解析如何优化Spring Boot项目的启动时间，以提高开发体验和系统性能。
Spring Boot性能优化实践：如何让你的应用跑得更快？看完此篇你就懂了。
最新发布
**My Coding Family**
06-15 1176
🏆本文收录于《滚雪球学Spring Boot》，专门攻坚指数提升，2025 年国内最系统+最强（更新中）。    本专栏致力打造最硬核 Spring Boot 从零基础到进阶系列学习内容，🚀均为全网独家首发，打造精品专栏，专栏持续更新中…欢迎大家订阅持续学习。 如果想快速定位学习，可以看这篇【SpringBoot教程导航帖】,你想学习的都被收集在内，快速投入学习！！两不误。
Spring Boot 启动时间优化全攻略
fudaihb的博客
12-17 2804
随着 Spring Boot 的广泛应用，开发者享受到了快速开发和自动化配置的便利。然而，随着项目复杂度的增加，Spring Boot 项目启动时间也变得越来越长，这在开发、调试和部署阶段可能会成为效率瓶颈。如何优化 Spring Boot 的启动时间，已经成为开发者和运维人员关注的重要问题。 本文将详细分析影响 Spring Boot 启动时间的主要因素，并提供一套从配置优化到代码调整的全方位优化方案，帮助开发者显著缩短项目的启动时间。
7min到40s：SpringBoot启动优化实践
码猿技术专栏
02-20 352
大家好，我是不才陈某~公司 SpringBoot 项目在日常开发过程中发现服务启动过程异常缓慢，常常需要6-7分钟才能暴露端口，严重降低开发效率。通过 SpringBoot 的 SpringApplicationRunListener 、BeanPostProcessor 原理和源码调试等手段排查发现，在 Bean 扫描和 Bean 注入这个两个阶段有很大的性能瓶颈。通过 JavaConfig 注...
聊聊SpringBoot应用启动优化
Huangjiazhen711的博客
10-25 3178
随着业务发展，线上业务jar 包越来越大，动不动就几百兆，启动时间也越来越慢，严重影响效率。目前大部分java项目都是使用SpringBoot，这篇文章就来简单聊聊关于SpringBoot应用启动优化。对于一个“历史悠久”的项目，业务代码自然是指数增长，而且在日常业务开发中，我们我都是在做加法，很少会去做删代码之类的操作。另外一般项目都会有很多中间件的初始化，比如：数据连接、redis连接、mq生产者和消费者注册、dubbo生产者和消费者注册、定时任务等；
Spring Boot-启动优化
嘻哈熊的专栏
05-13 782
来源：http://rrd.me/ekc64 FluxBaseline WebMVC spring-context-indexer 惰性初始化 NoVerify TieredStopAtLevel 指定 SpringConfigLocation 参数 关闭 JMX 取消 Logback 取消 Jackson 取消 HibernateValidator AppCDS 使用 Thin Launcher 的 .
Spring Boot性能优化与架构设计：应对技术瓶颈及改进建议
11-28
使用场景及目标：适用于希望在实际项目中提升Spring Boot应用性能、优化内存管理和改进微服务架构的企业级开发团队。目标是在高性能、高并发、高可用环境下确保Spring Boot应用的稳定性和高效性。 阅读建议：读者在...
Spring Boot 启动性能优化实践
YmsNet的博客
10-07 205
然而，在某些情况下，Spring Boot 应用的启动时间可能会变长，影响用户体验和应用的可用性。通过仔细审查项目的依赖项，并只保留必要的依赖，可以减少应用程序启动时需要加载的类和资源数量，从而加快启动速度。您可以通过使用合适的配置来精确控制自动配置，并只加载必要的组件和功能。通过采用上述优化实践，您可以显著减少 Spring Boot 应用程序的启动时间，提高用户体验和应用的可用性。要启用 DevTools，您可以在 Maven 或 Gradle 中添加相应的依赖，并在应用程序的配置文件中进行相应配置。
Spring Boot 启动优化
SR02020的博客
09-18 958
Spring Boot 启动优化 启动引导 确保你是Web项目 实例 @SpringBootApplication public class RunApp extends SpringBootServletInitializer { //实现configure方法 @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { return a
快做这 15点，让 SpringBoot 启动更快一点！
勇往直前的专栏
12-10 4669
“Spring有多快？” 这是 2018 Spring One Platform 中的一场会议。看完会议视频，我自己动手试了一下。下面是我做出的测试结果。 还没有观看视频的朋友推荐看一下，非常有意思。 https://springoneplatform.io/2018/sessions/how-fast-is-spring-   本文使用的代码 https://github.co...
springboot项目启动优化
weixin_33670786的博客
07-24 446
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringBoot 启动优化实践
qq_26304015的专栏
03-23 360
然后重点排查这些阶段的代码。先看下。
SpringBoot应用启动优化
jvjkfd的博客
04-21 1452
经历这么一个优化过程，我们发现，能定位到关键问题是非常关键的。而透过错综复杂的现象，能看到问题的本质是非常考验能力与经验的。
spring boot优化
a7082633的博客
05-30 474
英国架构师微https://alexecollins.com/spring-boot-performance/
记一次SpringBoot启动优化实践
m0_73311735的博客
01-04 315
有这种想法的原因是因为我在个人项目中使用过，因为这个项目刚起步，写的内容没那么多，随便设置几个JVM参数，堆内存设置大点，启动速度也就两三秒，不设置JVM参数，启动速度大概。而我在项目中使用，因为是本地，JVM参数并没有设置过，堆内存最小就是电脑内存的 1/64，最大就是内存的 1/4。尤其是需要频繁改代码，频繁重启项目的时候，每次项目启动起码都要两分钟才能启动完毕，挺影响开发效率的。主要是我理解的误区，我以为堆内存设置的足够大，减少 GC 频率，就可以提高启动速度。对于思路1，就不多说了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值