spring-aop

枫火木烈王

已于 2022-08-09 09:54:10 修改

阅读量234

点赞数

分类专栏： Spring 文章标签： spring

于 2022-07-21 17:20:18 首次发布

本文链接：https://blog.csdn.net/WangMapleWang/article/details/125888690

版权

Spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、aop代理类何时创建

1、无循环依赖

bean初始化时，后置处理器AnnotationAwareAspectJAutoProxyCreator查询当前的bean对象是否有Advisor(执行通知者)，若有则生成代理对象

bean的初始化

initializeBean(beanName, bean, beanDefinition){
    // 初始化aware方法
    invokeAwareMethods(beanName, bean);
    // 初始化方法之前的  前置处理器
    wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName)

    // afterPropertiesSet 或者自定义的init方法
    this.invokeInitMethods(beanName, wrappedBean, mbd);

    // 初始化方法之后的  后置处理器  
    wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}


aop后置处理器 -- 
AnnotationAwareAspectJAutoProxyCreator implements BeanPostProcessor {

   public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
       
        //spring aop代理主代码
        AbstractAutoProxyCreator.wrapIfNecessary(bean, beanName, cacheKey){

           Object[] specificInterceptors = AbstractAdvisorAutoProxyCreator.getAdvicesAndAdvisorsForBean(){

                 //查询出所有的切面
                findCandidateAdvisors();
                //进行过滤条件方法匹配
                findAdvisorsThatCanApply(list, beanClass, beanName)
                //排序
                sortAdvisors()

            }
            
            if (specificInterceptors != null) {
                //生成代理类
                return createProxy()

            }else{
                return bean;
            }
          
        }
       
  }

}

2、有循环依赖

bean进行属性注入时，发现有循环依赖，则调用三级缓存factory的执行getObject进行生成代理，生成完成之后移入二级缓存，

提前曝光的bean在提前引用时被Spring AOP代理了，但是此时的bean只是经过了实例化的bean，还没有进行属性的注入，也就是说此时代理的bean里面的属性是空的

spring循环依赖

@Service
@Order(1)
public class A {

    private B b;
    
    @Autowired
    public void setB(B b) {
        this.b = b;
    }

    public String a(){
      return "a";
  }
  
}

@Service
public class B implements Ordered {
    
    private A a;
    
    @Autowired
    public void setA(A a) {
        this.a = a;
    }

    @Override
    public int getOrder() {
        return 2;
    }
    
}

//获取A对象
doGetBean(name)

//从三级缓存中获取A对象
Object sharedInstance = this.getSingleton(beanName);

//获取不到开始创建对象A  beanName = "a"
doCreateBean(beanName, RootBeanDefinition, args)

//所有的bean对象都会添加一个factory，为后面生成代理对象使用，以及解决循环依赖问题
this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });

//属性设置赋值 
AbstractAutowireCapableBeanFactory.populateBean(beanName, beanDefinition, BeanWrapper)


//A对象的注入属性b
AutowiredAnnotationBeanPostProcessor.postProcessProperties(PropertyValues, bean, beanName)

AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement.inject(bean, beanName, PropertyValues)


//resolve调用方法的参数值
//method="public void com.example.myspr.A.setB(com.example.myspr.B)"  beanName="a"
arguments = this.resolveMethodArguments(method, bean, beanName);


AutowiredAnnotationBeanPostProcessor.this.beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter)



Object result = ContextAnnotationAutowireCandidateResolver.getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
//懒加载 直接构建个代理对象，注入的是一个代理非完全初始化的对象，当它首次被使用时才完全初始化
if (result == null) {
    //非懒加载
    result = this.doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;


//非lazy  autowiredBeanName="b"  type= class com.example.myspr.B
DependencyDescriptor.resolveCandidate(autowiredBeanName, Class<?> type, beanFactory)


beanFactory.getBean(beanName)

//从三层缓存中获取b对象，重复上述流程，获取不到进行b对象的实例化、属性注入、初始化流程
doGetBean(name)


//再对b对象的属性注入a阶段时，获取对象A，能够从三级缓存获取，调用factory.getObject方法
Object sharedInstance = this.getSingleton(beanName);


getEarlyBeanReference(bean, beanName)


//以下同上
wrapIfNecessary(bean, beanName, cacheKey){

           Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(){

                 //查询出所有的切面
                findCandidateAdvisors();
                //进行过滤条件方法匹配
                findAdvisorsThatCanApply(list, beanClass, beanName)
                //排序
                sortAdvisors()

            }
            
            if (specificInterceptors != null) {
                //生成代理类
                return createProxy()

            }else{
                return bean;
            }
          
        }

二、切面执行顺序

1、不同切面类顺序

判断当前所在的切面类是否实现org.springframework.core.Ordered接口
判断当前Advisor所在的切面类是否包含org.springframework.core.annotation.Order注解
判断当前Advisor所在的切面类是否包含javax.annotation.Priority注解
没有取到值，默认为最低优先级，值为最大Int
顺序一致时，则按spring获取到切面bean的顺序做排序，先获取先执行

AspectJAwareAdvisorAutoProxyCreator{

 protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
        List<AspectJAwareAdvisorAutoProxyCreator.PartiallyComparableAdvisorHolder> partiallyComparableAdvisors = new ArrayList(advisors.size());
        Iterator var3 = advisors.iterator();

        while(var3.hasNext()) {
            Advisor advisor = (Advisor)var3.next();
            partiallyComparableAdvisors.add(new AspectJAwareAdvisorAutoProxyCreator.PartiallyComparableAdvisorHolder(advisor, DEFAULT_PRECEDENCE_COMPARATOR));
        }

        List<AspectJAwareAdvisorAutoProxyCreator.PartiallyComparableAdvisorHolder> sorted = PartialOrder.sort(partiallyComparableAdvisors);
        if (sorted == null) {
            return super.sortAdvisors(advisors);
        } else {
            List<Advisor> result = new ArrayList(advisors.size());
            Iterator var5 = sorted.iterator();

            while(var5.hasNext()) {
                AspectJAwareAdvisorAutoProxyCreator.PartiallyComparableAdvisorHolder pcAdvisor = (AspectJAwareAdvisorAutoProxyCreator.PartiallyComparableAdvisorHolder)var5.next();
                result.add(pcAdvisor.getAdvisor());
            }

            return result;
        }
    }

}



AnnotationAwareOrderComparator{

 @Nullable
    protected Integer findOrder(Object obj) {
        Integer order = super.findOrder(obj);
        return order != null ? order : this.findOrderFromAnnotation(obj);
    }

    @Nullable
    private Integer findOrderFromAnnotation(Object obj) {
        AnnotatedElement element = obj instanceof AnnotatedElement ? (AnnotatedElement)obj : obj.getClass();
        MergedAnnotations annotations = MergedAnnotations.from((AnnotatedElement)element, SearchStrategy.TYPE_HIERARCHY);
        Integer order = OrderUtils.getOrderFromAnnotations((AnnotatedElement)element, annotations);
        return order == null && obj instanceof DecoratingProxy ? this.findOrderFromAnnotation(((DecoratingProxy)obj).getDecoratedClass()) : order;
    }

    @Nullable
    public Integer getPriority(Object obj) {
        if (obj instanceof Class) {
            return OrderUtils.getPriority((Class)obj);
        } else {
            Integer priority = OrderUtils.getPriority(obj.getClass());
            return priority == null && obj instanceof DecoratingProxy ? this.getPriority(((DecoratingProxy)obj).getDecoratedClass()) : priority;
        }
    }

}

2、同切面类下的advice通知执行顺序

@around{

around start

@before

proceeding.proceed(proceeding.getArgs())

@AfterReturning

@After （可看成finally）

around end

}

3、同一个切面类里面定义的多个通知，会按照方法名自然排序

@Before(value = "execution(* com.example..A.a(..))()")
    public void _a1(){
        System.out.println("before a1");
    }

    @Before(value = "execution(* com.example.myspr..*(..))")
    public void _b0(){
        System.out.println("before b0");
    }

    @Before(value = "execution(* com.example..A.*(..))")
    public void _a2(){
        System.out.println("before a2");
    }


    @After(value = "execution(* com.example..A.a(..))()")
    public void a1(){
        System.out.println("After a1");
    }

    @After(value = "execution(* com.example.myspr..*(..))")
    public void b0(){
        System.out.println("After b0");
    }

    @After(value = "execution(* com.example..A.*(..))")
    public void a2(){
        System.out.println("After a2");
    }


//
before a1
before a2
before b0
After b0
After a2
After a1