Bean的定义信息,封装bean的基本信息,从中可以获取类名、是否是单例、是否被注入到其他bean中、是否懒加载、bean依赖的bean的名称等。
继承Aware的bean可以感知到他在容器中的一些属性,如获取bean在容器中的ID,甚至获取到容器等。
Bean的后置处理器,可在bean的创建、初始化等阶段的前后对bean进行增强处理等。
以Factory结尾,表示它是一个工厂类(接口),用于管理Bean的一个工厂。在Spring中,BeanFactory是IOC容器的核心接口,它的职责包括:实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
是访问容器的顶层接口,他的实现类中会有一个MAP,用于存储bean的BeanDefinition。
(与FactoryBean区别:实现FactoryBean接口也是在容器中注入bean的方式之一,但它不是一个普通的bean,而是生成指定bean的一个工厂)
DefaultListableBeanFactory继承了AbstractAutowireCapableBeanFactory
此方法用于给bean注入依赖的其他bean
将交于容器管理的bean装饰,屏蔽多样性,统一的set、get方法,方便统一操作
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.support.AbstractBeanFactory#getBean(java.lang.String, java.lang.Class
==》 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无。
容器启动时:
==》 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
1、bean在缓存中(Map)是否存在,存在则直接返回,不存在进入创建流程
2、创建BeanPostProcessor后置处理器
是否实现Aware,实现则注入对应容器信息
3、创建自身bean
创建àpopulateBeanàInvoke InitMethod(若有advice此时创建proxy)
在业务方法中加断点,调试进入
==》 org.springframework.aop.framework.JdkDynamicAopProxy#invoke
//当被代理类实现了接口时使用jdk动态代理
// Get the interception chain for this method.
//获取通知封装成的链
List
1、创建AOP核心类:AnnotationAwareAspectJAutoProxyCreator
2、在注入时,CreateBean时,检查是否有Advice,如果有则创建bean的代理。
注意:代理类对象(proxy)会加入容器,但Context::BeanFactory::BeanDefinition中的定义信息仍是被代理类的,所以取到的name也是被代理类的。
代理类会在被代理类调用populateBean 、InitMethod后创建,
3、被增强的方法在调用时,会调用代理类的方法,方法中获取相应通知做增强处理。这些通知会被封装成MethodInterceptor,对切点进行拦截增强处理。
手机扫一扫
移动阅读更方便
你可能感兴趣的文章