Spring-AOP源码分析

一、概述

Spring的两大特性：IOC和AOP。

AOP是面向切面编程，Spring内置了自己实现的基于动态代理技术的AOP，同时还支持成熟的AspectJ框架，我们这里主要讲述的还是内置的基于动态代理的AOP实现。因为面对一些普通的需求，Spring内置的AOP已经绰绰有余。

AOP一般用于增强原来的代码的功能，这种增强体现在辅助方面，比如安全、日志、事务等。

二、术语

1、连接点（JoinPoint）

连接点就是具体的代码中的切入点，指的是具体的一处代码位置。

2、切点（PointCut）

切点是对一系列代表同种功能（目的）的切入点（连接点）的统称，切点不是一个点，而是代表某一功能的一系列连接点的集合。

3、通知（Advice）

通知就是我们要在切点执行的操作，就是我们要实现的目的，是要实现的功能的代码实现。一般通知又称为增强，所谓增强就是对原来功能的基础上添加新功能，进行功能增强。

4、切面（Aspect）

切面是通知和切点的综合体，定义好了一个切面，那么我们就知道，这个AOP要实现的功能是什么，需要切入到程序中的那些地方。抽象层次中，切面是代码功能的横切面，这个横切面的位置就是切点、这个切面的功能就是通知。

5、织入（Weaving）

织入就是切面作用到目标代码中的方式，Spring内置的AOP采用的是动态代理的方式来织入，还可以采用编译器织入和加载期织入，后两者分别需要特定的编译器和类加载器来完成，后两种方式是AspectJ所支持的织入方式。

6、引介（Introduction）

引介是另一种类型的增强，它可以为类添加一些属性和方法。它和通知是并列的两种不同的增强。

7、目标对象（Target）

目标对象就是我们想要织入的对象，一般不会是一个，通常是一批符合条件的对象。

8、代理（Proxy）

代理就好理解了，Spring内置的AOP就是通过动态代理的方式实现织入的，创建目标对象的代理类，在代理类中执行通知的内容，然后在合适的位置调用目标对象的方法，来达到织入的目的。

三、Spring AOP概述

Spring AOP是基于动态代理技术实现的切面编程，代理技术包括JDK动态代理和CGLIB动态代理，前者基于接口实现，后者基于类实现。

1、Spring中使用AOP技术的方式：

1）定义切面类，使用@Aspect注解

2）在切面类中定义切点方法，使用@PointCut注解

3）在切面类中定义通知方法，使用@Before、@After、@Around等注解

4）在通知方法的注解中使用切点方法

5）在切面类上加设注解@Component

6）启动AOP功能，两种方式：原始的XML配置方式和注解方式

XMl方式：aop:aspectj-autoproxy/

注解方式：@EnableAspectJAutoProxy

配置方式：spring.auto.proxy=true

2、Spring AOP支持的增强类型

通知增强：Advice

前置通知：MethodBeforeAdvice-在连接点之前执行

后置通知：AfterReturningAdvice-在连接点正常执行完后执行，如果还未到连接点就异常，不会执行

环绕通知：AroundAdvice-在连接点前后执行

异常通知：AfterThrowingAdvice-在连接点抛出异常后执行

finally通知：AfterAdvice-最终执行，无论是否异常，方法执行结束都会执行

引介增强：IntroductionInterceptor->DelegatingIntroductionInterceptor

前五种很好理解，重点是最后一种引介增强，这种增强并不是针对方法的增强，而是针对类的增强，它会为目标添加属性和方法，比如它可以为目标类添加一个接口的实现。目标类原本没有实现某个接口，但是我们可以使用引介增强的方式为目标类创建一个实现该接口的代理，在这个代理中可以使用接口的功能来作用于目标对象。

3、原理图

四、源码分析

1、入口

1.1 入口一：aop:aspectj-autoproxy/

源码1-来自：AopNamespaceHandler

@Override
    public void init() {
        // In 2.0 XSD as well as in 2.1 XSD.
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        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());
    }

上面源码就是针对XML配置中aop:XXX/配置的解析，红色部分正是针对aop:aspectj-autoproxy/的解析，如果配置了aspectj-autoproxy，则注册Bean定义解析器：AspectJAutoProxyBeanDefinitionParser。

AspectJAutoProxyBeanDefinitionParser是一个实现了BeanDefinitionParser接口的类，专门用于解析切面自动代理的Bean定义的解析工作，重点在其parse方法。

源码2-来自：AspectJAutoProxyBeanDefinitionParser

class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {
 
    @Override
    @Nullable
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        // 1-注册AnnotationAwareAspectJAutoProxyCreator
        AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
        // 2-扩展BeanDefinition
        extendBeanDefinition(element, parserContext);
        return null;
    }
 
    private void extendBeanDefinition(Element element, ParserContext parserContext) {
        // 获取BeanName为internalAutoProxyCreator的BeanDefinition，其实就是之前注册的自动代理构建器
        BeanDefinition beanDef =
                parserContext.getRegistry().getBeanDefinition(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
        if (element.hasChildNodes()) {
            // 如果当前元素有子节点，则给上面获取的Bean定义添加子节点中明确定义的类型值（填充BeanDefinition）
            addIncludePatterns(element, parserContext, beanDef);
        }
    }
 
    private void addIncludePatterns(Element element, ParserContext parserContext, BeanDefinition beanDef) {
        ManagedList includePatterns = new ManagedList<>();
        NodeList childNodes = element.getChildNodes();//获取子节点
        for (int i = 0; i < childNodes.getLength(); i++) {
            // 遍历子节点，获取子节点中name属性值，封装到TypeStringValue中
            // 在上下文中提取子节点includeElement的元数据保存到TypedStringValue的source属性中
            // 最后封装好的TypeStringValue保存到includePatterns列表中
            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()) {
            // 从解析上下文parserContext中提取指定节点element的元数据保存到includePatterns的source属性中，
            // 然后将includePatterns保存到BeanDefinition的propertyValues属性中
            includePatterns.setSource(parserContext.extractSource(element));
            beanDef.getPropertyValues().add("includePatterns", includePatterns);
        }
    }
 
}

上面代码中有两个重点，首先就是registerAspectJAnnotationAutoProxyCreatorIfNecessary方法调用，用于注册AnnotationAwareAspectJAutoProxyCreator构建器；另一点就是在构建器注册完成后，为其填充一些必要内容，这些内容为XML配置中子节点的配置内容，具体内容参照源码，这里重点看看第一步，注册构建器的源码：

源码3-来自：AopNamespaceUtils

public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            ParserContext parserContext, Element sourceElement) {
        // 1-注册或升级AnnotationAwareAspectJAutoProxyCreator
        // parserContext.getRegistry()获取到的是BeanDefinitionRegistry注册器，第二个参数是提取的指定元素的元数据
        BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
                parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        // 2-校验并设置是否适用基于CGLIB的动态代理实现AOP，和是否要暴露代理类
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        // 3-注册成组件
        registerComponentIfNecessary(beanDefinition, parserContext);
    }
 
    private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
        if (sourceElement != null) {
            boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));//获取XML中设置的proxy-target-class属性的值，解析为Boolean值
            if (proxyTargetClass) {
                // 如果为true，则强制自动代理构建器使用基于类的动态代理CGLIB，需要将属性设置到自动代理构建器的BeanDefinition中
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));//获取XML中配置的expose-proxy属性的值，同样解析为Boolean值
            if (exposeProxy) {
                // 如果为true，强制自动代理构建器暴露代理类，需要将属性设置到自动代理构建器的BeanDefinition中
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }
 
    private static void registerComponentIfNecessary(@Nullable BeanDefinition beanDefinition, ParserContext parserContext) {
        if (beanDefinition != null) {
            // 将自动代理构建器包装成为一个Bean组件定义。
            // Bean组件定义是将一个BeanDefinition中包含的所有的属性的值（可能为一个BeanDefinition或者BeanReference）全部封装起来成为一个组件包，然后将其注册到解析上下文中
            BeanComponentDefinition componentDefinition =
                    new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
            parserContext.registerComponent(componentDefinition);
        }
    }

registerAspectJAnnotationAutoProxyCreatorIfNecessary方法中主要做了三件事情：

1-注册构建器

2-配置属性

3-组件注册

针对第2和第3，在源码注释中解释的很清楚啦，主要看看第一步，继续进行构建器的注册：

源码4-来自：AopConfigUtils

public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
            //如果构建器已经加载，获取其BeanDefinition，添加属性proxyTargetClass，值为true
            BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
            definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
        }
    }
 
    public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
            //如果构建器已经加载，获取其BeanDefinition，添加属性exposeProxy，值为true
            BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
            definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
        }
    }
 
    @Nullable
    private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry,
            @Nullable Object source) {
 
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
 
        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
            // 1-如果internalAutoProxyCreator已经被注册那么比较新旧自动代理构建器类在列表中的优先级，如果已注册的构建器优先级低，则替换为给定的新构建器
            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;
        }
        // 尚未注册internalAutoProxyCreator的情况下，将给定的构建器包装成RootBeanDefinition，然后注册这个BeanDefinition
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        // 把元数据保存到BeanDefinition中
        beanDefinition.setSource(source);
        // 设置为最高优先值
        beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
        // 设置为基础角色
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        // 2-以internalAutoProxyCreator为beanName注册当前BeanDefinition（AnnotationAwareAspectJAutoProxyCreator类）
        registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
        return beanDefinition;
    }

源码4中前两个方法时源码3中第二步里面配置属性时调用的方法，在此给出。

源码4的1-中是在已存在一个自动代理构建器的情况下，将其与新的给定的AnnotationAwareAspectJAutoProxyCreator构建器的优先级进行比对，取优先极高的。

最后的registerBeanDefinition方法用于注册BeanDefinition。至此，自动代理构建器加载完毕。

1.2 入口二：@EnableAspectJAutoProxy

源码5-来自：EnableAspectJAutoProxy

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
 
    /**
     * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
     * to standard Java interface-based proxies. The default is {@code false}.
     */
    boolean proxyTargetClass() default false;
 
    /**
     * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
     * for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
     * Off by default, i.e. no guarantees that {@code AopContext} access will work.
     * @since 4.3.1
     */
    boolean exposeProxy() default false;
 
}

源码中重点关注@Import(AspectJAutoProxyRegistrar.class)，很明显这个注解导入了一个新类：AspectJAutoProxyRegistrar。

使用@Import注解导入的方式可以将一个类注册到BeanFactory中。

源码6-来自AspectJAutoProxyRegistrar

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
 
    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 1-注册或升级自动代理构建器
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        // 2-封装注解属性，并根据属性进行配置
        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }
 
}

我们可以从源码5中看到注解@EnableAspectJAutoProxy内部有两个属性设置proxyTargetClass和exposeProxy，这个之前的入口一中源码3里面的2-中的设置是一样的，即我们在XML启动AOP的时候也可以设置这两个值。

proxyTargetClass属性表示是否适用基于类的的动态代理CGLIB来创建代理类。true表示使用，false表示不使用，默认是false。

exposeProxy属性表示是否暴露生成的代理类，暴露就是可手动调用，最常见的情况如，在一个类中使用this调用带有@Transactional注解的方法，你会发现事务是不生效的，这时候我们就可以将生成的代理暴露出来手动调用代理类来保证事务生效：

如下例子中：

public interface TestService {
    void testMethod1();
    void testMethod2();
 }

public class TestServiceImpl {
 
    @Transactional
    public void testMethod1(){
        //some transaction operate    
    }
 
    public void testMethod2(){
        this.testMethod1();
    }
}

在testMethod2中以this.testMethod1()方式调用带事务注解的testMethod1方法时，其事务是不生效的。修改方式就是将exposeProxy设置为true，然后修改调用方式为：

1
((TestService)AopContext.currnetProxy()).testMethod1();
源码6中1-调用的是AopConfigUtils中的方法：

源码7-来自：AopConfigUtils

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}

然后它再调用的就是源码4中的源码了，到这里调用的就是公共部分啦。那么这一部分也就到此为止了，其余见源码4之后的部分。

到此两个主要的入口都分析完毕，入口的主要作用就是注册或者升级自动代理构建器，因为之后AOP的操作基本都要依靠这个构建器来完成。

2、创建AOP代理

我们的重点就是构建器AnnotationAwareAspectJAutoProxyCreator，分析下其继承结构，你会发现它实现了BeanPostProcessor接口。

BeanPostProcessor接口有两个方法：

postProcessBeforeInitialization：Bean实例初始化前调用

postProcessAfterInitialization：Bean实例初始化之后调用

然后我们在其继承体系中寻找实现这两个方法的类，一番寻找后发现：AbstractAutoProxyCreator

源码8-来自：AbstractAutoProxyCreator

@Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
        if (bean != null) {
            // 1-生成缓存key
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            // 校验该key是否已存在于earlyProxyReferences缓存
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                // 2-执行创建代理对象
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

我们发现了这个方法的实现，这个方法会在构建器Bean初始化之后被调用。我们看看它做了啥？

重点就是wrapIfNecessary方法，这个方法用于代理对象的生成。

源码9-来自：AbstractAutoProxyCreator

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            // 已经处理过，直接返回
            return bean;
        }
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            // 如果不需要增强，直接返回
            return bean;
        }
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        　　 // 检测目标类是否是AOP的基础设施类,基础设施类包括Advice、Pointcut、Advisor、AopInfrastructureBean，或者是否需要跳过代理，如果是则将其设置为无需增强
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
 
        // Create proxy if we have advice.
        // 1-获取针对当前Bean的增强
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            // 如果获取到增强则执行下面的创建代理
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            // 2-创建代理
            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;
    }

上面的源码中除了进行一些必要的校验之外，主要的逻辑是获取针对当前Bean的增强和创建代理这两步。

首先来看下如何获取增强

源码10-来自：AbstractAdvisorAutoProxyCreator

//获取通知（增强）
    @Override
    @Nullable
    protected Object[] getAdvicesAndAdvisorsForBean(
            Class beanClass, String beanName, @Nullable TargetSource targetSource) {
 
        List advisors = findEligibleAdvisors(beanClass, beanName);
        if (advisors.isEmpty()) {
            return DO_NOT_PROXY;
        }
        return advisors.toArray();
    }

源码11-来自：AbstractAdvisorAutoProxyCreator

protected List findEligibleAdvisors(Class beanClass, String beanName) {
        // 1-先获取所有的增强器列表
        List candidateAdvisors = findCandidateAdvisors();
        // 2-获取应用到当前目标类的增强器列表
        List eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        //这个方法是一个钩子方法，用于子类重写扩展
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);//排序
        }
        return eligibleAdvisors;
    }

上面的源码我们重点关注findCandidateAdvisors方法和findAdvisorsThatCanApply方法，分别用于找出BeanFactory中所有的可用的增强器，和从可用增强器中找出作用于目标类的增强器。

源码12-来自：AbstractAdvisorAutoProxyCreator

 protected List findCandidateAdvisors() {
     Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
      return this.advisorRetrievalHelper.findAdvisorBeans();
  }

源码13-来自：BeanFactoryAdvisorRetrievalHelper

public List findAdvisorBeans() {
        // Determine list of advisor bean names, if not cached already.
        String[] advisorNames = null;
        synchronized (this) {
            advisorNames = this.cachedAdvisorBeanNames;
            if (advisorNames == null) {
                // Do not initialize FactoryBeans here: We need to leave all regular beans
                // uninitialized to let the auto-proxy creator apply to them!
                // 1-获取当前BeanFactory及其继承体系中的容器中所有的Advisor类型的Bean的BeanName数组，排除掉FactoryBeans
                advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                        this.beanFactory, Advisor.class, true, false);
                this.cachedAdvisorBeanNames = advisorNames;
            }
        }
        if (advisorNames.length == 0) {
            return new LinkedList<>();
        }
 
        List advisors = new LinkedList<>();
        for (String name : advisorNames) {
            if (isEligibleBean(name)) {
                // 2-再排除创建中的Bean
                if (this.beanFactory.isCurrentlyInCreation(name)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Skipping currently created advisor '" + name + "'");
                    }
                }
                else {
                    try {
                        // 3-把剩下的Bean添加到通知（增强器）列表中
                        advisors.add(this.beanFactory.getBean(name, Advisor.class));
                    }
                    catch (BeanCreationException ex) {
                        Throwable rootCause = ex.getMostSpecificCause();
                        if (rootCause instanceof BeanCurrentlyInCreationException) {
                            BeanCreationException bce = (BeanCreationException) rootCause;
                            String bceBeanName = bce.getBeanName();
                            if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
                                if (logger.isDebugEnabled()) {
                                    logger.debug("Skipping advisor '" + name +
                                            "' with dependency on currently created bean: " + ex.getMessage());
                                }
                                // Ignore: indicates a reference back to the bean we're trying to advise.
                                // We want to find advisors other than the currently created bean itself.
                                continue;
                            }
                        }
                        throw ex;
                    }
                }
            }
        }
        return advisors;
    }

这段源码看起来挺复杂，我们去掉一些不必要的内容，总结起来，总共三件事：

1-获取容器中所有的Advisor，排除FactoryBeans

2-再排除创建中的Bean

3-将剩余的Advisor通过getBean创建Bean实例并添加到列表中返回

至于再下一步的逻辑就不再探寻啦。

然后是源码11中的2-findAdvisorsThatCanApply方法

源码14-来自：AbstractAdvisorAutoProxyCreator

protected List findAdvisorsThatCanApply(
            List candidateAdvisors, Class beanClass, String beanName) {
 
        // 将代理的目标Bean的beanName设置到ThreadLocal中
        ProxyCreationContext.setCurrentProxiedBeanName(beanName);
        try {
            // 1-在候选增强器中找出可作用于目标Bean的增强器
            return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
        }
        finally {
            ProxyCreationContext.setCurrentProxiedBeanName(null);
        }
    }

重点操作就是AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);用于找出能作用于目标Bean的增强器列表

源码15-来自：AopUtils

public static List findAdvisorsThatCanApply(List candidateAdvisors, Class clazz) {
        if (candidateAdvisors.isEmpty()) {
            return candidateAdvisors;
        }
        List eligibleAdvisors = new LinkedList<>();
        for (Advisor candidate : candidateAdvisors) {
            if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
                // 1-首先添加引介增强
                eligibleAdvisors.add(candidate);
            }
        }
        boolean hasIntroductions = !eligibleAdvisors.isEmpty();
        for (Advisor candidate : candidateAdvisors) {
            if (candidate instanceof IntroductionAdvisor) {
                // already processed
                //跳过引介增强
                continue;
            }
            //校验其余增强器是否能应用到目标Bean
            if (canApply(candidate, clazz, hasIntroductions)) {
                // 2-添加通知增强
                eligibleAdvisors.add(candidate);
            }
        }
        return eligibleAdvisors;
    }

源码中可以看出来，这里针对了两种类型的增强器（引介增强和通知增强）分别进行了处理，首先处理了引介增强，然后是通知增强。

这里有两个canApply方法，第一个用于判断引介增强是否能作用到目标类，第二个用于判断通知增强是否能作用到目标类。

其实第一个是通过调用第二个实现的。

我觉得我们可以简单看看其实现逻辑：

源码16-来源：AopUtils

//用于校验引介增强
    public static boolean canApply(Advisor advisor, Class targetClass) {
        return canApply(advisor, targetClass, false);
    }
 
    //用于校验通知增强
    public static boolean canApply(Advisor advisor, Class targetClass, boolean hasIntroductions) {
        if (advisor instanceof IntroductionAdvisor) {
            return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);// 针对引介增强的类级匹配校验
        }
        else if (advisor instanceof PointcutAdvisor) {
            PointcutAdvisor pca = (PointcutAdvisor) advisor;
            return canApply(pca.getPointcut(), targetClass, hasIntroductions);// 针对通知增强的匹配校验
        }
        else {
            // It doesn't have a pointcut so we assume it applies.
            return true;
        }
    }
 
    // 针对通知增强的匹配校验
    public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) {
        Assert.notNull(pc, "Pointcut must not be null");
        if (!pc.getClassFilter().matches(targetClass)) {
            return false;// 针对通知增强的类级匹配校验，如果类级校验不通过，直接驳回
        }
　　　　 
        MethodMatcher methodMatcher = pc.getMethodMatcher();// 获取方法匹配器
        if (methodMatcher == MethodMatcher.TRUE) {// 获取方法匹配器匹配的是所有方法，这里直接返回true，不必要做校验
            // No need to iterate the methods if we're matching any method anyway...
            return true;
        }
 
        IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
        if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
            introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
        }
 
        Set> classes = new LinkedHashSet<>();
        if (!Proxy.isProxyClass(targetClass)) {
            classes.add(ClassUtils.getUserClass(targetClass));
        }
        classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
 
        for (Class clazz : classes) {
            Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
            for (Method method : methods) {
                if (introductionAwareMethodMatcher != null ?
                        introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                        methodMatcher.matches(method, targetClass)) {
　　　　　　　　　　　　// 方法匹配校验
                    return true;
                }
            }
        }
 
        return false;
    }

上面的源码中用于判断增强是否与给定的类匹配，用了多个matches方法，包括ClassFilter的matches方法，IntroductionAwareMethodMatcher的matches方法和MethodMatcher中的matches方法。

第一个matches匹配的是类，第二、三个matches匹配的是方法。其中引介增强针对的是类，所以其校验仅仅使用类级匹配进行校验，但是通知增强针对的是类中的方法，需要进行类和方法的双重匹配校验。

然后返回到源码9中，我们开始生成代理：

源码17-来自：AbstractAutoProxyCreator

protected Object createProxy(Class beanClass, @Nullable String beanName,
            @Nullable Object[] specificInterceptors, TargetSource targetSource) {
 
        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            //暴露目标类，将其保存到BeanDefinition中
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }
 
        //创建一个新的代理工厂，并为其拷贝当前类中的相关配置属性
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);
 
        if (!proxyFactory.isProxyTargetClass()) {
            //校验proxyTargetClass设置，如果设置不是直接代理目标类，则采用默认的JDK动态代理指定接口
            if (shouldProxyTargetClass(beanClass, beanName)) {
                //校验该Bean的BeanDefinition中的preserveTargetClass属性，是否被代理工厂设置为true，如果设置为true，则表示代理工厂希望代理类可以强转为目标类
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                //否则表示基于接口创建代理
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }
 
        //将拦截器封装成通知
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        proxyFactory.addAdvisors(advisors);//加入增强器
        proxyFactory.setTargetSource(targetSource);//设置要代理的类
        customizeProxyFactory(proxyFactory);//子类定制代理
        //用于控制代理工厂被配置之后，是否还允许修改通知，默认为false（表示不允许修改）
        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }
        //创建代理
        return proxyFactory.getProxy(getProxyClassLoader());
    }

源码中执行了一大串的工作，都在为最后的创建代理做准备：

源码18-来自：ProxyFactory

public Object getProxy(@Nullable ClassLoader classLoader) {
       //创建AOP代理，并获取代理对象
    return createAopProxy().getProxy(classLoader);
  }

源码19-来自：ProxyCreatorSupport

protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();//激活开关
        }
        // 获取AOP代理工厂，使用AOP代理工厂创建AOP代理
        return getAopProxyFactory().createAopProxy(this);
    }
 
    private void activate() {
        this.active = true;
        // 回调监听器的activated方法
        for (AdvisedSupportListener listener : this.listeners) {
            listener.activated(this);
        }
    }
 
    public AopProxyFactory getAopProxyFactory() {
        return this.aopProxyFactory;
    }

重点在createAopProxy方法：

源码20-来自：DefaultAopProxyFactory

@Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            // 如果代理需要执行优化或者proxyTargetClass=true或者不存在代理接口
            Class targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                //如果目标类是接口或者是动态生成的代理类，则使用JDK动态代理
                return new JdkDynamicAopProxy(config);
            }
            //创建CGLIB动态AOP代理对象
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            //创建JDK动态AOP代理对象
            return new JdkDynamicAopProxy(config);
        }
    }

至此，代理对象生成，至于是使用JDK动态代理，还是Cglib动态代理，机理如下：

如果目标类实现了接口，默认使用JDK动态代理

如果目标类实现了接口，可以强制使用Cglib动态代理

如果目标没有实现接口，必须采用Cglib动态代理

至于如何强制使用Cglib动态代理：

首先需要添加CGLIB库，然后设置proxyTargetClass置为true，进行强制使用基于类的CGLIB动态代理。

JDK动态代理和Cglib动态代理的区别：

JDK动态代理只能基于接口生成代理，方式是通过实现JDK提供的InvocationHandler接口中的invoke方法来实现针对目标类指定方法的代理调用。

CGLIB可以基于类生成代理，方式是通过对目标类生成一个子类，覆盖其中的方法。

返回到源码18中，创建了AOP代理之后，执行其getProxy方法：（我们看下JDK动态代理的实现）

源码21-来自：JdkDynamicAopProxy

@Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }
        // 1-获取用于代理的全部接口的集合（数组）
        Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        // 2-查找接口集合中可能定义的equals方法获取hashCode方法
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        // 3-创建指定接口的代理实例
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

上面的代理主要做了三件事情：

1-首先获取用于代理的全部接口集；

2-然后查找该接口集中有无定义equals和hashCode方法；

3-最后执行代理实例的创建。

首先看下第一件事情：completeProxiedInterfaces

源码22-来自：AopProxyUtils

// 获取用于代理的接口的集合
    static Class[] completeProxiedInterfaces(AdvisedSupport advised, boolean decoratingProxy) {
        // 获取配置中所有的接口
        Class[] specifiedInterfaces = advised.getProxiedInterfaces();
        if (specifiedInterfaces.length == 0) {
            // No user-specified interfaces: check whether target class is an interface.
            Class targetClass = advised.getTargetClass();
            if (targetClass != null) {
                if (targetClass.isInterface()) {
                    advised.setInterfaces(targetClass);
                }
                else if (Proxy.isProxyClass(targetClass)) {
                    advised.setInterfaces(targetClass.getInterfaces());
                }
                specifiedInterfaces = advised.getProxiedInterfaces();
            }
        }
        // 将SpringProxy、Advised、DecoratingProxy三个接口添加到接口集中
        boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
        boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);
        boolean addDecoratingProxy = (decoratingProxy && !advised.isInterfaceProxied(DecoratingProxy.class));
        int nonUserIfcCount = 0;
        if (addSpringProxy) {
            nonUserIfcCount++;
        }
        if (addAdvised) {
            nonUserIfcCount++;
        }
        if (addDecoratingProxy) {
            nonUserIfcCount++;
        }
        Class[] proxiedInterfaces = new Class[specifiedInterfaces.length + nonUserIfcCount];
        System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
        int index = specifiedInterfaces.length;
        if (addSpringProxy) {
            proxiedInterfaces[index] = SpringProxy.class;
            index++;
        }
        if (addAdvised) {
            proxiedInterfaces[index] = Advised.class;
            index++;
        }
        if (addDecoratingProxy) {
            proxiedInterfaces[index] = DecoratingProxy.class;
        }
        return proxiedInterfaces;
    }

下面我们再看看之前的第二步：findDefinedEqualsAndHashCodeMethods

源码23-来自：JdkDynamicAopProxy

private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
        for (Class proxiedInterface : proxiedInterfaces) {
            Method[] methods = proxiedInterface.getDeclaredMethods();
            for (Method method : methods) {
                // 遍历每一个接口，再获取其中的方法进行遍历，逐个校验其是否是equals方法，或者hashCode方法，只有当二者都被定义之后校验才会结束，否则一直进行下去
                if (AopUtils.isEqualsMethod(method)) {
                    this.equalsDefined = true;
                }
                if (AopUtils.isHashCodeMethod(method)) {
                    this.hashCodeDefined = true;
                }
                if (this.equalsDefined && this.hashCodeDefined) {
                    return;
                }
            }
        }
    }

最后就是我们的重点步骤：Proxy.newProxyInstance(classLoader, proxiedInterfaces, this)，这个操作大家都不会陌生，这是JDK动态代理创建代理类的通用方式。这个方法的参数列表中最后一个是一个大家都很熟悉的家伙：InvocationHandler，我们都知道JDK动态代理的执行逻辑都是在一个实现了InvocationHandler接口中的invoke方法中，这里传入this，表示当前实例，代表当前实例所属类应该实现了InvocationHandler接口，之前已经成功创建了JDK动态代理对象，那么当我们发生对指定目标方法的调用时，就会触发JdkDynamicAopProxy中的invoke方法：

源码24-来自：JdkDynamicAopProxy

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    ...
}

这也就是说，这个类中必然实现了invoke方法：

源码25-来自：JdkDynamicAopProxy

@Override
    @Nullable
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation;
        Object oldProxy = null;
        boolean setProxyContext = false;
 
        TargetSource targetSource = this.advised.targetSource;
        Object target = null;
 
        try {
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // The target does not implement the equals(Object) method itself.
                // 目标类体系中未实现equals方法，但是代理的目标方法却是equals方法
                return equals(args[0]);
            }
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // The target does not implement the hashCode() method itself.
                // 目标类体系中未实现hashCode方法，但是代理的目标方法却是hashCode方法
                return hashCode();
            }
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                // There is only getDecoratedClass() declared -> dispatch to proxy config.
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            // isAssignableFrom方法的意义：调用方如果是参数方的同类（接口）或者父类（接口），则返回true
            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // Service invocations on ProxyConfig with the proxy config...
                // 直接反射调用目标方法
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }
 
            Object retVal;
 
            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                // 如果设置了exposeProxy=true，那么就代理保存起来备用
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
 
            // Get as late as possible to minimize the time we "own" the target,
            // in case it comes from a pool.
            target = targetSource.getTarget();
            Class targetClass = (target != null ? target.getClass() : null);
 
            // Get the interception chain for this method.
            // 1-获取目标方法的拦截链
            List