Spring IOC：doGetBean创建流程简要分析

一. 首先先看doGetBean的代码，这里只分析主要的代码 非必要的就不分析了

简要分析

1. 从缓存中获取bean，如果获取到了则直接获取bean实例返回
2. 没有获取到就去创建
3. 如果有父bean，就先创建父bean
4. 合并bean
5. 检查合并后的bean是否依赖其他的bean，若有先创建依赖的bean
6. 创建不通生命周期的bean

@SuppressWarnings("unchecked")
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		//解析bean的名字 可能有别名
		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		// 获取bean 
		// 1.singletonObjects：单例对象的cache当中获取
		// 2.earlySingletonObjects：提前曝光单例对象的Cache
		// 3.singletonFactories：单例对象工厂的cache
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			...........
			//获取指定bean的示实例对象，主要用于FactoryBean的特殊处理，普通Bean会直接返回sharedInstance本身
			//下面会经常用到这个方法
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
	
			// Check if bean definition exists in this factory.
			// 获取父容器的bean 然后创建父bean
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				//合并bean
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				// 是否有当前bean以来的bean，先创建依赖的bean
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						registerDependentBean(dep, beanName);
						getBean(dep);
					}
				}

				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							//核心  开始创建bean 
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					//获取bean 实例
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				//后面代码省略 就是创建不同作用域的bean 如scope、session、request等
				.....

		return (T) bean;
	}

二、createBean方法

简要分析

1. resolveBeforeInstantiation这个方法如果返回一个代理的bean则后续的实例化初始化都会被阶段，而返回这个代理的bean。
2. doCreateBean真正创建bean的方法

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		......

		try {
			// BeanPostProcessor有机会返回代理对象，直接截断后面的创建过程。返回的是一个代理的bean
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}

		try {
			//真正创建实例 初始化的方法
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
	.....
			return beanInstance;
		}
	
	}

三、doCreateBean方法

简要分析

1. 创建 bean 实例
2. 循环引用的处理
3. bean 实例属性填充
4. bean 实例的初始化
5. BeanPostProcessor 的各种扩展应用

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		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();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					//MergedBeanDefinitionPostProcessor中的方法  修改bean定义   
					//例如 @Autowire注解就是在这儿进行成员信息的收集
					//收集注入信息  合并bean的定义信息
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				//设置状态 表示已经进行处理
				mbd.postProcessed = true;
			}
		}

		// 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));
		if (earlySingletonExposure) {
			//getEarlyBeanReference  获得早期循环依赖的bean
			//加入到缓存 当中  这样在开头的doGetBean方法中的getSingleton就有了缓存
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			//给定属性 填充bean的实例 进行属性填充
			populateBean(beanName, mbd, instanceWrapper);
			//在这儿进行初始化  提示：（初始化和实例化的区别）
			//生命周期的初始化  xxxAware等接口就是在这儿执行的 可以看一下代码了解他的执行顺序
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		.......

		return exposedObject;
	}

图片地址

图片地址