spring源码@Async阅读笔记

这里主要讲的spring怎么实现@async进行处理的：
xml配置如下：

<!-- 任务执行器 --><task:executor id="executor" pool-size="5"/><!--开启注解调度支持 @Async--><task:annotation-driven executor="executor" proxy-target-class="true"/>

//spring对@Async注册了一个beanProcessor来对对象进行拦截，并生成一个新的代理对象 或 将“处理@Async注解的advisor”加入到对象拦截器调用链中public class AsyncAnnotationBeanPostProcessor extends AbstractAdvisingBeanPostProcessor implements BeanFactoryAware {    private Class<? extends Annotation> asyncAnnotationType;    //执行器    private Executor executor;    public AsyncAnnotationBeanPostProcessor() {        setBeforeExistingAdvisors(true);    }    public void setAsyncAnnotationType(Class<? extends Annotation> asyncAnnotationType) {        Assert.notNull(asyncAnnotationType, "'asyncAnnotationType' must not be null");        this.asyncAnnotationType = asyncAnnotationType;    }    public void setExecutor(Executor executor) {        this.executor = executor;    }    public void setBeanFactory(BeanFactory beanFactory) {        AsyncAnnotationAdvisor advisor = (this.executor != null ? new AsyncAnnotationAdvisor(this.executor) : new AsyncAnnotationAdvisor());        if (this.asyncAnnotationType != null) {            advisor.setAsyncAnnotationType(this.asyncAnnotationType);        }        advisor.setBeanFactory(beanFactory);        this.advisor = advisor;    }}

//处理拦截对象，并将处理@Async 注解的 advisor加入到目标对象拦截器调用链中public abstract class AbstractAdvisingBeanPostProcessor extends ProxyConfig        implements BeanPostProcessor, BeanClassLoaderAware, Ordered {    protected Advisor advisor;    protected boolean beforeExistingAdvisors = false;    private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();    private int order = Ordered.LOWEST_PRECEDENCE;    private final Map<Class<?>, Boolean> eligibleBeans = new ConcurrentHashMap<Class<?>, Boolean>(64);    public void setBeforeExistingAdvisors(boolean beforeExistingAdvisors) {        this.beforeExistingAdvisors = beforeExistingAdvisors;    }    public void setBeanClassLoader(ClassLoader beanClassLoader) {        this.beanClassLoader = beanClassLoader;    }    public void setOrder(int order) {        this.order = order;    }    public int getOrder() {        return this.order;    }    public Object postProcessBeforeInitialization(Object bean, String beanName) {        return bean;    }    public Object postProcessAfterInitialization(Object bean, String beanName) {        if (bean instanceof AopInfrastructureBean) { //获取AOP相关类            return bean;        }        //当前对象已经拥有一条调用拦截链，则添加我们自己的调用链        if (bean instanceof Advised) {             Advised advised = (Advised) bean;            if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {                if (this.beforeExistingAdvisors) {                    advised.addAdvisor(0, this.advisor);                }                else {                    advised.addAdvisor(this.advisor);                }                return bean;            }        }        //是否满足条件，本质是调用AsyncAnnotationAdvisor的pointcut的mathes()        if (isEligible(bean, beanName)) {            ProxyFactory proxyFactory = new ProxyFactory(bean);            // Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.            proxyFactory.copyFrom(this);            proxyFactory.addAdvisor(this.advisor);            return proxyFactory.getProxy(this.beanClassLoader);        }        // No async proxy needed.        return bean;    }    protected boolean isEligible(Object bean, String beanName) {        return isEligible(bean.getClass());    }    protected boolean isEligible(Class<?> targetClass) {        Boolean eligible = this.eligibleBeans.get(targetClass);        if (eligible != null) {            return eligible;        }        eligible = AopUtils.canApply(this.advisor, targetClass);        this.eligibleBeans.put(targetClass, eligible);        return eligible;    }}

处理@Async注解的advisor源码

public class AsyncAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {    private Advice advice;    private Pointcut pointcut;    public AsyncAnnotationAdvisor() {        this(new SimpleAsyncTaskExecutor());    }    @SuppressWarnings("unchecked")    public AsyncAnnotationAdvisor(Executor executor) {        Set<Class<? extends Annotation>> asyncAnnotationTypes = new LinkedHashSet<Class<? extends Annotation>>(2);        asyncAnnotationTypes.add(Async.class);        try {            asyncAnnotationTypes.add((Class<? extends Annotation>)                    ClassUtils.forName("javax.ejb.Asynchronous", AsyncAnnotationAdvisor.class.getClassLoader()));        }        catch (ClassNotFoundException ex) {        }        //初始化通知        this.advice = buildAdvice(executor);        //初始化切点        this.pointcut = buildPointcut(asyncAnnotationTypes);    }    public void setTaskExecutor(Executor executor) {        this.advice = buildAdvice(executor);    }    public void setAsyncAnnotationType(Class<? extends Annotation> asyncAnnotationType) {        Assert.notNull(asyncAnnotationType, "'asyncAnnotationType' must not be null");        Set<Class<? extends Annotation>> asyncAnnotationTypes = new HashSet<Class<? extends Annotation>>();        asyncAnnotationTypes.add(asyncAnnotationType);        this.pointcut = buildPointcut(asyncAnnotationTypes);    }    public void setBeanFactory(BeanFactory beanFactory) {        if (this.advice instanceof BeanFactoryAware) {            ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);        }    }    public Advice getAdvice() {        return this.advice;    }    public Pointcut getPointcut() {        return this.pointcut;    }    protected Advice buildAdvice(Executor executor) {        //初始化@Async的拦截器，并指定executor        return new AnnotationAsyncExecutionInterceptor(executor);    }    protected Pointcut buildPointcut(Set<Class<? extends Annotation>> asyncAnnotationTypes) {        ComposablePointcut result = null;        for (Class<? extends Annotation> asyncAnnotationType : asyncAnnotationTypes) {            Pointcut cpc = new AnnotationMatchingPointcut(asyncAnnotationType, true);            Pointcut mpc = AnnotationMatchingPointcut.forMethodAnnotation(asyncAnnotationType);            if (result == null) {                result = new ComposablePointcut(cpc).union(mpc);            }            else {                result.union(cpc).union(mpc);            }        }        return result;    }}

将同步转成异步执行过程如下：

public class AnnotationAsyncExecutionInterceptor extends AsyncExecutionInterceptor {    //缓存 方法对应的executor    private final Map<Method, AsyncTaskExecutor> executors = new ConcurrentHashMap<Method, AsyncTaskExecutor>(16);    private Executor defaultExecutor;    private BeanFactory beanFactory;    //初始化方法，构造器    public AnnotationAsyncExecutionInterceptor(Executor defaultExecutor) {        super(defaultExecutor);    }    public Object invoke(final MethodInvocation invocation) throws Throwable {        //获取目标类类型        Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);        //获取链接点方法对象        Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);        //获取到桥接方法对应的实际的方法        specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);        //确定executor        AsyncTaskExecutor executor = determineAsyncExecutor(specificMethod);        if (executor == null) {            throw new IllegalStateException(                    "No executor specified and no default executor set on AsyncExecutionInterceptor either");        }        //将调用链包装Callable对象，置入executor中        Future<?> result = executor.submit(                new Callable<Object>() {                    public Object call() throws Exception {                        try {                            Object result = invocation.proceed();                            if (result instanceof Future) {                                return ((Future<?>) result).get();                            }                        }                        catch (Throwable ex) {                            ReflectionUtils.rethrowException(ex);                        }                        return null;                    }                });        if (Future.class.isAssignableFrom(invocation.getMethod().getReturnType())) {            return result;        }        else {            return null;        }    }    //获取executor对象    protected AsyncTaskExecutor determineAsyncExecutor(Method method) {        AsyncTaskExecutor executor = this.executors.get(method);        if (executor == null) { //获取缓存            Executor executorToUse = this.defaultExecutor;            //获取qualifier            String qualifier = getExecutorQualifier(method);            if (StringUtils.hasLength(qualifier)) { //具有qualifier                Assert.notNull(this.beanFactory, "BeanFactory must be set on " + getClass().getSimpleName() +                        " to access qualified executor '" + qualifier + "'");                //查找指定Executor                executorToUse = BeanFactoryAnnotationUtils.qualifiedBeanOfType(                        this.beanFactory, Executor.class, qualifier);            }            else if (executorToUse == null) {                return null;            }            //将executor包装成AsyncTaskExecutor            executor = (executorToUse instanceof AsyncTaskExecutor ?                    (AsyncTaskExecutor) executorToUse : new TaskExecutorAdapter(executorToUse));            this.executors.put(method, executor);        }        return executor;    }    @Override    protected String getExecutorQualifier(Method method) { //获取qualifier        //获取方法注解@Async        Async async = AnnotationUtils.findAnnotation(method, Async.class);        if (async == null) {            //获取类注解@Async            async = AnnotationUtils.findAnnotation(method.getDeclaringClass(), Async.class);        }        return (async != null ? async.value() : null);    }}