Spring Bean的创建初始化过程–源码分析

---

title: Spring Bean的创建初始化过程–源码分析
date: 2020-04-20 19:59:24
tags:Spring

---

bean的生命周期简单来说：

bean创建—初始化----销毁的过程

Bean的创建初始化

​ 当完成了Spring容器的初始化以及BeanDefinition的搜集入库后，Spring就会开始一部分bean的创建与初始化。

（1）refresh()中

//在Spring的启动方法refresh()中，最后会调用此方法，完成内部持有的beanFactory的初始化，并且完成所有的非懒加载的单例bean的实例化
finishBeanFactoryInitialization(beanFactory);

（2）finishBeanFactoryInitialization(beanFactory)中

//完成所有的非懒加载的单例bean的实例化
beanFactory.preInstantiateSingletons();

（3）beanFactory.preInstantiateSingletons()中

//首先获取beanDefinition的name集合
//在Spring容器（DefaultListableBeanFactory）中会持有两个关于beanDefinition相关的集合对象
//beanDefinitionMap和beanDefinitionNames，一个为Map，一个为List，这样的目的就是为了保存bean的注册顺序
//private final Map beanDefinitionMap = new ConcurrentHashMap<>(256);
//private volatile List beanDefinitionNames = new ArrayList<>(256);
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//遍历集合
for (String beanName : beanNames) {
    //从beanDefinitionMap获取beanDefinition
	RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    //如果这个bean不是抽象的、不是懒加载的、是单例的，就进行实例化
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            //bean是否为FactoryBean
			if (isFactoryBean(beanName)) {
                //获取这个bean的factoryBean，“&”+beanName
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
                    。。。。。
                        //一般的FactoryBean是不会现在完成初始化的:它的getObject()只会在实际访问时调用
						if (isEagerInit) {
                            //初始化一些急切（eager）的bean
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

（4）getBean(beanName) -> doGetBean(beanName)中

//private final Map singletonObjects = new ConcurrentHashMap<>(256);
//先去singletonObjects查看是否有已经创建了
Object sharedInstance = getSingleton(beanName);
//若已经创建，就获取bean对应的对象返回
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

（5）doGetBean(beanName)->createBean

//加载Bean的Class类
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
//验证以及准备需要覆盖的方法

（6）createBean->doCreateBean

//使用合适的实例化策略来创建Bean（工厂方法、构造函数自动注入、简单初始化），并得到Bean包装类BeanWrapper对象。
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
	instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();


//调用BeanDefinitionPostProcessor修改bean定义
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

//设置bean的属性
populateBean(beanName, mbd, instanceWrapper);

//开始初始化bean
exposedObject = initializeBean(beanName, exposedObject, mbd);

（7）initializeBean

//核心代码
//执行BeanPostProcessor的前置方法，遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
//执行自定义的一些初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
//执行BeanPostProcessor的后置方法
applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

自定义初始化方法

1. 指定初始化和销毁方法

//bean
public class Cat {
 public Cat() {
     System.out.println("cat");
 }
 
 public void MyInit(){
     System.out.println("init...");
 }

 public void MyDestroy() throws Exception {
		System.out.println("destroy...");
 }

}
//配置类
@Configuration
public class Application {
 //指定初始化方法，销毁方法
 @Bean(initMethod = "MyInit" ，destroyMethod = "MyDestroy")
 public Cat cat(){
     return new Cat();
 }
}

2.通过让Bean实现InitializingBean（定义初始化逻辑），DisposableBean（定义销毁逻辑）

public class Cat implements InitializingBean, DisposableBean {
 public Cat() {
     System.out.println("cat");
 }

 public void destroy() throws Exception {
		System.out.println("disposableBean");
 }

 public void afterPropertiesSet() throws Exception {
     System.out.println("afterPropertiesSet");
 }

}

3.@PostConstruct：在bean创建完成并且属性赋值完成，来执行初始化方法；@PreDestroy：在容器销毁bean之前进行清理工作。

public class Cat implements {
 public Cat() {
     System.out.println("cat");
 }

 @PostConstruct
 public void postConstruct(){
     System.out.println("postConstruct");
 }

}

4.实现BeanPostProcessor接口

bean的后置处理器；

• 在bean初始化前后进行一些处理工作；
• postProcessBeforeInitialization:在初始化之前工作
• postProcessAfterInitialization:在初始化之后工作

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
     System.out.println(beanName + "...BeforeInitialization...");
     return bean;
 }

 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
     System.out.println(beanName + "...AfterInitialization...");
     return bean;
 }
}

前面的3种方法是针对一个bean定制化的初始化以及销毁，而BeanPostProcessor会对所有bean都起作用。

对于3、4来说，都是在applyBeanPostProcessorsBeforeInitialization中处理的，也就是说@PostConstruct标注的方法，会被当作这个bean独有的BeanPostProcessor。

对于1、2来说，会在invokeInitMethods中一起处理。

（8）initializeBean->invokeInitMethods

//这个方法的作用：检查bean是否实现了InitializingBean或定义了自定义init方法，如果实现了，则进行调用。
//执行InitializingBean接口的afterPropertiesSet 
((InitializingBean) bean).afterPropertiesSet();
//invokeCustomInitMethod执行自定义的init-method方法
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&!(isInitializingBean && "afterPropertiesSet".equals(initMethodName))&&!mbd.isExternallyManagedInitMethod(initMethodName)) {
			invokeCustomInitMethod(beanName, bean, mbd);
		}

（9）返回bean