Spring Framework 异步工作原理
原因
Spring Framework 外部提供了除IOC和AOP之外的很多有意思的性能,深入研究其技术原理,可在我的项目技术选型上提供更多的思路,和技术把控。Spring Framewrok 代码由大佬精心打磨,能够从性能实现上学习和模拟。另外Spring Framework是Java我的项目开发的根底,其余技术框架都会基于或者与Spring 兼容,钻研其中的技术原理,可疾速把握其余技术框架的技术原理,比方 Spring boot \ Spring cloud…
简述
Spring Framework 提供了代码异步执行的性能。在须要异步执行的办法下面增加 @Async 注解,两外在@Configuration 类上减少 @EnableAsync 注解。代码执行到须要异步执行的办法上,就能够跨线程运行,达到异步执行的目标。
前提
Spring Framework 的异步工作性能是基于Spring AOP实现,Spring Aop 又是切面编程的一种,
须要对切面编程和 Spring Aop 中的根底概念有所理解。
注释
@EnableAsync
通过浏览注解的源文件 org.springframework.scheduling.annotation.EnableAsync
中正文,可对异步工作性能应用与定制有一个根本理解。
- 搭配@Configuration 注解一起应用。
- 反对 Spring’s @Async、 EJB 3.1 @jakarta.ejb.Asynchronous、 自定义注解(在 annotation() 中指定) 三种注解。
- 默认应用
org.springframework.core.task.SimpleAsyncTaskExecutor
线程池执行异步工作。能够通过自定义一个org.springframework.core.task.TaskExecutor
Bean 或者java.util.concurrent.Executor
Bean 名字是 ‘taskExecutor’。 - 异步办法的执行产生的异样不能传递给调用方,对于为解决的异样仅打印日志。
-
通过实现 AsyncConfigurer 能够线程池和异样处理器进行定制。
@Configuration @EnableAsync public class AppConfig implements AsyncConfigurer { // @Bean 不增加此注解也能失常应用,增加后该线程池能够被Spring 治理。 @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(7); executor.setMaxPoolSize(42); executor.setQueueCapacity(11); executor.setThreadNamePrefix("MyExecutor-"); // 应用@Bean 后,能够正文上面一行,线程池的初始化工作会有Spring负责。 executor.initialize(); return executor; } @Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { return new MyAsyncUncaughtExceptionHandler(); } }
- mode 属性管制 advice 如何利用。默认是 AdviceMode.PROXY,其余属性能够管制代理的行为,代理后的办法只能通过代理援用调用,调用本类中的代理办法不会失效。
- 另外能够将 mode 属性 设置为 AdviceMode.ASPECTJ. 须要引入spring-aspectj jar,反对以后类办法调用。
将正文删除后的代码:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AsyncConfigurationSelector.class)
public @interface EnableAsync {
Class<? extends Annotation> annotation() default Annotation.class;
boolean proxyTargetClass() default false;
AdviceMode mode() default AdviceMode.PROXY;
int order() default Ordered.LOWEST_PRECEDENCE;
}
@EnableAsync 通过 @Import 引入 AsyncConfigurationSelector
.
AsyncConfigurationSelector
依据@EnableAsync.mode返回 AbstractAsyncConfiguration
实现 ProxyAsyncConfiguration
或者 AspectJAsyncConfiguration
。
ProxyAsyncConfiguration
- 继承一个抽象类
AbstractAsyncConfiguration
。 -
创立
AsyncAnnotationBeanPostProcessor
,将默认的或者自定义的线程池和失败处理器放入其中。AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor(); bpp.configure(this.executor, this.exceptionHandler); Class<? extends Annotation> customAsyncAnnotation = this.enableAsync.getClass("annotation"); if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, "annotation")) { bpp.setAsyncAnnotationType(customAsyncAnnotation); } bpp.setProxyTargetClass(this.enableAsync.getBoolean("proxyTargetClass")); bpp.setOrder(this.enableAsync.<Integer>getNumber("order")); return bpp;
AbstractAsyncConfiguration
- 实现接口
ImportAware
, 在setImportMetadata
中对 enableAsync属性进行赋值。 - 主动注入
AsyncConfigurer
,Only one AsyncConfigurer may exist, 将Bean中的线程池和失败处理器赋值到属性中。
以上类属于性能配置阶段, 从此开始进入异步工作性能执行相干类。
Spring Framework 异步工作的技术原理实质就是通过aop机制,对Bean进行代理,将办法的执行放入线程池中执行。
Spring Framework 中对Bean创立代理的做法就是实现 BeanPostProcessor接口,在Bean创立的过程中,对Bean的类注解或者办法注解进行规定匹配,匹配通过后会生成代理对象,对Bean进行加强。
AsyncAnnotationBeanPostProcessor
异步工作的后置处理器。
在Bean实例化过程中会调用所有的beanPostProcessor,这些BeanPostProcessor 能够在定义类的时候实现 BeanPostProcessor 接口并注册为Bean,在Spring容器启动过程中,会通过注解解析取得bean definition,在AbstractApplicationContext 的 refresh() 中,调用完 invokeBeanFactoryPostProcessors()后,将BeanFactory中所有BeanPostProcessor 实现类的Bean 收集到AbstractBeanFactory中的 beanPostProcessors书信中,在进行Bean创立时,调用初始化的前置或者后置beanPostProcessor时,会执行所有的BeanPostProcessor的实现类。
UML:
仅实现 BeanFactoryAware.setBeanFactory()
, 创立 AsyncAnnotationAdvisor
AsyncAnnotationAdvisor advisor = new AsyncAnnotationAdvisor(this.executor, this.exceptionHandler);
if (this.asyncAnnotationType != null) {
advisor.setAsyncAnnotationType(this.asyncAnnotationType);
}
advisor.setBeanFactory(beanFactory);
this.advisor = advisor;
AsyncAnnotationAdvisor
中蕴含 advice 和 pointcut,advice就是动静代理中加强逻辑对象,pointcut就是代理的切入点。并会在构造方法中对advice和pointcut进行创立。
protected Advice buildAdvice(@Nullable Supplier<Executor> executor, @Nullable Supplier<AsyncUncaughtExceptionHandler> exceptionHandler) {
AnnotationAsyncExecutionInterceptor interceptor = new AnnotationAsyncExecutionInterceptor(null);
interceptor.configure(executor, exceptionHandler);
return interceptor;
}
AnnotationAsyncExecutionInterceptor
对象中蕴含异步工作执行逻辑代码。
protected Pointcut buildPointcut(Set<Class<? extends Annotation>> asyncAnnotationTypes) {
ComposablePointcut result = null;
for (Class<? extends Annotation> asyncAnnotationType : asyncAnnotationTypes) {
// 创立类 级别的匹配 MethodMatcher.TRUE
Pointcut cpc = new AnnotationMatchingPointcut(asyncAnnotationType, true);
// 创立办法级别的匹配 AnnotationMethodMatcher
Pointcut mpc = new AnnotationMatchingPointcut(null, asyncAnnotationType, true);
if (result == null) {
result = new ComposablePointcut(cpc);
}
else {
result.union(cpc);
}
result = result.union(mpc);
}
return (result != null ? result : Pointcut.TRUE);
}
创立基于指定注解的Pointcut,在结构器中会基于framework实现的两种注解 Async \ @jakarta.ejb.Asynchronous,另提供 setAsyncAnnotation 办法对自定义的异步注解进行从新设置,设置为仅反对指定注解的Pointcut。
在下面UML中能够看出 AsyncAnnotationBeanPostProcessor
继承了 AbstractAdvisingBeanPostProcessor
, Async的后置解决逻辑也在此类中。
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (this.advisor == null || bean instanceof AopInfrastructureBean) {
// Ignore AOP infrastructure such as scoped proxies.
return bean;
}
if (bean instanceof Advised advised) {
if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
// Add our local Advisor to the existing proxy's Advisor chain...
if (this.beforeExistingAdvisors) {
advised.addAdvisor(0, this.advisor);
}
else {
advised.addAdvisor(this.advisor);
}
return bean;
}
}
// 1.规定匹配
if (isEligible(bean, beanName)) {
ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
if (!proxyFactory.isProxyTargetClass()) {
evaluateProxyInterfaces(bean.getClass(), proxyFactory);
}
proxyFactory.addAdvisor(this.advisor);
customizeProxyFactory(proxyFactory);
// Use original ClassLoader if bean class not locally loaded in overriding class loader
ClassLoader classLoader = getProxyClassLoader();
if (classLoader instanceof SmartClassLoader && classLoader != bean.getClass().getClassLoader()) {
classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
}
// 2.创立代理
return proxyFactory.getProxy(classLoader);
}
// No proxy needed.
return bean;
}
规定匹配
- 首先会对匹配后果进行缓存到eligibleBeans。
- 匹配逻辑是在 AopUtils.canApply(),具体代码在
org.springframework.aop.support.AopUtils#canApply(org.springframework.aop.Pointcut, java.lang.Class<?>, boolean)
中,能够对照代码进行剖析。 - Pointcut构建的时候能够指定classFilter,匹配过程中会进行排除。
- pointcut的办法匹配器 MethodMatcher,若是类级别的匹配,会间接返回匹配胜利的后果。
- 指标类的Class对象,以及所有接口的Class对象进行收集。
- 遍历Class对象,获取Class对象的所有办法进行遍历,应用 AnnotationMethodMatcher 对办法注解进行匹配。
生成代理
- 指标类的所有接口都会设置到 ProxyFactory中。
- 设置以后Advisor到ProxyFactory中。
- ProxyFactory 创立代理。
结尾
以上就是对Spring Framework 异步工作的根本介绍,其中AnnotationAsyncExecutionInterceptor相干代码没有进行具体阐明。异步工作的根本技术原理进行了梳理,后续会对其余性能持续梳理。