Spring AOP 学习记录2

主题

补充学习一下一些关于Spring AOP的理解

怎么找到当前Bean可以哪些advisor应用

在当前Bean被AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInitialization方法处理的过程中

会需要找到当前Bean可以被应用到的所有advisor.

 

 看代码也知道大致的步骤:

1.findCandidateAdvisors 找到所有的advisor

2.findAdvisorsThatCanApply 过滤出可以使用的advisor

findCandidateAdvisors

如何找到所有advisor?

/**
     * Look for AspectJ-annotated aspect beans in the current bean factory,
     * and return to a list of Spring AOP Advisors representing them.
     * <p>Creates a Spring Advisor for each AspectJ advice method.
     * @return the list of {@link org.springframework.aop.Advisor} beans
     * @see #isEligibleBean
     */
    public List<Advisor> buildAspectJAdvisors() {
        List<String> aspectNames = this.aspectBeanNames;

        if (aspectNames == null) {
            synchronized (this) {
                aspectNames = this.aspectBeanNames;
                if (aspectNames == null) {
                    List<Advisor> advisors = new ArrayList<>();
                    aspectNames = new ArrayList<>();
                    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                            this.beanFactory, Object.class, true, false);
                    for (String beanName : beanNames) {
                        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;
                        }
                        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);
                                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 ArrayList<>();
        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;
    }

BF中取到所有的BeanName,并遍历.对于每个BeanName,找到对应的Type(Class).再去找它这个类是否有Aspect.class的注解

 从中我们可以看出我们如果要使用AOP有什么样的条件:

1.这个Aspect的类应该要被当做Bean.不然BF中里没有这个Bean的定义.不管是在XML里直接定义BeanDifination还是@Component都OK.

2.这个类应该要有@Aspect.不然怎么知道这个是一个aspect呢.(其实还有一种是compiledByAjc(clazz)..没用过.不清楚怎么用)

找到了Aspect的类以后只要提取其中的advisor即可. List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);

大致核心如下:

对于类的每个没有标记@PointCut的方法

        for (Method method : getAdvisorMethods(aspectClass)) {
            Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }

    private List<Method> getAdvisorMethods(Class<?> aspectClass) {
        final List<Method> methods = new ArrayList<>();
        ReflectionUtils.doWithMethods(aspectClass, method -> {
            // Exclude pointcuts
            if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
                methods.add(method);
            }
        }, ReflectionUtils.USER_DECLARED_METHODS);
        methods.sort(METHOD_COMPARATOR);
        return methods;
    }

找到这个方法上的Aspect注解(@before..@after...@around...).从中提取出pointcut的表达式即可.

Advisor = advise(你的asperct类里的方法) + pointcut(表达式)

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

        validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());

        AspectJExpressionPointcut expressionPointcut = getPointcut(
                candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
        if (expressionPointcut == null) {
            return null;
        }

        return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
                this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    }

    @Nullable
    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());
        if (this.beanFactory != null) {
            ajexp.setBeanFactory(this.beanFactory);
        }
        return ajexp;
    }

    /**
     * Find and return the first AspectJ annotation on the given method
     * (there <i>should</i> only be one anyway...).
     */
    @SuppressWarnings("unchecked")
    @Nullable
    protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
        for (Class<?> clazz : ASPECTJ_ANNOTATION_CLASSES) {
            AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) clazz);
            if (foundAnnotation != null) {
                return foundAnnotation;
            }
        }
        return null;
    }

    private static final Class<?>[] ASPECTJ_ANNOTATION_CLASSES = new Class<?>[] {
            Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class};

最后封装成InstantiationModelAwarePointcutAdvisorImpl并返回.

findAdvisorsThatCanApply

这里没有太多神奇的操作.

找到所有的advisor以后就是判断每个advisor能不能作用到当前的类上. 怎么判断的? 之前是提出了pointcut的expression.那这里使用这个expr去和类比较一下即可.

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

Advisor委托MethodMatcher去做对应的match.

具体调用比较复杂..我也没有仔细去看...

AOP本类方法掉用本类方法不生效咋办

这个问题可能经常会遇到.我相信80%出现的情况是一个操作数据库的service上的方法a上有@Transaction, 然后方法b是个很一般的方法.b会调用a.然后发现事务没生效.

解决这个问题可能会有2种办法.

expose-proxy

 <aop:aspectj-autoproxy expose-proxy="true"/>

设置了这个标签属性以后可以在代码里

AopContext.currentProxy()

这样来获取当前类的proxy.然后调用方法就行了.

原理呢? 其实很简单.以JDK动态代理为例

JdkDynamicAopProxy.invoke 方法内部有一段代码

            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

将当前bean对应的proxy设置到AopCOntext的currentProxy中.currentProxy是个threadLocal对象.完成绑定.

所以在我们的bean中可以通过AopContext.currentProxy()获取之前设置进去的proxy对象.

自身持有自身的引用

class A {

　　@Autowired

　　private A a;

}

大致是这样的操作. 为什么这样可以呢? 首先应该要分析为什么本类调用本类方法AOP不起作用.

ReflectiveMethodInvocation类中当interceptor的全部操作都已经做完以后会调用我们joinpoint的方法(我们的业务代码).

 

 注意这里传入的第一个参数是target. target不是proxy.是原始的你写的bean而不是AOP产生的代理对象.所以调用方法的时候会调用你本身对象的相关方法.

因为不是proxy.也就不会再触发所有interceptor.自然也就没有了aop的advise的功能.

那为什么本类注入本类的对象就可以呢?

因为本类注入本类的时候, private A a中a是一个proxy..所以invokeJoinpoint的时候虽然this.target是原生的bean.但是他的field a仍然是proxy的a.所以调用a的相关方法仍然会经过interceptor处理,保留advise的功能.

看到这里不知道大家会不会想到有一个循环引用的问题.

https://www.cnblogs.com/abcwt112/p/12577109.html

问题2种写到A中有B,B中有A的时候如果A被代理了.那会throw BeanCurrentlyInCreationException,因为B中注入的是原始的A,A后来又被代理返回了proxy.那B注入的原始的A就有问题,是原始的,而非代理的.

那为啥这里A中注入A就没事呢?

因为AnnotationAwareAspectJAutoProxyCreator这个类impl了org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference

 getEarlyBeanReference这个方法就是为了处理提前引用的.需要提前获取原始Bean引用的时候可以进行一些回调处理,这里的处理为需要提前获取引用的时候直接返回代理,而不是原始的Bean.

当A Bean被加载,populate他的属性A a的时候,返回的并不是原生的A,而是proxy..接下来正在创建的原生A也会被替换成proxy返回.因此不会出现异常.

Aspect的顺序

多个aop如何处理顺序问题?

 找出bean可以被应用的advisor以后会排序,排序规则和BeanPostProcessor等都是一样的

详见org.springframework.core.OrderComparator#doCompare

    private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
        boolean p1 = (o1 instanceof PriorityOrdered);
        boolean p2 = (o2 instanceof PriorityOrdered);
        if (p1 && !p2) {
            return -1;
        }
        else if (p2 && !p1) {
            return 1;
        }

        int i1 = getOrder(o1, sourceProvider);
        int i2 = getOrder(o2, sourceProvider);
        return Integer.compare(i1, i2);
    }


    private int getOrder(@Nullable Object obj, @Nullable OrderSourceProvider sourceProvider) {
        Integer order = null;
        if (obj != null && sourceProvider != null) {
            Object orderSource = sourceProvider.getOrderSource(obj);
            if (orderSource != null) {
                if (orderSource.getClass().isArray()) {
                    Object[] sources = ObjectUtils.toObjectArray(orderSource);
                    for (Object source : sources) {
                        order = findOrder(source);
                        if (order != null) {
                            break;
                        }
                    }
                }
                else {
                    order = findOrder(orderSource);
                }
            }
        }
        return (order != null ? order : getOrder(obj));
    }


    protected int getOrder(@Nullable Object obj) {
        if (obj != null) {
            Integer order = findOrder(obj);
            if (order != null) {
                return order;
            }
        }
        return Ordered.LOWEST_PRECEDENCE;
    }

小结下就是:

PriorityOrdered > getOrder > 没有order(Ordered.LOWEST_PRECEDENCE)

数字越小越外层(越先有机会处理).