AOP流程分析

1. 添加后处理器（SmartInstantiationAwareBeanPostProcessor）

@EnableAspectJAutoProxy --> @Import(AspectJAutoProxyRegistrar.class) --> 注册AnnotationAwareAspectJAutoProxyCreator

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    ...
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        ...
        // 非Advice、Pointcut、Advisor、AopInfrastructureBean类型，且无@Aspect注解
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            ...
            Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            ...
            return proxy;
        }
        ...
    }

    protected Object createProxy(Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
        ...
        ProxyFactory proxyFactory = new ProxyFactory();
        ...
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        for (Advisor advisor : advisors) {
            proxyFactory.addAdvisor(advisor);
        }
        ...
        return proxyFactory.getProxy(getProxyClassLoader());
    }
    ...
}

2. 获取Advisor（Advice）

--> AbstractAdvisorAutoProxyCreator.getAdvicesAndAdvisorsForBean
--> AbstractAdvisorAutoProxyCreator.findEligibleAdvisors

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
    ...
    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        // 获取所有Advisor（Advice），排序如下：@Around -> @Before -> @After -> @AfterReturning -> @AfterThrowing -> @Around -> @Before -> ...
        List<Advisor> candidateAdvisors = findCandidateAdvisors(); 
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            // 重新局部排序：@AfterThrowing -> @AfterReturning -> @After -> @Around -> @Before -> @AfterThrowing -> @AfterReturning -> ...
            eligibleAdvisors = sortAdvisors(eligibleAdvisors); 
        }
        return eligibleAdvisors;
    }
    ...
}

--> findCandidateAdvisors

public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
    ...
    private AspectJAdvisorFactory aspectJAdvisorFactory;
    private BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder;

    @Override
    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.initBeanFactory(beanFactory);
        if (this.aspectJAdvisorFactory == null) {
            this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
        }
        this.aspectJAdvisorsBuilder = new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
    }

    @Override
    protected List<Advisor> findCandidateAdvisors() {
        List<Advisor> advisors = super.findCandidateAdvisors();
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        return advisors;
    }
    ...
}

--> BeanFactoryAspectJAdvisorsBuilderAdapter.buildAspectJAdvisors

public class BeanFactoryAspectJAdvisorsBuilder {
    ...
    private final AspectJAdvisorFactory advisorFactory; // ReflectiveAspectJAdvisorFactory
    ...
    public List<Advisor> buildAspectJAdvisors() {
        List<String> aspectNames = this.aspectBeanNames;
        // 无缓存
        if (aspectNames == null) {
            synchronized (this) {
                ...
                if (aspectNames == null) {
                    List<Advisor> advisors = new LinkedList<Advisor>();
                    ...
                    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
                    for (String beanName : beanNames) {
                        ...
                        Class<?> beanType = this.beanFactory.getType(beanName);
                        ...
                        if (this.advisorFactory.isAspect(beanType)) {
                            ...
                            if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) { // 单实例
                                MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                                List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                                ...
                                advisors.addAll(classAdvisors);
                            }
                            else { // 多实例
                                ...
                                MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                                ...
                                advisors.addAll(this.advisorFactory.getAdvisors(factory));
                            }
                        }
                    }
                    ...
                    return advisors;
                }
            }
        }
        // 有缓存
        ...
    }
    ...
}

--> ReflectiveAspectJAdvisorFactory.getAdvisors

public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFactory implements Serializable {
    ...
    @Override
    public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
        Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
        ...
        List<Advisor> advisors = new LinkedList<Advisor>();
        for (Method method : getAdvisorMethods(aspectClass)) { // 按方法上的注解排序：@Around -> @Before -> @After -> @AfterReturning -> @AfterThrowing
            Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }
        ...
        return advisors;
    }

    @Override
    public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrderInAspect, String aspectName) {
        ...
        AspectJExpressionPointcut expressionPointcut = getPointcut(candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
        if (expressionPointcut == null) {
            return null;
        }
        return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod, this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    }

    public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
            MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
        ...
        AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
        AbstractAspectJAdvice springAdvice;
        switch (aspectJAnnotation.getAnnotationType()) {
            case AtBefore:
                springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                break;
            case AtAfter:
                springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                break;
            case AtAfterReturning:
                springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                ...
                break;
            case AtAfterThrowing:
                springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                ...
                break;
            case AtAround:
                springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                break;
            case AtPointcut:
                return null;
            default:
                ...
        }
        ...
        return springAdvice;
    }
    ...
}

--> new InstantiationModelAwarePointcutAdvisorImpl

class InstantiationModelAwarePointcutAdvisorImpl implements InstantiationModelAwarePointcutAdvisor, AspectJPrecedenceInformation, Serializable {
    ...
    public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut, Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
            MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
        ...
        private Advice instantiatedAdvice;
        ...
        if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
            ...
        }
        else {
            ...
            this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
        }
    }

    private Advice instantiateAdvice(AspectJExpressionPointcut pcut) {
        return this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pcut, this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
    }
    ...
}

3. 创建代理

--> ProxyFactory.getProxy
--> ProxyCreatorSupport.createAopProxy
--> DefaultAopProxyFactory.createAopProxy

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            ...
            return new ObjenesisCglibAopProxy(config); // CGLIB代理
        }
        else {
            return new JdkDynamicAopProxy(config); // JDK代理
        }
    }
    ...
}

--> JDK代理

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    ...
    protected final AdvisedSupport advised; // ProxyFactory
    ...
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        ...
        try {
            ...
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
            if (chain.isEmpty()) {
                ...
            }
            else {
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                retVal = invocation.proceed();
            }
            ...
            return retVal;
        }
        ...
    }
    ...
}

--> CGLIB代理

class CglibAopProxy implements AopProxy, Serializable {
    ...
    protected final AdvisedSupport advised; // ProxyFactory
    ...
    private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
        ...
        if (isStatic && isFrozen) {
            Method[] methods = rootClass.getMethods();
            ...
            for (int x = 0; x < methods.length; x++) {
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(methods[x], rootClass);
                fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
                ...
            }
            ...
        }
        ...
    }
    ...
    private static class FixedChainStaticTargetInterceptor implements MethodInterceptor, Serializable {
        ...
        @Override
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            MethodInvocation invocation = new CglibMethodInvocation(proxy, this.target, method, args, this.targetClass, this.adviceChain, methodProxy);
            Object retVal = invocation.proceed();
            ...
            return retVal;
        }
    }
    private static class CglibMethodInvocation extends ReflectiveMethodInvocation {
        ...
    }
    ...
}

4. 拦截器链

--> ProxyFactory.getInterceptorsAndDynamicInterceptionAdvice

public class AdvisedSupport extends ProxyConfig implements Advised {
    ...
    AdvisorChainFactory advisorChainFactory = new DefaultAdvisorChainFactory();
    ...
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
        ...
        if (cached == null) {
            cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this, method, targetClass);
            ...
        }
        return cached;
    }
    ...
}
public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {
    @Override
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, Class<?> targetClass) {
        ...
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance(); // DefaultAdvisorAdapterRegistry
        for (Advisor advisor : config.getAdvisors()) {
            if (advisor instanceof PointcutAdvisor) {
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                    MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                    MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                    if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
                        if (mm.isRuntime()) {
                            for (MethodInterceptor interceptor : interceptors) {
                                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                            }
                        }
                        else {
                            interceptorList.addAll(Arrays.asList(interceptors));
                        }
                    }
                }
            }
            ...
        }
        return interceptorList;
    }
    ...
}
public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {

    private final List<AdvisorAdapter> adapters = new ArrayList<AdvisorAdapter>(3);

    public DefaultAdvisorAdapterRegistry() {
        registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
        registerAdvisorAdapter(new AfterReturningAdviceAdapter());
        registerAdvisorAdapter(new ThrowsAdviceAdapter());
    }

    ...

    @Override
    public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
        List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
        Advice advice = advisor.getAdvice();
        if (advice instanceof MethodInterceptor) {
            interceptors.add((MethodInterceptor) advice);
        }
        for (AdvisorAdapter adapter : this.adapters) {
            if (adapter.supportsAdvice(advice)) {
                interceptors.add(adapter.getInterceptor(advisor));
            }
        }
        ...
        return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
    }

    @Override
    public void registerAdvisorAdapter(AdvisorAdapter adapter) {
        this.adapters.add(adapter);
    }

}

--> ReflectiveMethodInvocation.proceed

public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {
    ...
    protected final List<?> interceptorsAndDynamicMethodMatchers;
    ...
    @Override
    public Object proceed() throws Throwable {
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }

        Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            ...
        }
        else {
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }
    protected Object invokeJoinpoint() throws Throwable {
        return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
    }
    ...
}