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
1、bean在缓存中(Map)是否存在,存在则直接返回,不存在进入创建流程
2、创建BeanPostProcessor后置处理器
是否实现Aware,实现则注入对应容器信息
3、创建自身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,对切点进行拦截增强处理。
最新文章
- 在IE浏览器中执行OpenFlashChart的reload方法时无法刷新的解决方法
- ASP.NET(转自wiki)
- DNS初识
- PHP核心技术与最佳实践--笔记
- js判断移动终端url跳转
- Java异常(一) Java异常简介及其架构
- 论文笔记之:Attention For Fine-Grained Categorization
- win32 console application 如何修改图标?
- uva 10635 - Prince and Princess(LCS)
- Unity3D Android手机开发环境配置
- CSS_position
- (五)solr7.1.0之solrJ的使用
- Linux管理日记(三)
- [Swift]LeetCode1029. 两地调度 | Two City Scheduling
- Mysql数据库和表的增删改查以及数据备份&;恢复
- 【VMware vSphere】使用U盘给戴尔服务器安装ESXi6.0系统
- select for update引发死锁分析
- Database hang and Row Cache Lock concurrency troubleshooting
- laravel数据库配置
- 20165215 学习基础和c语言基础调查