Spring源码分析笔记--AOP

核心类&方法

BeanDefinition

Bean的定义信息，封装bean的基本信息，从中能够获取类名、是不是单例、是否被注入到其余bean中、是否懒加载、bean依赖的bean的名称等。

Aware

继承Aware的bean能够感知到他在容器中的一些属性，如获取bean在容器中的ID，甚至获取到容器等。

BeanPostProcessor

 

Bean的后置处理器，可在bean的建立、初始化等阶段的先后对bean进行加强处理等。

BeanFactory

以Factory结尾，表示它是一个工厂类(接口)，用于管理Bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及创建这些对象间的依赖。

是访问容器的顶层接口，他的实现类中会有一个MAP，用于存储bean的BeanDefinition。

(与FactoryBean区别：实现FactoryBean接口也是在容器中注入bean的方式之一，但它不是一个普通的bean，而是生成指定bean的一个工厂)

 

AbstractAutowireCapableBeanFactory：： populateBean（..）

DefaultListableBeanFactory继承了AbstractAutowireCapableBeanFactory

此方法用于给bean注入依赖的其余bean

 

BeanWrapper

将交于容器管理的bean装饰，屏蔽多样性，统一的set、get方法，方便统一操做

 

核心流程源码

AnnotationAwareAspectJAutoProxyCreator建立过程

AOP核心类：AnnotationAwareAspectJAutoProxyCreator，本质是一种BeanPostProcessor

 

容器启动时：

==》 org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>...) 　　register(annotatedClasses);//加载、注册配置类；配置类也是一个被容器管理的bean
　　refresh();//刷新容器，注册、建立相关bean
==》 org.springframework.context.support.AbstractApplicationContext#refresh 　// Register bean processors that intercept bean creation.
　　registerBeanPostProcessors(beanFactory);//注册容器须要的核心BeanPostProcessor 　　// Instantiate all remaining (non-lazy-init) singletons.
　　finishBeanFactoryInitialization(beanFactory);//建立并初始化其余非懒加载的bean，主要是业务类bean
==》 org.springframework.context.support.AbstractApplicationContext#registerBeanPostProcessors ==》 org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, org.springframework.context.support.AbstractApplicationContext) 　　// Separate between BeanPostProcessors that implement PriorityOrdered, Ordered, and the rest. 　　//根据继承的order等级，顺序建立BeanPostProcessor 　　//AnnotationAwareAspectJAutoProxyCreator实现了Order 　　//建立
　　BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); 　　//添加到容器-FactoryBean中
　　org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.List<org.springframework.beans.factory.config.BeanPostProcessor>) ==》 org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String, java.lang.Class<T>) ==》 org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean//BeanPostProcessor和业务Bean都用此建立bean 　　//建立bean
　　return createBean(beanName, mbd, args); ==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[]) 　　// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. 　　//有一次经过代理直接返回对象的机会，但通常都不会走到此方法中
　　Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 　　//建立过程
　　Object beanInstance = doCreateBean(beanName, mbdToUse, args); ==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean 　　//建立Bean，经过Wrapper装饰
　　if (instanceWrapper == null) { 　　　　instanceWrapper = createBeanInstance(beanName, mbd, args); 　　} 　　// Initialize the bean instance. 　　//填充bean后初始化bean
　　Object exposedObject = bean; 　　try { 　　populateBean(beanName, mbd, instanceWrapper); 　　if (exposedObject != null) { 　　exposedObject = initializeBean(beanName, exposedObject, mbd); 　　} 　　} ==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition) 　　//初始化bean 　　//检查实现了哪些aware，并注入相应的值
　　invokeAwareMethods(beanName, bean); 　　//BeanPostProcessor初始化前置处理
　　wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); 　　//调用bean的初始方法
　　invokeInitMethods(beanName, wrappedBean, mbd); 　　//BeanPostProcessor初始化后置处理
　　wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); ==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization 　　//此类作Bean初始化的后置处理，若bean有advice则建立proxy bean，此bean无。

业务Bean（proxy）建立过程

 

容器启动时：

==》 org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>...) 　　register(annotatedClasses);//加载、注册配置类；配置类也是一个被容器管理的bean
　　refresh();//刷新容器，注册、建立相关bean
==》 org.springframework.context.support.AbstractApplicationContext#refresh 　// Register bean processors that intercept bean creation.
　　registerBeanPostProcessors(beanFactory);//注册容器须要的核心BeanPostProcessor 　　// Instantiate all remaining (non-lazy-init) singletons.
　　finishBeanFactoryInitialization(beanFactory);//建立并初始化其余非懒加载的bean，主要是业务类bean
==》 org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization 　　// Instantiate all remaining (non-lazy-init) singletons.
　　beanFactory.preInstantiateSingletons(); ==》 org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons 　　//getBean(beanName);
==》 org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String) ==》 org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean 　　return createBean(beanName, mbd, args); ==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[]) 　　Object beanInstance = doCreateBean(beanName, mbdToUse, args); 　　//建立Bean，经过Wrapper装饰
　　if (instanceWrapper == null) { 　　　　instanceWrapper = createBeanInstance(beanName, mbd, args); 　　} 　　// Initialize the bean instance. 　　//填充bean后初始化bean
　　Object exposedObject = bean; 　　try { 　　populateBean(beanName, mbd, instanceWrapper); 　　if (exposedObject != null) { 　　exposedObject = initializeBean(beanName, exposedObject, mbd); 　　} 　　} ==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition) 　　//初始化bean 　　//检查实现了哪些aware，并注入相应的值
　　invokeAwareMethods(beanName, bean); 　　//BeanPostProcessor初始化前置处理
　　wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); 　　//调用bean的初始方法
　　invokeInitMethods(beanName, wrappedBean, mbd); 　　//BeanPostProcessor初始化后置处理
　　wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); ==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization 　　//此类作Bean初始化的后置处理，若bean有advice则建立proxy bean 　　//遍历bean的后置处理器，并作后置处理 　　//当后置处理器时AnnotationAwareAspectJAutoProxyCreator时进入方法，判断是否须要作代理
　　for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { 　　result = beanProcessor.postProcessAfterInitialization(result, beanName); 　　if (result == null) { 　　return result; 　　} 　　} ==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization ==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary 　　// Create proxy if we have advice.
　　Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); 　　if (specificInterceptors != DO_NOT_PROXY) { 　　this.advisedBeans.put(cacheKey, Boolean.TRUE); 　　Object proxy = createProxy( bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); 　　this.proxyTypes.put(cacheKey, proxy.getClass()); 　　return proxy; 　　} ==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#createProxy 　　//bean须要被aop作代理进行加强时进入此方法 　　//取得bean对应的advisors，advisors会被封装成链式Interceptors（责任链模式）供后期加强使用
　　Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); 　　//使用代理工厂建立代理
　　return proxyFactory.getProxy(getProxyClassLoader()); ==》 org.springframework.aop.framework.ProxyFactory#getProxy(java.lang.ClassLoader) 　　return createAopProxy().getProxy(classLoader); ==》 org.springframework.aop.framework.ProxyCreatorSupport#createAopProxy 　　return getAopProxyFactory().createAopProxy(this); ==》 org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy 　　//若是继承自接口使用JDK动态代理
　　if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { 　　return new JdkDynamicAopProxy(config); 　　} 　　//不然使用CGLib动态代理
　　return new ObjenesisCglibAopProxy(config);

Bean的建立梳理

包括工具Bean、业务Bean

一、bean在缓存中（Map）是否存在，存在则直接返回，不存在进入建立流程

二、建立BeanPostProcessor后置处理器

是否实现Aware，实现则注入对应容器信息

三、建立自身bean

建立àpopulateBeanàInvoke InitMethod(如有advice此时建立proxy)

AOP advice过程

 

在业务方法中加断点，调试进入

==》 org.springframework.aop.framework.JdkDynamicAopProxy#invoke 　　//当被代理类实现了接口时使用jdk动态代理 　　// Get the interception chain for this method. 　　//获取通知封装成的链
    List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 　　// We need to create a method invocation...
　　invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); 　　// Proceed to the joinpoint through the interceptor chain. 　　//容器在封装advisors成Interceptors时会进行排序，此顺序和实际执行顺序相反，由于Interceptors会以责任链的形式调用，所以实际执行时顺序是正常的
　　retVal = invocation.proceed();

 

AOP 方法加强梳理

1、建立AOP核心类：AnnotationAwareAspectJAutoProxyCreator

2、在注入时，CreateBean时，检查是否有Advice，若是有则建立bean的代理。

注意：代理类对象（proxy）会加入容器，但Context::BeanFactory::BeanDefinition中的定义信息还是被代理类的，因此取到的name也是被代理类的。

代理类会在被代理类调用populateBean 、InitMethod后建立，

3、被加强的方法在调用时，会调用代理类的方法，方法中获取相应通知作加强处理。这些通知会被封装成MethodInterceptor,对切点进行拦截加强处理。

 

原文出处：https://www.cnblogs.com/little-sheep/p/10103797.html