【开源项目】SofaBoot实现Spring Bean 异步初始化的源码拆解

最新推荐文章于 2023-08-16 11:35:07 发布
最新推荐文章于 2023-08-16 11:35:07 发布
阅读量631 收藏
点赞数
分类专栏： 开源项目介绍 源码解析 文章标签： spring 开源 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42985872/article/details/131081140
版权

使用场景

在实际使用 Spring/Spring Boot 开发中，一些 Bean 在初始化过程中执行准备操作，如拉取远程配置、初始化数据源等等。在应用启动期间，这些 Bean 会增加 Spring 上下文刷新时间，导致应用启动耗时变长。

Demo展示

SpringBoot案例

MaxBean实例

@Slf4j
public class MaxBean {

    public void init() throws Exception {
        Thread.sleep(5000);
        log.info("maxBean init ok");
    }
}

WhyBean实例

@Slf4j
public class WhyBean {

    public void init() throws Exception {
        Thread.sleep(5000);
        log.info("whyBean init ok");
    }
}

系统启动

@SpringBootApplication
public class DemoSofabootApplication {

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

    @Bean(name = "maxBean", initMethod = "init")
    public MaxBean maxBean() {
        return new MaxBean();
    }

    @Bean(name = "whyBean", initMethod = "init")
    public WhyBean whyBean() {
        return new WhyBean();
    }

}

启动日志输出，花了11s钟

2023-06-06 13:45:51.219  INFO 21320 --- [           main] com.charles.entity.MaxBean               : maxBean init ok
2023-06-06 13:45:56.220  INFO 21320 --- [           main] com.charles.entity.WhyBean               : whyBean init ok
2023-06-06 13:45:56.483  INFO 21320 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-06-06 13:45:56.492  INFO 21320 --- [           main] com.charles.DemoSofabootApplication      : Started DemoSofabootApplication in 11.893 seconds (JVM running for 12.746)

Sofa优化

修改依赖，设置父pom为sofaboot-dependencies，引入runtime-sofa-boot-starter。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>com.alipay.sofa</groupId>
        <artifactId>sofaboot-dependencies</artifactId>
        <version>3.18.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.charles</groupId>
    <artifactId>demo-sofaboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo-sofaboot</name>
    <description>demo-sofaboot</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.6.13</spring-boot.version>
        <sofa.boot.version>3.18.0</sofa.boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alipay.sofa</groupId>
            <artifactId>runtime-sofa-boot-starter</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.charles.DemoSofabootApplication</mainClass>
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

添加配置项

spring:
  application:
    name: demo-sofaboot

修改系统启动，添加注解SofaAsyncInit。

@SpringBootApplication
public class DemoSofabootApplication {

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

    @Bean(name = "maxBean", initMethod = "init")
    @SofaAsyncInit
    public MaxBean maxBean() {
        return new MaxBean();
    }

    @Bean(name = "whyBean", initMethod = "init")
    @SofaAsyncInit
    public WhyBean whyBean() {
        return new WhyBean();
    }

}

启动日志，启动时间花费了6.8s左右

2023-06-06 13:48:42.440  INFO 10528 --- [bean-1-thread-2] com.charles.entity.WhyBean               : whyBean init ok
2023-06-06 13:48:42.440  INFO 10528 --- [bean-1-thread-1] com.charles.entity.MaxBean               : maxBean init ok
2023-06-06 13:48:42.440  INFO 10528 --- [bean-1-thread-1] com.alipay.sofa                          : com.charles.entity.MaxBean(maxBean) init method execute 5013ms, moduleName: RootApplicationContext.
2023-06-06 13:48:42.440  INFO 10528 --- [bean-1-thread-2] com.alipay.sofa                          : com.charles.entity.WhyBean(whyBean) init method execute 5009ms, moduleName: RootApplicationContext.
2023-06-06 13:48:42.450  INFO 10528 --- [           main] com.charles.DemoSofabootApplication      : Started DemoSofabootApplication in 6.883 seconds (JVM running for 7.535)

源码理解

AsyncInitBeanFactoryPostProcessor

AsyncInitBeanFactoryPostProcessor#postProcessBeanFactory，系统启动的时候，执行AbstractApplicationContext#invokeBeanFactoryPostProcessors，触发所有的BeanFactoryPostProcessor，执行BeanFactoryPostProcessor#postProcessBeanFactory。AsyncInitBeanFactoryPostProcessor实现了BeanFactoryPostProcessor，会扫描到带有SofaAsyncInit的Bean。

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        Arrays.stream(beanFactory.getBeanDefinitionNames())
                .collect(Collectors.toMap(Function.identity(), beanFactory::getBeanDefinition))
                .forEach((key, value) -> scanAsyncInitBeanDefinition(key, value, beanFactory));
    }

AsyncInitBeanFactoryPostProcessor#scanAsyncInitBeanDefinitionOnClass，扫描到带有SofaAsyncInit的Bean，收集起来。

    private void scanAsyncInitBeanDefinitionOnClass(String beanId, Class<?> beanClass,
                                                    BeanDefinition beanDefinition,
                                                    ConfigurableListableBeanFactory beanFactory) {
        // See issue: https://github.com/sofastack/sofa-boot/issues/835
        SofaAsyncInit sofaAsyncInitAnnotation = AnnotationUtils.findAnnotation(beanClass,
            SofaAsyncInit.class);
        registerAsyncInitBean(beanId, sofaAsyncInitAnnotation, beanDefinition);
    }

    private void registerAsyncInitBean(String beanId, SofaAsyncInit sofaAsyncInitAnnotation,
                                       BeanDefinition beanDefinition) {
        if (sofaAsyncInitAnnotation == null) {
            return;
        }
        PlaceHolderAnnotationInvocationHandler.AnnotationWrapperBuilder<SofaAsyncInit> wrapperBuilder = PlaceHolderAnnotationInvocationHandler.AnnotationWrapperBuilder
            .wrap(sofaAsyncInitAnnotation).withBinder(binder);
        sofaAsyncInitAnnotation = wrapperBuilder.build();

        if (sofaAsyncInitAnnotation.value()) {
            AsyncInitBeanHolder.registerAsyncInitBean(moduleName, beanId,
                beanDefinition.getInitMethodName());
        }
    }

AsyncInitBeanHolder对于收集到的Bean的处理，就是存放到Map集合中。

public class AsyncInitBeanHolder {
    private static final ConcurrentMap<String, Map<String, String>> asyncBeanInfos = new ConcurrentHashMap<String, Map<String, String>>();

    public static void registerAsyncInitBean(String moduleName, String beanId, String methodName) {
        if (moduleName == null || beanId == null || methodName == null) {
            return;
        }

        Map<String, String> asyncBeanInfosInModule = asyncBeanInfos.get(moduleName);
        if (asyncBeanInfosInModule == null) {
            asyncBeanInfos.putIfAbsent(moduleName, new ConcurrentHashMap<String, String>());
            asyncBeanInfosInModule = asyncBeanInfos.get(moduleName);
        }

        asyncBeanInfosInModule.put(beanId, methodName);
    }

    public static String getAsyncInitMethodName(String moduleName, String beanId) {
        Map<String, String> asyncBeanInfosInModule;
        asyncBeanInfosInModule = (moduleName == null) ? null : asyncBeanInfos.get(moduleName);
        return (beanId == null || asyncBeanInfosInModule == null) ? null : asyncBeanInfosInModule
            .get(beanId);
    }
}

AsyncProxyBeanPostProcessor

AsyncProxyBeanPostProcessor#postProcessBeforeInitialization，AsyncProxyBeanPostProcessor 类实现了 BeanPostProcessor 接口，并重写了其 postProcessBeforeInitialization 方法。如果在AsyncInitBeanHolder找到对应的数据，就会生成相应的代理类。

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
                                                                               throws BeansException {
        String methodName = AsyncInitBeanHolder.getAsyncInitMethodName(moduleName, beanName);
        if (methodName == null || methodName.length() == 0) {
            return bean;
        }

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTargetClass(bean.getClass());
        proxyFactory.setProxyTargetClass(true);
        AsyncInitializeBeanMethodInvoker asyncInitializeBeanMethodInvoker = new AsyncInitializeBeanMethodInvoker(
            bean, beanName, methodName);
        proxyFactory.addAdvice(asyncInitializeBeanMethodInvoker);
        return proxyFactory.getProxy();
    }

AsyncInitializeBeanMethodInvoker

AsyncProxyBeanPostProcessor.AsyncInitializeBeanMethodInvoker#invoke，代理的拦截器的核心就是把初始化方法扔到线程池中。

        @Override
        public Object invoke(final MethodInvocation invocation) throws Throwable {
            // if the spring refreshing is finished
            if (AsyncTaskExecutor.isStarted()) {
                return invocation.getMethod().invoke(targetObject, invocation.getArguments());
            }

            Method method = invocation.getMethod();
            final String methodName = method.getName();
            if (!isAsyncCalled && methodName.equals(asyncMethodName)) {
                isAsyncCalled = true;
                isAsyncCalling = true;
                AsyncTaskExecutor.submitTask(applicationContext.getEnvironment(), new Runnable() {
                    @Override
                    public void run() {
                        try {
                            long startTime = System.currentTimeMillis();
                            invocation.getMethod().invoke(targetObject, invocation.getArguments());
                            SofaLogger.info(String.format(
                                "%s(%s) %s method execute %dms, moduleName: %s.", targetObject
                                    .getClass().getName(), beanName, methodName, (System
                                    .currentTimeMillis() - startTime), moduleName));
                        } catch (Throwable e) {
                            throw new RuntimeException(e);
                        } finally {
                            initCountDownLatch.countDown();
                            isAsyncCalling = false;
                        }
                    }
                });
                return null;
            }

            if (isAsyncCalling) {
                long startTime = System.currentTimeMillis();
                initCountDownLatch.await();
                SofaLogger.info(String.format("%s(%s) %s method wait %dms, moduleName: %s.",
                    targetObject.getClass().getName(), beanName, methodName,
                    (System.currentTimeMillis() - startTime), moduleName));
            }
            return invocation.getMethod().invoke(targetObject, invocation.getArguments());
        }

AsyncTaskExecutionListener

AsyncTaskExecutionListener当监听到ContextRefreshedEvent，执行AsyncTaskExecutor.ensureAsyncTasksFinish();，保证线程池中的初始化任务都执行结束。

public class AsyncTaskExecutionListener implements PriorityOrdered,
                                       ApplicationListener<ContextRefreshedEvent>,
                                       ApplicationContextAware {
    private ApplicationContext applicationContext;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (applicationContext.equals(event.getApplicationContext())) {
            AsyncTaskExecutor.ensureAsyncTasksFinish();
        }
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE + 1;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

AsyncTaskExecutor#ensureAsyncTasksFinish，保证启动完毕之前所有的异步线程执行结束

    public static void ensureAsyncTasksFinish() {
        for (Future future : FUTURES) {
            try {
                future.get();
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        }

        STARTED.set(true);
        FUTURES.clear();
        if (THREAD_POOL_REF.get() != null) {
            THREAD_POOL_REF.get().shutdown();
            THREAD_POOL_REF.set(null);
        }
    }

相关参考

  • https://mp.weixin.qq.com/s/brEKfqWbaGt3FvpuMqSoGg

在这里插入图片描述

秋装什么
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Bean初始化过程
轻风无言的博客
02-18 398
Spring初始化过程，相信很多人都知道，而初始化过程中，我们能够做些什么，现在就来做过总结。
Spring Boot是一个基于Spring框架的开源项目，旨在简化Spring应用的初始搭建以及开发过程 以下是对Spring
最新发布
05-05
Spring Boot是一个基于Spring框架的开源项目，旨在简化Spring应用的初始搭建以及开发过程。以下是对Spring Boot的500字资源介绍： Spring Boot是一款快速、轻便的Java开发框架，它为Spring应用提供了更加简化的开发...
SOFABoot——基本使用（笔记）
weixin_46949627的博客
08-16 1579
SOFABoot基础
登陆1-关于sofaboot拦截器的问题
qq_35653822的博客
02-10 886
我的问题：一个sofaboot项目中，按正常springboot项目那样写拦截器或者过滤器都不好用 我的写法 @Component @Slf4j public class LoginInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest ...
SOFA原理学习--sofa boot入门学习
井底之蛙
08-25 1万+
        目前Spring boot可以说是Spring web最为流行的开发框架了，目前很多框架都支持Spring boot注册扫描的模式，这篇博客我们用一个示例来展示一下sofa-boot简单的开发工程。 1、创建API中相关接口及实现类 接口： public interface IHelloService { public String sayHello(String...
SOFA Weekly | 开源人—于雨、本周 QA、本周 Contributor
金融级分布式架构
06-24 140
SOFA WEEKLY | 每周精选筛选每周精华问答，同步开源进展欢迎留言互动～SOFAStack（ScalableOpenFinancialArchitecture Stack）是蚂蚁集团自主研发的金融级云原生架构，包含了构建金融级云原生架构所需的各个组件，包括微服务研发框架，RPC 框架，服务注册中心，分布式定时任务，限流/熔断框架，动态配置推送，分布式链路...
Bean的异步加载，SOFABoot主打一个异步
m0_71777195的博客
07-04 253
最近在学习异步编程的过程中，偶然看到Bean的异步加载，之前只用过方法的异步事务、异步回调、异步线程，基本都是针对方法的执行，但是具体涉及到Bean实例的异步加载，还没有在实际开发中应用过，在我的理解Spring boot在项目启动的时候会加载很多bean，比如一些远程配置、数据源，可能会在需要调用的时候，进行使用，如果这个时候在进行加载，是不是就会节约很多资源。了解Spring的小伙伴应该知道，bean加载避免不了上下文的切换，减少上下文的切换本身就是一种节约CPU资源的方式。
基于Spring Boot 2的Roses开源项目Guns核心支撑层设计源码
04-09
本项目是基于Spring Boot 2的Roses开源项目Guns核心支撑层设计源码，包含1509个文件，其中1120个Java文件，188个XML文件，139个Markdown文件，27个Factories文件，25个SQL文件，5个PNG文件，3个GITIGNORE文件，1个...
基于Spring Boot的mblog开源博客系统设计源码
04-04
本设计源码提供了一个基于Spring Boot的mblog开源博客系统。项目包含761个文件，主要使用Java编程语言，并包含了JavaScript、CSS、HTML和Shell。文件类型包括226个Java源代码文件、154个JavaScript脚本文件、121个...
基于Spring Boot的Rabbit自动化测试平台服务端设计源码
04-04
本设计源码提供了一个基于Spring Boot的Rabbit自动化测试平台服务端。项目包含451个文件，主要使用Java编程语言，并包含了JavaScript、CSS、HTML和Shell。文件类型包括347个Java源代码文件、50个XML配置文件、13个...
Sofa学习文档--关于safa的一些学习心得
09-02
Sofa学习心得，告诉你如何从零开始做Sofa
SOFABoot 是蚂蚁集团开源的基于 Spring Boot 的研发框架.rar
07-02
针对 Spring Boot 缺少 Readiness Check 能力的情况，SOFABoot 增加了 Spring Boot 现有的健康检查的能力，提供了 Readiness Check 的能力。 利用 Readiness Check 的能力，SOFA 中间件中的各个组件只有在 ...
SOFABoot源码解析之Readiness检查
闲来无事
06-28 4911
        SOFABoot在SpringBoot的Liveness检查能力的基础上，增加了Readiness检查能力。如果你需要使用SOFA中间件，那么建议使用SOFABoot的Readiness检查能力，来更优雅的上线应用实例。一、SpringBoot健康检查        SpringBootActuator帮助我们监控我们的SpringBoot项目。        SpringBoot...
最全Spring初始化Bean的方法
just_for_that_moment的博客
11-14 3836
最全Spring初始化Bean的方法
java bean 初始化_Spring Bean初始化的几种常规方式
weixin_34489345的博客
02-23 411
通过构造方法实例化通过静态工厂实例化通过实例工厂实例化通过FactoryBean实例化RumenzA实体类package com.rumenz;public class RumenzA {private String id;private String name;public static RumenzA createRumenzA(){RumenzA rumenzA=new RumenzA();...
springboot：bean常用初始化方法与销毁执行方法
Gu31415的专栏
08-27 1242
bean常用初始化方法与销毁执行方法
springboot 加载完bean之后的初始化
热门推荐
叶新东老师的博客
08-05 1万+
一般情况下，我们的项目在刚启动的时候就需要初始化一些数据，特别有些是需要查询表的情况下，这时候我们就要用到springboot的初始化了, 我自己的个人网站就用到了这种技术 我们需要实现 CommandLineRunner 接口并在类上面添加 @Component 和 @Order(2) 注解 ， 并重写run()方法，springboot会自动扫描这些注解，即可完成初始化， 注意：这个初始...
Springboot bean初始化方法InitializingBean
Mrerlou的博客
09-24 4080
spring boot InitializingBean接口使用总结 被spring管理 实现InitializingBean接口 重写afterPropertiesSet方法 InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。 代码入下 @Compo...
java spring boot 异步调用
03-23
Java Spring Boot提供了异步调用的功能，可以在处理请求时将一些耗时的操作交给其他线程来处理，以提高系统的并发性能和响应速度。 在Spring Boot中，可以使用`@Async`注解来标记一个方法为异步方法。需要在配置类上添加`@EnableAsync`注解来启用异步调用功能。 以下是使用Java Spring Boot进行异步调用的步骤： 1. 在需要进行异步调用的方法上添加`@Async`注解。 2. 在配置类上添加`@EnableAsync`注解，启用异步调用功能。 3. 在调用异步方法时，使用`CompletableFuture`或`Future`来获取异步方法的返回结果。 示例代码如下： ```java import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Service; @Service public class MyService { @Async public CompletableFuture<String> asyncMethod() { // 异步执行的逻辑 // ... return CompletableFuture.completedFuture("异步方法执行完成"); } } ``` 在上述示例中，`MyService`类中的`asyncMethod`方法被标记为异步方法。在方法内部可以执行一些耗时的操作，然后通过`CompletableFuture.completedFuture`方法返回异步方法的结果。 使用异步方法时，可以通过`CompletableFuture.get()`方法来获取异步方法的返回结果，或者使用`CompletableFuture.join()`方法等待异步方法执行完成。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值