Spring源码阅读-IOC(二)

前言

今天开始跟你们一块儿进入spring源码阅读阶段,咱们将从一个你们比较熟悉的高级容器-ClassPathXmlApplicationContext为入口去了解spring容器的加载过程。

IOC容器的加载

ClassPathXmlApplicationContext有许多构造函数，咱们找到真的调用的入口。
复制代码

public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz, @Nullable ApplicationContext parent)
			throws BeansException {
        //加载容器前的一些处理
		super(parent);
		Assert.notNull(paths, "Path array must not be null");
		Assert.notNull(clazz, "Class argument must not be null");
		this.configResources = new Resource[paths.length];
		for (int i = 0; i < paths.length; i++) {
			this.configResources[i] = new ClassPathResource(paths[i], clazz);
		}
		//真正开始加载容器的方法
		refresh();
	}
复制代码

这个构造函数中，咱们只须要关注最后一个方法refresh()，这个才是容器加载的入口，下面咱们跟进去看下具体的内容。

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
            //刷新容器前的预处理,包括删除旧容器等
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
            // 	建立bean工厂
            //	加载解析XML文件，并完成BeanDefinition的加载和注册
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
                initMessageSource();

				// Initialize event multicaster for this context.
                initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
                onRefresh();

				// Check for listener beans and register them.
                registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				// 实例化剩余的单例bean（非懒加载方式）
                // Bean的IoC、DI和AOP都是发生在这个过程当中
                finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
                finishRefresh();
			}
        。。。。。
	}
复制代码

spring容器的加载有多个步骤，咱们主要关系里面的两个步骤

• obtainFreshBeanFactory():该方法主要是建立springBean工厂，同时加载xml配置文件，将配置文件中的bean标签，解析成一个个BeanDefinition对象，并注册到spring容器中
• finishBeanFactoryInitialization(beanFactory)：该方法是实例化spring中非懒加载的单例bean，同时spring中的依赖注入和产生代理对象都是在这个过程当中完成的。

而剩余的其余步骤，主要初始哈一些BeanPostProcessor，然括对BeanDefinition的一些处理，初始化一些特殊的bean，而后注册监听器，最后广播加载完成的消息等一些功能。这些功能分支，你们有兴趣的能够本身进行了解，在这里就不一一详细说明了。今天，咱们主要是来看springBean的加载，及初始化流程。也就是，咱们主要看finishBeanFactoryInitialization该方法完成的内容。

下面咱们就接着看finishBeanFactoryInitialization这个方法到底完成了些什么事情:

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	
	。。。。。。。。。

		// Instantiate all remaining (non-lazy-init) singletons.
		// 完成单例Bean的初始化
		beanFactory.preInstantiateSingletons();
	}
复制代码

这个方法前面的一些内容咱们并不须要太多关注，咱们看到方法最后，这个preInstantiateSingletons()就是实例化咱们单例bean的入口:

public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		// 加载全部非懒加载方式的单例bena
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				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<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else { // 普通bean走下面的方法
					getBean(beanName);
				}
			}
		}
复制代码

咱们来一步步看下这个方法

• 便利全部的beanName,而后从BeanDefinition集合中获取到对应的BeanDefinition对象
• 接着判断该对象若是不是抽象类，是个单例对象，不是懒加载方式的就进入执行if()下面的代码
• 接着判断若是这个bean是个特殊的工厂bean，就执行对应的方法。
• 最后就是加载普通的bean

接着咱们顺着getBean方法往下点，最终会来到AbstractBeanFactory中真正建立bean的doCreateBean方法

这里面的代码很长，在这里咱们就不贴出来了，你们跟着个人思路往下看就能够了 *

Object sharedInstance = getSingleton(beanName);
复制代码

首先咱们看到句代码，这个实际上是从spring的缓存容器中获取bean对象，spring容器中一共有三层缓存，一级缓存就是存放spring加载完成的bean对象。而二三级缓存主要是为了解决spring中的循环依赖这个问题（这个问题比较重要，咱们后面会在具体的说明这个问题）。

// 从一级缓存也就是map容器中获取对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				// 从二级缓存中尝试获取单例bean
				singletonObject = this.earlySingletonObjects.get(beanName);
				// allowEarlyReference 
				//是否容许从三级缓存中获取对象就是是否容许循环依赖
				if (singletonObject == null && allowEarlyReference) {
					//尝试从三级缓存中获取单例bean
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						//经过单例工厂获取单例bean
						singletonObject = singletonFactory.getObject();
						//将bean放到二级缓存
						this.earlySingletonObjects.put(beanName, singletonObject);
						//将bean从三级缓存中删除
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
复制代码

这个就是获取单例bean的过程，其中三级缓存中存放的是bean的工厂对象。

接着咱们继续看doCreateBean下面的代码

• 接着就是判断是否获取到了bean对象,若是获取到的是一个Factory对象，就产生对应的bean实例
• 若是没有获取到bean对象，就进入else去建立该bean对象
• 接着就看到咱们最主要的建立单例bean的方法

if (mbd.isSingleton()) {
			sharedInstance = getSingletion(beanName, () -> {
				try {
					// 建立单例Bean的主要方法
					return createBean(beanName, mbd, args);
				}
				catch (BeansException ex) {
					// Explicitly remove instance from singleton cache: It might have been put there
					// eagerly by the creation process, to allow for circular reference resolution.
					// Also remove any beans that received a temporary reference to the bean.
					destroySingleton(beanName);
					throw ex;
				}
			});
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
		}
复制代码

• 这个方法中用了lamda表达式，你们能够直接点进去getSingleton这个方法中。 里面的方法很长咱们主要先关注这两句代码

singletonObject = singletonFactory.getObject();
	newSingleton = true;
复制代码

这个getObject()方法真正的实现是以前的这个createBean(beanName, mbd, args); 这个方法是真正去建立一个bean的方法。这个咱们等下在看。 这个getSingletion方法的最后就是将建立好的bean加入到map容器中，同时删除二三级缓存

addSingleton(beanName, singletonObject);
复制代码

protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// 加入到一级缓存
			this.singletonObjects.put(beanName, singletonObject);
			// 删除三级缓存
			this.singletonFactories.remove(beanName);
			// 删除二级缓存
			this.earlySingletonObjects.remove(beanName);
			// 将beanName加入到已经建立的beanName集合中
			this.registeredSingletons.add(beanName);
		}
	}
复制代码

如今咱们就去看下最后一个creatBean这个建立bean的方法

。。。。
try {
			// 完成Bean实例的建立包括-实例化，依赖注入(填充属性值)，初始化(调用初始化方法)
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isDebugEnabled()) {
				logger.debug("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
。。。
复制代码

里面咱们关注这个doCreateBean()，咱们接着往下找,终于来到了具体建立bean的代码,这代码有点长，咱们截取一些片断

// Instantiate the bean.
		。。。
		//1. 实例化bean对象
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//实例化后的Bean对象
		。。。。。
		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		// 若是该对象是单例的，容许循环依赖，且正在建立中
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		// 为解决循环依赖提早暴露单例Bean，将该Bean放入三级缓存中
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			// 把刚建立的bean放入三级缓存中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			// 属性填充也就是DI的过程
			populateBean(beanName, mbd, instanceWrapper);
			//调用初始化方法，完成初始化操做
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
。。。。。。。
		return exposedObject;
复制代码

这里面主要能够分红三步

• 实例化单例Bean,且将单例bean放入二级缓存
• 进行bean的属性填充
• 对bean进行初始化，就是调用初始化方法完成bean的初始化操做

结语

至此，咱们已经看完了springIOC的主要加载流程，咱们主要对bean的建立过程进行了解读，知道了bean是如何建立出来并加入到容器中。而这里也剩下一个循环依赖的问题，及属性填充的过程咱们尚未进行理解和阅读，这两个问题咱们留到下面的文章为你们讲解，但愿你们多多关注，谢谢阅读。复制代码