EnableAspectJAutoProxy

使用AOP需要用到两个注解：

1.在配置类加上@EnableAspectJAutoProxy注解，开启基于注解的AOP模式

2.在切面类加上@Aspect注解，告诉Spring这是一个切面类

@EnableAspectJAutoProxy代码如下所示

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
	boolean proxyTargetClass() default false;
	boolean exposeProxy() default false;
}

该注解使用@Import注解导入了AspectJAutoProxyRegistrar这个类

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 查看这里面的代码可以发现
        // 它往ioc容器里面注入了 AnnotationAwareAspectJAutoProxyCreator 这个类
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        // 下面的暂时先不分析
        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }
}

AspectJAutoProxyRegistrar往ioc容器里面注入了AnnotationAwareAspectJAutoProxyCreator。

AnnotationAwareAspectJAutoProxyCreator继承了很多父类，如下所示

AnnotationAwareAspectJAutoProxyCreator
	extends AspectJAwareAdvisorAutoProxyCreator
  	extends AbstractAdvisorAutoProxyCreator
  		extends AbstractAutoProxyCreator
  			extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
  
SmartInstantiationAwareBeanPostProcessor
  extends InstantiationAwareBeanPostProcessor
  	extends BeanPostProcessor

上面的一些接口定义如下

BeanFactoryAware

public interface BeanFactoryAware extends Aware {
    void setBeanFactory(BeanFactory var1) throws BeansException;
}

BeanPostProcessor

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

InstantiationAwareBeanPostProcessor

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }
    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }
    // 剩下的方法省略
    // ......
}

SmartInstantiationAwareBeanPostProcessor

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
  	// ......
}

AbstractAutoProxyCreator

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    // 实现BeanFactoryAware的接口
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    // 实现 InstantiationAwareBeanPostProcessor 接口
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        // ......
    }
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true;
    }

    // 实现 BeanPostProcessor 接口
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        // ......
    }
}

AbstractAdvisorAutoProxyCreator

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
    // 重写了父类AbstractAutoProxyCreator#setBeanFactory(BeanFactory beanFactory)
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        super.setBeanFactory(beanFactory);
        if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
            throw new IllegalArgumentException(
                    "AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
        }
        initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
    }
    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
    }
}

AnnotationAwareAspectJAutoProxyCreator

public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
    // 重写父类 AbstractAdvisorAutoProxyCreator#initBeanFactory(ConfigurableListableBeanFactory beanFactory)
    @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);
    }
}

生成代理入口

前面分析Bean的实例化流程可以知道，Bean实例化的初始化操作会调用所有实现了BeanPostProcessor接口的postProcessAfterInitialization(Object bean, String beanName)方法，AOP就是在这个阶段来生成Bean的代理对象的，它根据扫描到的切面判断是否要为这个类生成代理对象。

下面来查看AbstractAutoProxyCreator#postProcessAfterInitialization方法

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        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) {
        // 省略......
        // 1. 为代理类找到增强方法
      	// 为这个 bean 获取advice方法，比如：@Aspect类里面的 @Before、@After
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        // specificInterceptors != DO_NOT_PROXY 说明这个bean存在代理方法
        if (specificInterceptors != DO_NOT_PROXY) {
          	// 保存这个bean被增强处理的状态
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            // 2. 产生代理对象
            // 内部可以通过 JDK 或者 CGLIB 生成代理对象。
            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;
    }
}

1.为代理类找到增强方法

// AbstractAdvisorAutoProxyCreator.java
// 给某个类找到所有的Advisor, Advisor保存的就是那些切面方法
// 如果没有找到则返回 DO_NOT_PROXY, 代表这个类初始化的时候不需要产生代理；
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
    Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    return advisors.toArray();
}

// AbstractAdvisorAutoProxyCreator.java
// 给这个类找到合适的 Advisor
// 根据我们配置的正则式判断哪些类需要哪些切面
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    // 这里是获取所有的 Advisor
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    // 根据我们配置的正则式来获取Advisor
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

获取到合适的切面方法将会创建代理对象

2.产生代理对象

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
  
    protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
                                 @Nullable Object[] specificInterceptors, TargetSource targetSource) {

        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }
        // 创建代理工厂
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);

        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        // 获取增强器方法
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        // 将增强方法设置到代理工厂中
        proxyFactory.addAdvisors(advisors);
        proxyFactory.setTargetSource(targetSource);
        // 定制化代理工厂，这里可以忽略
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        // 通过代理工厂帮我们创建代理对象
        return proxyFactory.getProxy(getProxyClassLoader());
    }
}

ProxyFactory

public class ProxyFactory extends ProxyCreatorSupport {
    public Object getProxy(@Nullable ClassLoader classLoader) {
        // createAopProxy() 是父类 ProxyCreatorSupport 的方法
      	// createAopProxy() 返回的是 AopProxy, 然后通过放回的是AopProxy.getProxy来生成代理对象
        return createAopProxy().getProxy(classLoader);
    }
}


public class ProxyCreatorSupport extends AdvisedSupport {
    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();
        }
        // getAopProxyFactory() 返回的是 AopProxyFactory, 默认类为DefaultAopProxyFactory
      	// 
        return getAopProxyFactory().createAopProxy(this);
    }
}

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
  	// 获取AOP的代理, JDK或者CGLIB 
    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            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)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }
}

原文链接：https://blog.csdn.net/lizc_lizc/article/details/105161088