【Spring容器初始化后实例化单例bean过程源码解析 5.1.3.RELEASE版本】

目录

前言

一、基本介绍

二、SpringBean生命周期

 2.1 生命周期流程图

2.2 各个节点含义

三、SpringBean实例化源码解析

3.1 代码入口

3.2 refresh方法

3.3 finishBeanFactoryInitialization方法

3.4 preInstantiateSingletons方法

3.5 getMergedLocalBeanDefinition方法

3.6 getBean方法

3.7 createBean方法

3.8 doCreateBean方法

3.9 createBeanInstance方法

四、SpringBean实例化对象属性赋值源码解析

4.1 doCreateBean方法

4.2 populateBean方法

五、SpringBean实例化后对象前后置处理源码解析

5.1 doCreateBean方法

5.2 initializeBean方法

5.3 invokeAwareMethods方法

5.4 applyBeanPostProcessorsBeforeInitialization方法

5.5 invokeInitMethods方法

5.6 applyBeanPostProcessorsAfterInitialization方法

六、SpringBean销毁源码解析

6.1 代码入口

 6.2 registerShutdownHook方法

 6.3 doClose方法

 6.4 destroyBeans方法

 6.5 destroySingletons方法

 6.6 destroySingletons方法

  6.7 destroySingleton方法

  6.8 destroyBean方法

   6.9 destroy方法

七、SpringBean的AOP代理源码解析

7.1 代码入口

7.2 postProcessAfterInitialization方法

7.3 wrapIfNecessary方法

7.4 createProxy方法

7.5 getProxy方法

7.6 getProxy方法

7.7 JdkDynamicAopProxy的invoke方法

7.8 proceed方法

总结

---

前言

        看这篇文章，需要了解Spring容器初始化的过程，可以参考我的上篇文章或者查看其他优秀的CSDN文章。了解xml文件的bean标签最后转为BeanDefinition对象的全过程。

        这篇文章将对Spring容器初始化后，对非懒加载的单例bean实例化过程进行源码解析，首先对SpringBean的生命周期进行详细的解释，包含一些用到的方法及其所在类，然后再进行源码的解析。

        我也是初学bean初始化的源码， 解析的有问题欢迎指出，相互学习。

一、基本介绍

        当Spring容器初始化之后，会对非懒加载的单例bean进行实例化、属性赋值和AOP增强等等操作，最后将单例保存在singletonObjects集合中。方法入口：finishBeanFactoryInitialization(beanFactory);

---

二、SpringBean生命周期

        Spring管理的bean的生命周期和普通的java bean是不一样的，Spring可以根据我们的配置对bean进行一系列的增强操作，常见的就是aop或者实现Spring规定的一些接口，就会在实例化之后对bean进行增强。

 2.1 生命周期流程图

        bean创建到使用，流程图

        bean使用完销毁，流程图

2.2 各个节点含义

Spring生命周期节点详细介绍

beanDefinitionNames	当前类.方法：DefaultListableBeanFactory.preInstantiateSingletons() List beanNames = new ArrayList(this.beanDefinitionNames); 遍历Spring容器初始化后，保存的所有beanName集合，进行实例化。
Bean实例化	当前类.方法：AbstractAutowireCapableBeanFactory.doCreateBean() instanceWrapper = this.createBeanInstance(beanName, mbd, args); 根据构造方法进行实例化
Bean属性赋值	当前类.方法：AbstractAutowireCapableBeanFactory.doCreateBean() this.populateBean(beanName, mbd, instanceWrapper); 对bean属性进行赋值，根据xml里面配置的property属性或者Autowired注解
调用Bean实现的Aware接口	当前类.方法：AbstractAutowireCapableBeanFactory.initializeBean() this.invokeAwareMethods(beanName, bean); 具体调用BeanNameAware，BeanClassLoaderAware和BeanFactoryAware接口的方法，可以进入invokeAwareMethods方法详细查看。 特殊的是ApplicationContextAware这个接口，它也是Aware的子类，但是没有在invokeAwareMethods这个方法调用，而是在applyBeanPostProcessorsBeforeInitialization方法对bean进行的前置处理的时候调用的，由ApplicationContextAwareProcessor类的前置处理方法postProcessBeforeInitialization中进行调用。详细看方法invokeAwareInterfaces
调用BeanPostProcessor接口的前置处理方法 postProcessBeforeInitialization	当前类.方法：AbstractAutowireCapableBeanFactory.initializeBean() wrappedBean = this.applyBeanPostProcessorsBeforeInitialization( bean, beanName); 这个方法很简单，就是获取所有BeanPostProcessor对象，依次调用postProcessBeforeInitialization方法
调用Bean实现的InitializingBean接口方法	当前类.方法：AbstractAutowireCapableBeanFactory.initializeBean() this.invokeInitMethods(beanName, wrappedBean, mbd); 调用afterPropertiesSet方法，进入invokeInitMethods方法详细查看
调用Bean的init-method方法	当前类.方法：AbstractAutowireCapableBeanFactory.initializeBean() this.invokeInitMethods(beanName, wrappedBean, mbd); 也是在这个invokeInitMethods方法里面，反射调用
调用BeanPostProcessor接口的后置处理方法 postProcessAfterInitialization	当前类.方法：AbstractAutowireCapableBeanFactory.initializeBean() wrappedBean = this.applyBeanPostProcessorsAfterInitialization( wrappedBean, beanName); 获取所有BeanPostProcessor对象，依次调用postProcessAfterInitialization 方法。 aop也是在后置处理实现的，具体的处理类是AbstractAutoProxyCreator的wrapIfNecessary方法，在源码中详细解析。
调用destroy销毁bean	当前类.方法：DefaultSingletonBeanRegistry.destroyBean() bean.destroy();
调用bean实现的DisposableBean接口方法	当前类.方法：DisposableBeanAdapter.destroy() ((DisposableBean)this.bean).destroy();
调用Bean的destroy-method方法	当前类.方法：DisposableBeanAdapter.destroy() this.invokeCustomDestroyMethod(this.destroyMethod);

---

三、SpringBean实例化源码解析

3.1 代码入口

public static void main(String[] args) {
    // new一个容器
	ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
			"classpath:*c/test*.xml","classpath:*c/s*/test*.xml");
	applicationContext.registerShutdownHook();
}

// 当前类：ClassPathXmlApplicationContext
public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
    // 进入重载的构造方法
	this(configLocations, true, (ApplicationContext)null);
}

// 当前类：ClassPathXmlApplicationContext
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
	super(parent);
    // 设置xml路径
	this.setConfigLocations(configLocations);
	if (refresh) {
        // 刷新容器
		this.refresh();
	}

}

3.2 refresh方法

// 当前类：AbstractApplicationContext
// 当前类：AbstractApplicationContext，初始化容器入口
public void refresh() throws BeansException, IllegalStateException {
	synchronized(this.startupShutdownMonitor) {
		this.prepareRefresh();
        // 初始化容器，加载xml数据转换为java对象，保存在容器里面，后面使用
		ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        // 容器的准备工作，对容器的一些属性赋值，以后使用
		this.prepareBeanFactory(beanFactory);

		try {
            // 对于ClassPathXmlApplicationContext容器，这个是模板方法，没有实现，子类实现该                        
            // 方法可以对容器进行一些后置处理，此时容器已经初始化了
			this.postProcessBeanFactory(beanFactory);
            // 调用BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor的方法
            // 把当前容器传入，这个可以自己点开看看
            // 这行currentRegistryProcessors.add(beanFactory.getBean(ppName,             
            // BeanDefinitionRegistryPostProcessor.class));
			this.invokeBeanFactoryPostProcessors(beanFactory);
            // 注册BeanPostProcessor对象，后面会画图解释，为什么要注册这个
            // String[] postProcessorNames =                 
            // beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
			this.registerBeanPostProcessors(beanFactory);
            // 国际化
			this.initMessageSource();
            // 初始化事件管理类applicationEventMulticaster
			this.initApplicationEventMulticaster();
            // 模板方法，留给子类实现
			this.onRefresh();
            // 往事件管理类中注册事件类
			this.registerListeners();
            // bean实例化，属性赋值，前后置处理，aop代理
			this.finishBeanFactoryInitialization(beanFactory);
			this.finishRefresh();
		} catch (BeansException var9) {
			if (this.logger.isWarnEnabled()) {
				this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
			}
            // 异常就destory容器中的所有单例bean
			this.destroyBeans();
			this.cancelRefresh(var9);
			throw var9;
		} finally {
			this.resetCommonCaches();
		}

	}
}

3.3 finishBeanFactoryInitialization方法

        此处之后的代码都是Spring的源码

// 当前类：AbstractApplicationContext，下载的源码
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// Initialize conversion service for this context.
	if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
			beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
		beanFactory.setConversionService(
				beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
	}

	// Register a default embedded value resolver if no bean post-processor
	// (such as a PropertyPlaceholderConfigurer bean) registered any before:
	// at this point, primarily for resolution in annotation attribute values.
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		getBean(weaverAwareName);
	}

	// Stop using the temporary ClassLoader for type matching.
	beanFactory.setTempClassLoader(null);

	// Allow for caching all bean definition metadata, not expecting further changes.
	beanFactory.freezeConfiguration();

	// Instantiate all remaining (non-lazy-init) singletons.
    // 实例化所有的非懒加载的单例
	beanFactory.preInstantiateSingletons();
}

3.4 preInstantiateSingletons方法

// 当前类：DefaultListableBeanFactory，下载的源码
public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("Pre-instantiating singletons in " + this);
	}

	// 容器初始化之后保存的所有的beanName集合
	List beanNames = new ArrayList<>(this.beanDefinitionNames);

	// Trigger initialization of all non-lazy singleton beans...
	for (String beanName : beanNames) {
    // 得到该beanName的BeanDefinition和父BeanDefinition信息，包装在RootBeanDefinition里面
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

        // 不是抽象的，而且是单例，非懒加载的，就实例化
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

            // 判断是不是工厂bean，这种bean的有特殊处理方式不同，
            // 可以查看相关文章看看是不是FactoryBean
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					final FactoryBean factory = (FactoryBean) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction)
										((SmartFactoryBean) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {
                // 其他单例bean
				getBean(beanName);
			}
		}
	}

	// Trigger post-initialization callback for all applicable beans...
    // bean初始化之后的回调，不讲解没研究过。。。
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction