文章目录
- 概述
- BeanFactory创建的主要流程
- prepareRefresh()创建前的预处理
- obtainFreshBeanFactory()获取BeanFactory
- prepareBeanFactory(beanFactory)预准备工作
- postProcessBeanFactory(beanFactory)后置处理
- invokeBeanFactoryPostProcessors(beanFactory)
- registerBeanPostProcessors(beanFactory)
- initMessageSource()
- initApplicationEventMulticaster()
- onRefresh()
- registerListeners()
- Bean的创建
Spring Ioc,AOP以及循环依赖
概述
BeanFactory是个Factory,也就是IOC容器或对象工厂;在Spring中,所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。
我们先创建一个类,用创建的类来研究Spring是如何创建的该类的实例以及整个容器的流程(创建的bean实例是使用注解完成的,如果是xml文件形式,和注解的流程类似):
@Test
public void test(){
//1.创建IOC容器
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(LifeCycle.class);
System.out.println("容器创建完毕");
Person person= applicationContext.getBean(Person .class);
//关闭容器
applicationContext.close();
}
上述的代码就是将LifeCycle配置类放入容器中进行bean的创建,我们使用debug模式来进入new AnnotationConfigApplicationContext(LifeCycle.class),该构造器中会调用refresh()函数进行容器的“刷新”:
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}
BeanFactory创建的主要流程
进入refresh()函数后会发现,BeanFactory的基本创建都在这个方法之中,下面代码是主要主要流程;
//准备为此上下文以进行刷新
prepareRefresh();
// 告诉子类刷新内部bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//准备在目前情况下使用的bean工厂(BeanFactory的预准备工作)
prepareBeanFactory(beanFactory);
try {
//允许在上下文子类中对bean工厂进行后处理
postProcessBeanFactory(beanFactory);
//调用在上下文中注册的bean的工厂处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 注册拦截Bean创建的Bean处理器
registerBeanPostProcessors(beanFactory);
// 为此上下文初始化消息源
initMessageSource();
//为此上下文初始化事件多播器
initApplicationEventMulticaster();
// 在特定上下文子类中初始化其他特殊bean(空方法,留给子类重写使用的方法,在SpringBoot中,会将该方法重写,并且在该方法中创建了嵌入式Servlet容器实例)
onRefresh();
// 检查侦听器bean并注册它们
registerListeners();
// 实例化所有剩余的(非延迟)单例
finishBeanFactoryInitialization(beanFactory);
// 最后一步:发布相应的事件
finishRefresh();
}
prepareRefresh()创建前的预处理
在该方法中会有以下主要方法:
//在上下文环境中初始化任何占位符属性源(空方法)
initPropertySources();
//验证标记为必需的所有属性都是可解析的
getEnvironment().validateRequiredProperties();
//允许收集早期的ApplicationEvent,一旦多播器可用时就发布
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
- initPropertySources()初始化一些占位符属性源设置,子类可以自定义个性化的属性设置;
- getEnvironment().validateRequiredProperties()验证所有属性标注都是可解析的;
- earlyApplicationEvents = new LinkedHashSet()保存容器中的一些早期的事件,在有了多播器后就可以被直接发布(目前我们没有设置事件,因此为null);
obtainFreshBeanFactory()获取BeanFactory
- refreshBeanFactory刷新(创建)BeanFactory,并创建了beanFactory = new DefaultListableBeanFactory();
- getBeanFactory()方法,返回刚刚在1中创建的BeanFactory对象;
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
prepareBeanFactory(beanFactory)预准备工作
BeanFactory的预准备工作(BeanFactory进行一些设置),配置工厂的标准上下文(容器)特征,例如上下文的ClassLoader和后处理器:
将上一步获取的BeanFactory对象传入进来进行配置
@param beanFactory the BeanFactory to configure
postProcessBeanFactory(beanFactory)后置处理
postProcessBeanFactory(beanFactory)该方法也是一个空方法,是为子类所留,子类通过重写该方法,可以在BeanFactory创建并预准备完成以后做进一步的设置; 这里也就是编写后置处理方法的地方;
invokeBeanFactoryPostProcessors(beanFactory)
该方法必须在单例实例化之前被调用;一些后置处理器的执行是会按照优先级(PriorityOrdered接口)和顺序(Ordered接口)依次执行的,最后执行没有实现任何优先级或顺序接口的BeanDefinitionRegistryPostProcessor(后置处理器)方法;
registerBeanPostProcessors(beanFactory)
- 会获取所有的BeanPostProcessor(内部bean,非我们创建的)(后置处理器默认都可以通过PriorityOrdered,Ordered接口指定优先级);
- 先注册(加入到beanFactory中)PriorityOrdered优先级接口的BeanPostProcessor;接着就是实现了Ordered接口,最后还是执行没有实现任何优先级或顺序接口的BeanPostProcessor;
initMessageSource()
初始化MessageSource组件(国际化功能,消息绑定,消息解析);
- 【MessageSource能取出国际化配置文件中的某个key值,能按照区域信息获取】
- 获取BeanFactory;
ConfigurableListableBeanFactory beanFactory = getBeanFactory(); - 判断容器中是否有id为MessageSource组件,如果有该组件,就直接赋值给它,如果没有就创建一个DelegatingMessageSource组件;
- 然后把注册好的MessageSource注册在beanFactory中;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource)
initApplicationEventMulticaster()
初始化事件派发器:
- 获取beanFactory;
- 从beanFactory获取applicationEventMulticaster的ApplicationEventMulticaster;
- 如果没有用户未配置,就会创建一个SimpleApplicationEventMulticaster事件派发器,并将其注册到beanFactory中,以后其它组件就可以自动注入;
onRefresh()
留给子容器(子类),在特定子类中初始化其他特殊的bean;SpringBoot中该方法创建了嵌入式servlet容器的实例;
registerListeners()
给容器中将所有项目里面的ApplicationListener注册进来,
Bean的创建
finishBeanFactoryInitialization(beanFactory)
初始化所有剩余的(非延迟)单例(在该方法中会创建出来我们所定义出来的bean实例);
- 调用beanFactory.preInstantiateSingletons();初始化所有剩余的(非延迟)单例,在这个方法中会对bean进行复杂的判断与创建,会获取bean的定义信息,判断bean是否是实现了FactoryBean的Bean等等;
- 若不是实现了FactoryBean的Bean,就会调用 getBean(beanName)继续创建bean实例;
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// 依次注册新的bean定义
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// 开始所有非懒加载单例bean的初始化
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//判断Bean不是抽象的,是单实例的并且不是懒加载的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判断是否是FactoryBean(工厂Bean)的(判断是否实现了FactoryBean的Bean)
if (isFactoryBean(beanName)) {
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
//如果不是FactoryBean,就会利用getBean(beanName)创建对象
else {
getBean(beanName);
}
}
}
// 触发所有合适的bean的初始化后的回调
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
smartSingleton.afterSingletonsInstantiated();
return null;
}
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
- 在getBean方法中调用doGetBean(name, null, null, false)方法:先获取缓存(存在一级,二级和三级缓存)中保存的单实例Bean;如果能够获取到,说明之前已经被创建过(创建的单实例Bean都会被缓存起来);若获取不到就继续创建;
// 检查单例缓存中是否有注册的单实例bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
- 在缓存中如果没有,说明是没有创建的bean,就会调用createBean(beanName, mbd, args)来继续创建;
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
//创建Bean实例
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
- 在createBean方法中的中会有resolveBeforeInstantiation(beanName,mbd)方法,该方法会给bean的后置处理器一个返回代理对象而不是目标bean实例的机会;让BeanPostProcessor先拦截返回代理对象:
- InstantiationAwareBeanPostProcessor的执行;
- 先执行postProcessBeforeInstantiation(beanClass, beanName)方法,如果有返回值再去执行postProcessAfterInitialization(result, beanName)方法;
//使用实例化之前的后处理器,以解决指定bean实例化之前是否存在的快捷方式 protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { // Make sure bean class is actually resolved at this point. if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class<?> targetType = determineTargetType(beanName, mbd); if (targetType != null) { //前置实例化处理 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { //后置实例化处理 bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } mbd.beforeInstantiationResolved = (bean != null); } return bean; }
- 如果上一步没有返回代理对象时,就会调用如下方法继续创建:
Object beanInstance = doCreateBean(beanName, mbdToUse, args);/创建Bean
doGetBean方法:
在doGetBean方法中调用createBean,然后再createBean中再调用doCreateBean方法;
-
在doCreateBean方法中创建Bean的实例:createBeanInstance(beanName, mbd, args);利用工厂方法或确定对象的构造器创建出Bean实例;
-
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName),允许Bean的后置处理器来修改bean的定义;
-
populateBean(beanName, mbd, instanceWrapper)开始给Bean属性进行赋值:
- 赋值之前:
- 获取到InstantiationAwareBeanPostProcessor后置处理器,执行postProcessAfterInstantiation方法;
- 再获取到InstantiationAwareBeanPostProcessor后置处理器,执行postProcessPropertyValues方法;
- 赋值:
- 应用Bean的属性值,为属性利用setter方法进行赋值:applyPropertyValues(beanName, mbd, bw, pvs);
- 赋值之前:
-
Bean初始化:initializeBean(beanName, exposedObject, mbd):
- 【执行Aware接口的方法】执行invokeAwareMethods(beanName, bean)方法,也就是执行BeanNameAware、BeanClassLoaderAware和BeanFactoryAware方法(xxxAware方法);
private void invokeAwareMethods(final String beanName, final Object bean) { if (bean instanceof Aware) { if (bean instanceof BeanNameAware) { ((BeanNameAware) bean).setBeanName(beanName); } if (bean instanceof BeanClassLoaderAware) { ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader()); } if (bean instanceof BeanFactoryAware) { ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); } } }
- 【执行后置处理器初始化之前的方法(预初始化方法)】调用applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)方法,然后再调用BeanPostProcessor.postProcessBeforeInitialization(result, beanName)方法;
- 【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd):
- 判断是否是InitializingBean接口的实现,执行接口规定的初始化;
- 判断是否自定义初始化方法,如果有就执行;
- 【执行后置处理器初始化后方法】applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName),然后执行beanProcessor.postProcessAfterInitialization(result, beanName)方法;
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged(new PrivilegedAction<Object>() { @Override public Object run() { invokeAwareMethods(beanName, bean); return null; } }, getAccessControlContext()); } else { //执行Aware接口的方法 invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { //【执行后置处理器初始化之前的方法(预初始化方法)】 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { //【执行初始化方法】 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { //【执行后置处理器初始化后方法】 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }
5.在上述的doCreateBean方法返回创建好的exposedObject(bean实例),最终在doGetBean中会返回创建的bean:
- 在doCreateBean方法中注册Bean的销毁方法(不是执行)registerDisposableBeanIfNecessary(beanName, bean, mbd);
-
将创建的Bean实例添加到缓存( Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256))中;
上述是Bean实例的创建过程。
finishRefresh()
完成BeanFactory的初始化创建工作,IOC容器就会创建完毕:
- initLifecycleProcessor(),初始化和声明周期有关的处理器;
- getLifecycleProcessor().onRefresh(),获取到之前定义的生命周期处理器(BeanFactory),回调onRefresh方法;
- publishEvent(new ContextRefreshedEvent(this)),发布容器刷新完成事件;
- LiveBeansView.registerApplicationContext(this)。