标签：Object return Spring beanName bean Bean AnnotationAwareAspectJAutoProxyCreator A

本文能帮你回答以下几个问题；

AnnotationAwareAspectJAutoProxyCreator后置器的作用是什么?
Spring AOP自动增强bean是如何实现的。
如何在spring上下文添加AnnotationAwareAspectJAutoProxyCreator？
如何利用ProxyFactory硬编码实现一个bean的增强？
AnnotationAwareAspectJAutoProxyCreator是在bean的生命周期什么阶段完成bean的增强？

类的介绍

类的作用

AnnotationAwareAspectJAutoProxyCreator也是一个bean的后置处理器，是Spring AOP完成bean自动增强的关键类，用于在bean创建过程中扫描@Aspect注解的bean，创建Advisor，从而实现对bean的代理增强。

类继承关系

核心逻辑主要在AbstractAutoProxyCreator，bean后置器的相关方法都是在该抽象类实现的。

AbstractAutoProxyCreator继承的类主要是后置处理器接口SmartInstantiationAwareBeanPostProcessor以及支持代理的通用类ProxyProcessorSupport。

实现的后置器方法主要有predictBeanType、getEarlyBeanReference、postProcessBeforeInstantiation、postProcessAfterInitialization。

如何添加AnnotationAwareAspectJAutoProxyCreator

通过添加注解@EnableAspectJAutoProxy，Spring容器启动时就会自动扫描到该注解，从而添加AnnotationAwareAspectJAutoProxyCreator这个BeanPostProcessor。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

    /**
     * 是否基于类来创建代理，而不是基于接口来创建代理，
     * 当为true的时候会使用cglib来直接对目标类创建代理对象（cglib是基于类创建代理）
     * 默认为false，意味着当目标bean有接口，则用java动态代理创建，否则用cglib
     * */
    boolean proxyTargetClass() default false;

    /**
     * 是否需要将代理对象暴露在ThreadLocal中，当为true的时候
     * 可以通过org.springframework.aop.framework.AopContext#currentProxy获取当前代理对象
     */
    boolean exposeProxy() default false;

}

而@EnableAspectJAutoProxy注解上通过Import了AspectJAutoProxyRegistrar类，AspectJAutoProxyRegistrar类会调用AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry)，向BeanDefinitionRegistry中添加该BeanPostProcessor。

AOP相关知识点

在分析AnnotationAwareAspectJAutoProxyCreator的具体实现之前，我们先准备相关AOP的知识点。

Spring中AOP的几个概念

JoinPoint

连接点，连接点就是被拦截到的程序执行点，因为Spring只支持方法类型的连接点，所以在Spring中连接点就是被拦截到的方法。

Advice

通知，需要在目标对象中增强的功能，通知中有2个重要的信息：方法的什么地方，执行什么操作，这2个信息通过通知来指定。

在spring中接口定义是Advice，同时有不同子类用于在方法不同阶段做功能增强，对应注解通过@Before、@Around、@After、@AfterReturning、@AfterThrowing表示。

Pointcut

切入点，用来指定需要将通知使用到哪些地方，比如需要用在哪些类的哪些方法上，切入点就是做这个配置的，在Spring中对应接口Pointcut，对应注解@Pointcut

Advisor

切面，Pointcut与Advice组合在一起叫Advisor，代表在什么地方（Pointcut）添加什么样的增强功能（Advice），对应接口为Advisor，对应注解为@Aspect。

硬编码AOP实例

示例：在DemoService调用say方法前后增加开始和结束的输出逻辑，同时添加say方法调用的耗时。

代码说明：

通过定义好pointcut和Advice，然后组合得到Advisor，利用ProxyFactory，得到增强后的代理类。

static class DemoService{
    public void say(){
        System.out.println("hello word");
    }
}

@Test
public void  test4(){
    DemoService target = new DemoService();
    //定义pointcut
    Pointcut pointcut = new Pointcut() {

        //增强类的匹配规则
        @Override
        public ClassFilter getClassFilter() {
            return clazz -> DemoService.class.isAssignableFrom(clazz);
        }

        //增强方法的匹配规则
        @Override
        public MethodMatcher getMethodMatcher() {
            return new MethodMatcher() {
                //匹配方法名称
                @Override
                public boolean matches(Method method, Class<?> targetClass) {
                    return "say".equals(method.getName());
                }

                @Override
                public boolean isRuntime() {
                    return false;
                }

                @Override
                public boolean matches(Method method, Class<?> targetClass, Object... args) {
                    return false;
                }
            };
        }
    };
    //定义Advice，MethodInterceptor是Advice的子类，在方法前后增强
    MethodInterceptor advice = invocation -> {
        System.out.println("start");
        long starTime = System.nanoTime();
        //连接点执行
        Object result = invocation.proceed();
        long endTime = System.nanoTime();
        System.out.println("end！");
        System.out.println("耗时:" + (endTime - starTime));
        return result;
    };

    //创建Advisor，将pointcut和advice组装起来
    DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);

    //通过spring提供的代理创建工厂来创建代理
    ProxyFactory proxyFactory = new ProxyFactory();
    //为工厂指定目标对象
    proxyFactory.setTarget(target);
    //调用addAdvisor方法，为目标添加增强的功能，即添加Advisor，可以为目标添加很多个Advisor
    proxyFactory.addAdvisor(advisor);
    DemoService demoService = (DemoService) proxyFactory.getProxy();
    demoService.say();
}

输出：

start
hello word
end！
耗时:13044107

实现方法分析

predictBeanType

实例化前预测bean的类型，这里会从创建的代理缓存中获取bean，如果存在则返回代理的对象类型。

public Class<?> predictBeanType(Class<?> beanClass, String beanName) {
    if (this.proxyTypes.isEmpty()) {
        return null;
    }
    Object cacheKey = getCacheKey(beanClass, beanName);
    return this.proxyTypes.get(cacheKey);
}

getEarlyBeanReference

用于处理循环引用，这里不分析。

postProcessBeforeInstantiation

bean实例化前调用，主要是判断是否是要代理增强的bean，并缓存起来。

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    Object cacheKey = getCacheKey(beanClass, beanName);

    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        //如果是基础类（是指是否属于Advisor、Pointcut AOP等提供的基础类）
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
            //是，会把基础bean缓存起来，value为false（代表不是要增强的bean）
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }

    //省略部分代码

    return null;
}

判断是否是需要增强的bean

不是，会缓存到map，value记录为false。

if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

1）isInfrastructureClass

AnnotationAwareAspectJAutoProxyCreator覆写了该方法，增加了注解的判断逻辑，所有的判断逻辑为：

Advice.class.isAssignableFrom(beanClass) ||
Pointcut.class.isAssignableFrom(beanClass) ||
Advisor.class.isAssignableFrom(beanClass) ||
AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
(AnnotationUtils.findAnnotation(clazz, Aspect.class) != null && !compiledByAjc(clazz))

即是不是AOP的基础类，包括是否是基础类的实现或者是否是添加了@Aspect注解。

2）shouldSkip

AspectJAwareAdvisorAutoProxyCreator覆写了该方法，添加了findCandidateAdvisors逻辑，主要逻辑也在findCandidateAdvisors方法。

@Override
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
    // TODO: Consider optimization by caching the list of the aspect names
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    for (Advisor advisor : candidateAdvisors) {
        if (advisor instanceof AspectJPointcutAdvisor &&
            ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
            return true;
        }
    }
    return super.shouldSkip(beanClass, beanName);
}

findCandidateAdvisors主要做的事情是查找所有的Advisor，并缓存起来。

protected List<Advisor> findCandidateAdvisors() {
    // Add all the Spring advisors found according to superclass rules.
    //查找继承了Advisor的类
    List<Advisor> advisors = super.findCandidateAdvisors();
    // Build Advisors for all AspectJ aspects in the bean factory.
    if (this.aspectJAdvisorsBuilder != null) {
        //查找标注了@Aspect注解的类
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
    }
    return advisors;
}

postProcessAfterInitialization

bean初始化后调用，调用wrapIfNecessary来对bean进行代理增强，返回出去，这样拿到的bean实际是经过代理增强的bean。

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

AbstractAutoProxyCreator#wrapIfNecessary：

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)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    //前面判断是否是需要代理增强的类，是才会走到下面的逻辑
    // Create proxy if we have advice.
    //获取当前bean的advisors，也就是要针对当前bean增强的逻辑
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        //将当前bean标示为要代理增强的bean
        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;
}

主要做了3件事：

1）判断是否是需要增强的类。

2）是，则取得当前bean对应的advisor数组

AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean --> AbstractAdvisorAutoProxyCreator#findEligibleAdvisors



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();
}

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    //获取所有的Advisor
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    //获取与当前bean有关的Advisor
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        //按照规则对多个Advisor进行排序
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

3）根据拿到的advisor数组给当前bean创建代理。

AbstractAutoProxyCreator#createProxy

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 proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);

    if (!proxyFactory.isProxyTargetClass()) {
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        }
        else {
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }
    //准备好Advisor
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    //添加Advisors
    proxyFactory.addAdvisors(advisors);
    //设置目标对象
    proxyFactory.setTargetSource(targetSource);
    customizeProxyFactory(proxyFactory);

    proxyFactory.setFrozen(this.freezeProxy);
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }
    //创建代理类
    return proxyFactory.getProxy(getProxyClassLoader());
}

分析到这里，我们从beanFactory中获取的bean就是经过AOP增强的bean了。

总结

AnnotationAwareAspectJAutoProxyCreator实现了两个关键类SmartInstantiationAwareBeanPostProcessor和ProxyProcessorSupport。
通过实现postProcessBeforeInstantiation，在bean实例化前扫描@Aspect注解，解析到需要增强的Advisor，并缓存起来。
通过实现postProcessAfterInitialization，在bean初始化后，利用缓存的Advisor，创建代理类，完成bean的增强。

标签：Object,return,Spring,beanName,bean,Bean,AnnotationAwareAspectJAutoProxyCreator,A
From： https://www.cnblogs.com/xfeiyun/p/17922723.html

Spring的Bean后置处理器之AnnotationAwareAspectJAutoProxyCreator