AOP源码

本文主要为spring中AOP的源码。

AOP源码

在spring的配置文件中配置后，spring在解析是使用的是自定义的方式解析。

BeanDefinitionParserDelegate类

根据标签内容，即aop:aspectj-autoproxy在配置文件中获取到uri:http://www.springframework.org/schema/aop，再到spring.handlers中获取到对应的类org.springframework.aop.config.AopNamespaceHandler。将该类进行初始化创建对象，然后调用类中的init方法，init方法中的aspectj-autoproxy对应的是AspectJAutoProxyBeanDefinitionParser对象。调用AspectJAutoProxyBeanDefinitionParser对象的parser方法，将AnnotationAwareAspectJAutoProxyCreator转换为RootDefinition最终进行注册。

AnnotationAwareAspectJAutoProxyCreator分析

private final XmlReaderContext readerContext;
//ele=[aop:aspectj-autoproxy: null],containingBd=null
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        //namespaceUri=http://www.springframework.org/schema/aop
        String namespaceUri = getNamespaceURI(ele);
        //this.readContext=XmlReaderContext,handler最终返回AopNamespaceHandler对象
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler == null) {
            error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
            return null;
        }
        //调用
        return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

DefaultNamespaceHandlerResolver类

    private volatile Map<String, Object> handlerMappings;

    //namespaceUri = http://www.springframework.org/schema/aop
    @Override
    public NamespaceHandler resolve(String namespaceUri) {
        Map<String, Object> handlerMappings = getHandlerMappings();
        /**handlerOrClassName = org.springframework.aop.config.AopNamespaceHandler,
        从spring.handlers中获取到其对应的className。
        */
        Object handlerOrClassName = handlerMappings.get(namespaceUri);
        if (handlerOrClassName == null) {
            return null;
        }
        else if (handlerOrClassName instanceof NamespaceHandler) {
            return (NamespaceHandler) handlerOrClassName;
        }
        else {
            String className = (String) handlerOrClassName;
            try {
                //获取对应的Class实例
                Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
                if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                    throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                            "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
                }
                //生成AopNamespaceHandler对象。其为NamespaceHandler的子类。
                NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
                //初始化
                namespaceHandler.init();
                //将生成的namespaceHandler对象放入到this.handlerMappings中。
                handlerMappings.put(namespaceUri, namespaceHandler);
                return namespaceHandler;
            }
            catch (ClassNotFoundException ex) {
                throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
                        namespaceUri + "] not found", ex);
            }
            catch (LinkageError err) {
                throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
                        namespaceUri + "]: problem with handler class file or dependent class", err);
            }
        }
    }

namespaceHandler.init();

class AopNamespaceHandler extends NamespaceHandlerSupport

自定义的标签解析类都需要继承NamespaceHandlerSupport类，实现init()方法。

@Override
    public void init() {
        // In 2.0 XSD as well as in 2.1 XSD.
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        //对应配置文件中的<aop:aspectj-autoproxy></aop:aspectj-autoproxy>，继承自BeanDefinitionParser
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

        // Only in 2.0 XSD: moved to context namespace as of 2.1
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

new ParserContext(this.readerContext, this, containingBd)

创建一个ParserContext对象。

private final XmlReaderContext readerContext;

private final BeanDefinitionParserDelegate delegate;

private BeanDefinition containingBeanDefinition;

handler.parse(ele, new ParserContext(this.readerContext, this, containingBd))

public abstract class NamespaceHandlerSupport implements NamespaceHandler {

   private final Map<String, BeanDefinitionParser> parsers =
            new HashMap<String, BeanDefinitionParser>();

    //将parser对象放入集合中    
    protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
        this.parsers.put(elementName, parser);
    }

   @Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        //获取对应的BeanDefinitionParser的子类，并调用其的parse方法。
        return findParserForElement(element, parserContext).parse(element, parserContext);
    }

    //获取到AspectJAutoProxyBeanDefinitionParser对象。
    private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
        //获取标签中冒号后面的内容：aspectj-autoproxy
        String localName = parserContext.getDelegate().getLocalName(element);
        //取出对应的对象，即AspectJAutoProxyBeanDefinitionParser
        BeanDefinitionParser parser = this.parsers.get(localName);
        if (parser == null) {
            parserContext.getReaderContext().fatal(
                    "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
        }
        return parser;
    }
}

AspectJAutoProxyBeanDefinitionParser

class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {

    @Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        /**进行注册，AnnotationAwareAspectJAutoProxyCreator对象最终生成RootBeanDefinition对象，并注册
        key:org.springframework.aop.config.internalAutoProxyCreator
        */
        AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
        extendBeanDefinition(element, parserContext);
        return null;
    }

    private void extendBeanDefinition(Element element, ParserContext parserContext) {
        BeanDefinition beanDef =
                parserContext.getRegistry().getBeanDefinition(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
        //是否有子标签
        if (element.hasChildNodes()) {
            addIncludePatterns(element, parserContext, beanDef);
        }
    }

    //将子标签的内容最终添加到beandefinition中。
    private void addIncludePatterns(Element element, ParserContext parserContext, BeanDefinition beanDef) {
        ManagedList<TypedStringValue> includePatterns = new ManagedList<TypedStringValue>();
        NodeList childNodes = element.getChildNodes();
        for (int i = 0; i < childNodes.getLength(); i++) {
            Node node = childNodes.item(i);
            if (node instanceof Element) {
                Element includeElement = (Element) node;
                TypedStringValue valueHolder = new TypedStringValue(includeElement.getAttribute("name"));
                valueHolder.setSource(parserContext.extractSource(includeElement));
                includePatterns.add(valueHolder);
            }
        }
        if (!includePatterns.isEmpty()) {
            includePatterns.setSource(parserContext.extractSource(element));
            beanDef.getPropertyValues().add("includePatterns", includePatterns);
        }
    }

}

AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);

class AopNamespaceUtils 


public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            ParserContext parserContext, Element sourceElement) {
    /**
    parserContext.getRegistry() : DefaultListableBeanFactory，进行注册
    */
    BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    registerComponentIfNecessary(beanDefinition, parserContext);
}

AopConfigUtils

在此处将AnnotationAwareAspectJAutoProxyCreator进行注册

public abstract class AopConfigUtils

//source=null,registry=DefaultListableBeanFactory
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

//cls=AnnotationAwareAspectJAutoProxyCreator
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }
        return null;
    }
    //将cls传入生成一个RootBeanDefinition对象。
    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    beanDefinition.setSource(source);
    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    //将对象在registry中进行注册。
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    return beanDefinition;
}

DefaultListableBeanFactory

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
//将beanName放入其中。
private final List<String> beanDefinitionNames = new ArrayList<String>();
//将beanName和对应的对象放入其中。
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);

}

useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);

class AopNamespaceUtils

private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
    if (sourceElement != null) {
        //proxy-target-class
        boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
        if (proxyTargetClass) {
            //向RootDefinition中的MutablePropertyValues中的propertyValueList添加proxyTargetClass，true
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }
        //expose-proxy
        boolean exposeProxy = Boolean.valueOf(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
        if (exposeProxy) {
            //向RootDefinition中的MutablePropertyValues中的propertyValueList添加exposeProxy，true
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }
    }
}

registerComponentIfNecessary(beanDefinition, parserContext);

class AopNamespaceUtils
private static void registerComponentIfNecessary(BeanDefinition beanDefinition, ParserContext parserContext) {
    if (beanDefinition != null) {
        BeanComponentDefinition componentDefinition =
                new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
        parserContext.registerComponent(componentDefinition);
    }
}

AnnotationAwareAspectJAutoProxyCreator

在此处将进行AOP逻辑的分析
该类实现了BeanPostProcessor接口，

在Bean实例化的时候会调用下面的方法。
public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

调用postProcessAfterInitialization方法。
配置文件：

class AbstractAutoProxyCreator 

private final Map<Object, Class<?>> proxyTypes;
//{xprenc.test.AopTest_test=class xprenc.test.AopTest$$EnhancerByCGLIB$$6d6ea7a2}
private final Map<Object, Boolean> advisedBeans;
//{xprenc.test.AopTest_test=true}

//bean:test.AopTest,beanName:test,最终返回一个代理对象。
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean != null) {
        //cacheKey=test.AopTest_test
        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) {
    if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    //shouldSkip(bean.getClass(), beanName)方法初次将带Aspect注解的类和方法以及表达式存入到缓存中。
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // Create proxy if we have advice.
    //获取所有的增强器方法
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    //如果当前bean是符合aop规则的，则创建对应的代理，并返回代理。若不是，则返回bean。
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        //创建代理
        Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator

@Override
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    return advisors.toArray();
}

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    //获取缓存中保存的带有注解Aspectj的对象，若缓存没有，则循环查找带有AspectJ注解的对象，并放入缓存中。
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    /**查找当前的bean中是否存在同Aop表达式吻合的方法，若有，则最终放入InstantiationModelAwarePointcutAdvisor的pointcut属性的shadowMatchCase中。
    */
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    //集合中新增一个ExposeInvocationInterceptor
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

protected List<Advisor> findAdvisorsThatCanApply(
            List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {

    ProxyCreationContext.setCurrentProxiedBeanName(beanName);
    try {

        return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
    }
    finally {
        ProxyCreationContext.setCurrentProxiedBeanName(null);
    }
}

AopUtils

class AopUtils 

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
    if (candidateAdvisors.isEmpty()) {
        return candidateAdvisors;
    }
    List<Advisor> eligibleAdvisors = new LinkedList<Advisor>();
    for (Advisor candidate : candidateAdvisors) {
        if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
            eligibleAdvisors.add(candidate);
        }
    }
    boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    for (Advisor candidate : candidateAdvisors) {
        if (candidate instanceof IntroductionAdvisor) {
            // already processed
            continue;
        }
        //普通bean的处理
        if (canApply(candidate, clazz, hasIntroductions)) {
            eligibleAdvisors.add(candidate);
        }
    }
    return eligibleAdvisors;
}

//targetClass:class xprenc.test.AopTest, pc:AspectJExpressionPointcut: () test() 获取需要被处理的bean
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
    Assert.notNull(pc, "Pointcut must not be null");
    //AspectJExpressionPointcut: () test()
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }
    //AspectJExpressionPointcut: () test()
    MethodMatcher methodMatcher = pc.getMethodMatcher();
    IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
    if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
        introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
    }

    Set<Class<?>> classes = new HashSet<Class<?>>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
    classes.add(targetClass);
    for (Class<?> clazz : classes) {
        //获取目标class的所有方法
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            //如果获取到了同introductionAwareMethodMatcher表达式相匹配的方法，则return。
            if ((introductionAwareMethodMatcher != null &&
                    introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
                    methodMatcher.matches(method, targetClass)) {
                return true;
            }
        }
    }

    return false;
}

PointcutExpressionImpl

class PointcutExpressionImpl implements PointcutExpression

private Pointcut pointcut; //execution(* test(..))
private String expression; //test()

private ShadowMatch matchesExecution(Member aMember) {
    //method-execution(void xprenc.test.AopTest.test())
    Shadow s = ReflectionShadow.makeExecutionShadow(world, aMember, this.matchContext);
    //同pointcunt进行正则匹配
    ShadowMatchImpl sm = getShadowMatch(s);
    sm.setSubject(aMember);
    sm.setWithinCode(null);
    sm.setWithinType(aMember.getDeclaringClass());
    return sm;
}

class AspectJExpressionPointcut 

private transient PointcutExpression pointcutExpression; //PointcutExpressionImpl

private transient Map<Method, ShadowMatch> shadowMatchCache;//符合条件的方法会放入其中。

private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
    // Avoid lock contention for known Methods through concurrent access...
    ShadowMatch shadowMatch = this.shadowMatchCache.get(targetMethod);
    if (shadowMatch == null) {
        synchronized (this.shadowMatchCache) {
            // Not found - now check again with full lock...
            Method methodToMatch = targetMethod;
            PointcutExpression fallbackPointcutExpression = null;
            shadowMatch = this.shadowMatchCache.get(methodToMatch);
            if (shadowMatch == null) {
                try {
                    //将该方法生成对应的shadowMatch类
                    shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
                }
                catch (ReflectionWorld.ReflectionWorldException ex) {
                    // Failed to introspect target method, probably because it has been loaded
                    // in a special ClassLoader. Let's try the original method instead...
                    try {
                        fallbackPointcutExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
                        shadowMatch = fallbackPointcutExpression.matchesMethodExecution(methodToMatch);
                    } catch (ReflectionWorld.ReflectionWorldException e) {
                        if (targetMethod == originalMethod) {
                            shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
                        }
                        else {
                            try {
                                shadowMatch = this.pointcutExpression.matchesMethodExecution(originalMethod);
                            }
                            catch (ReflectionWorld.ReflectionWorldException ex2) {
                                // Could neither introspect the target class nor the proxy class ->
                                // let's simply consider this method as non-matching.
                                methodToMatch = originalMethod;
                                fallbackPointcutExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
                                try {
                                    shadowMatch = fallbackPointcutExpression.matchesMethodExecution(methodToMatch);
                                } catch (ReflectionWorld.ReflectionWorldException e2) {
                                    shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
                                }
                            }
                        }
                    }
                }
                if (shadowMatch.maybeMatches() && fallbackPointcutExpression!=null) {
                    shadowMatch = new DefensiveShadowMatch(shadowMatch,
                            fallbackPointcutExpression.matchesMethodExecution(methodToMatch));
                }
                //{public void xprenc.test.AopTest.test()=org.aspectj.weaver.reflect.ShadowMatchImpl@28d18df5}
                this.shadowMatchCache.put(targetMethod, shadowMatch);
            }
        }
    }
    return shadowMatch;
}

private void checkReadyToMatch() {
    if (getExpression() == null) {
        throw new IllegalStateException("Must set property 'expression' before attempting to match");
    }
    if (this.pointcutExpression == null) {
        this.pointcutExpression = buildPointcutExpression();
    }
}

BeanFactoryAspectJAdvisorsBuilder类

private final AspectJAdvisorFactory advisorFactory;//ReflectiveAspectJAdvisorFactory


//获取带有AspectJ注解的bean，并生成advisors放入缓存中，或者从缓存中查找。
public List<Advisor> buildAspectJAdvisors() {
    List<String> aspectNames = null;

    synchronized (this) {
        aspectNames = this.aspectBeanNames;
        if (aspectNames == null) {
            List<Advisor> advisors = new LinkedList<Advisor>();
            aspectNames = new LinkedList<String>();
            //将所有的beanName获取到。
            String[] beanNames =
                    BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
            for (String beanName : beanNames) {
                //过滤掉不合法的bean
                if (!isEligibleBean(beanName)) {
                    continue;
                }
                // We must be careful not to instantiate beans eagerly as in this
                // case they would be cached by the Spring container but would not
                // have been weaved
                Class<?> beanType = this.beanFactory.getType(beanName);
                if (beanType == null) {
                    continue;
                }
                //循环遍历，将带有Aspect注解的bean找出来。
                if (this.advisorFactory.isAspect(beanType)) {
                    aspectNames.add(beanName);
                    AspectMetadata amd = new AspectMetadata(beanType, beanName);
                    if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                        MetadataAwareAspectInstanceFactory factory =
                                new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                        //获取带有Aspectj中的增强方法。
                        List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                        if (this.beanFactory.isSingleton(beanName)) {
                            this.advisorsCache.put(beanName, classAdvisors);
                        }
                        else {
                            this.aspectFactoryCache.put(beanName, factory);
                        }
                        advisors.addAll(classAdvisors);
                    }
                    else {
                        // Per target or per this.
                        if (this.beanFactory.isSingleton(beanName)) {
                            throw new IllegalArgumentException("Bean with name '" + beanName +
                                    "' is a singleton, but aspect instantiation model is not singleton");
                        }
                        MetadataAwareAspectInstanceFactory factory =
                                new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                        this.aspectFactoryCache.put(beanName, factory);
                        advisors.addAll(this.advisorFactory.getAdvisors(factory));
                    }
                }
            }
            this.aspectBeanNames = aspectNames;
            return advisors;
        }
    }

    if (aspectNames.isEmpty()) {
        return Collections.emptyList();
    }
    List<Advisor> advisors = new LinkedList<Advisor>();
    for (String aspectName : aspectNames) {
        List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
        if (cachedAdvisors != null) {
            advisors.addAll(cachedAdvisors);
        }
        else {
            MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
            advisors.addAll(this.advisorFactory.getAdvisors(factory));
        }
    }
    return advisors;
}

ReflectiveAspectJAdvisorFactory类

//获取带有Aspectj中的增强方法。
@Override
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory maaif) {
    final Class<?> aspectClass = maaif.getAspectMetadata().getAspectClass();
    final String aspectName = maaif.getAspectMetadata().getAspectName();
    validate(aspectClass);

    // We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
    // so that it will only instantiate once.
    final MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
            new LazySingletonAspectInstanceFactoryDecorator(maaif);

    //筛选出带有注解的方法，并生成InstantiationModelAwarePointcutAdvisorImpl对象放入集合中。
    final List<Advisor> advisors = new LinkedList<Advisor>();
    //getAdvisorMethods筛选出不带有Pointcut注解的method
    for (Method method : getAdvisorMethods(aspectClass)) {
        //筛选出带有特定注解的方法，并生成对象。
        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }

    // If it's a per target aspect, emit the dummy instantiating aspect.
    if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
        Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
        advisors.add(0, instantiationAdvisor);
    }

    // Find introduction fields.
    for (Field field : aspectClass.getDeclaredFields()) {
        Advisor advisor = getDeclareParentsAdvisor(field);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }

    return advisors;
}

@Override
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aif,
        int declarationOrderInAspect, String aspectName) {

    validate(aif.getAspectMetadata().getAspectClass());

    AspectJExpressionPointcut ajexp =
            getPointcut(candidateAdviceMethod, aif.getAspectMetadata().getAspectClass());
    if (ajexp == null) {
        return null;
    }
    return new InstantiationModelAwarePointcutAdvisorImpl(
            this, ajexp, aif, candidateAdviceMethod, declarationOrderInAspect, aspectName);
}

private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
    AspectJAnnotation<?> aspectJAnnotation =
            AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
    if (aspectJAnnotation == null) {
        return null;
    }
    AspectJExpressionPointcut ajexp =
            new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
    ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
    return ajexp;
}

AbstractAspectJAdvisorFactory

//筛选出特定注解的方法，封装为AspectJAnnotation对象。
@SuppressWarnings("unchecked")
protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
    Class<?>[] classesToLookFor = new Class<?>[] {
            Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};
    for (Class<?> c : classesToLookFor) {
        AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) c);
        if (foundAnnotation != null) {
            return foundAnnotation;
        }
    }
    return null;
}

AbstractAutowireCapableBeanFactory类

此处在spring实例化bean的时候会进行再处理

class AbstractAutowireCapableBeanFactory 

/**existingBean：xprenc.test.AopTest@1a72a540，beanName：test
*/
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        //xprenc.test.AopTest@1a72a540 此处进行aop的处理，最终生成一个AopTest的代理对象
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
                invokeAwareMethods(beanName, bean);
                return null;
            }
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }

    if (mbd == null || !mbd.isSynthetic()) {
        //此处开始调用BeanPostProcessor的postProcessAfterInitialization
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

@Override
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
        throws BeanCreationException {

    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean '" + beanName + "'");
    }
    // Make sure bean class is actually resolved at this point.
    resolveBeanClass(mbd, beanName);

    // Prepare method overrides.
    try {
        mbd.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    try {
        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
        Object bean = resolveBeforeInstantiation(beanName, mbd);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "BeanPostProcessor before instantiation of bean failed", ex);
    }
    //在此处开始进行bean的后期创建。
    Object beanInstance = doCreateBean(beanName, mbd, args);
    if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}