Spring源码分析-03-createBean()过程解析

发表于 更新于 分类于 ， Valine：
本文字数： 14k 阅读时长 ≈ 13 分钟
  • 本文主要讲述创建单例bean(即createBean(beanName, mbd,args))这一过程, 暂不包括处理循环依赖这一过程.

image.png

  • PS: 若文章字体偏大或者偏小,建议通过 ctrl键+鼠标滑轮 进行修改,以提升阅读效果.(带来不便,请谅解!

Version:

jdk :1.8

Spring: 5.1.7

前提须知:

Bean生命周期:

createBean():
	// 1. 尝试获取bean代理对象
	resolveBeforeInstantiation():
		postProcessBeforeInstantiation()
     	postProcessAfterInstantiation()
    // 2.创建bean
    doCreateBean():
		//2.1 实例化 根据factory method| constructor autowired | no-arg constructor 创建
		createBeanInstance():
		//2.2 属性赋值<bean property>
		populateBean(beanName,mbd,instanceWrapper):
		//2.3 初始化bean
		initializeBean(beanName,exposedObj,mbd):
			 invokeAwareMethods(beanName, bean);// 执行aware方法 :beanNameAware, classloaderAware... 
			 applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);//BeanPostProcessor 处理bean
			 invokeInitMethods(beanName, wrappedBean, mbd);// 执行初始化方法
			 applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);// beanPostProcessor 处理bean
        //2.4 注册销毁方法
 		registerDisposableBeanIfNecessary(beanName, bean, mbd);

BeanPostProcessor:

SmartInstantiationAwareBeanPostProcessor

源码分析

createBean(beanName,mbd,args)

  • AbstractAutowireCapableBeanFactory.java

    流程图:image-20210309164031410

  • 步骤描述

    1. 根据BeanDefinition 回去到 Bean 的Class 类信息

      1. Class<?> resolvedClass = resolveBeanClass(mbd, beanName); // ( 不重要)

    2. 尝试通过 BeanPostProcessor 获得代理对象 : 即

      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);//不重要

    3. 创建 单例 bean

      1. 实例化 Object beanInstance = doCreateBean(beanName, mbdToUse, args); // 重要
      2. 属性注入
      3. 初始化
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {

   if (logger.isTraceEnabled()) {
      logger.trace("Creating instance of bean '" + beanName + "'");
   }
   RootBeanDefinition mbdToUse = mbd;
   // 1. 准备bean class
   //1. Make sure bean class is actually resolved at this point, and
   // clone the bean definition in case of a dynamically resolved Class
   // which cannot be stored in the shared merged bean definition.
   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
   }

   // Prepare method overrides.//
   try {
      mbdToUse.prepareMethodOverrides();
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
            beanName, "Validation of method overrides failed", ex);
   }
   // 2.尝试通过beanPostProcessor的方式获得代理对象,
   try {// 给bean后置处理器一个机会来返回代理对象(对bean对象有加强),而不是bean本身实例
      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);//
      if (bean != null) {
         return bean;
      }
   }
   catch (Throwable ex) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
            "BeanPostProcessor before instantiation of bean failed", ex);
   }
   //3.  创建单例bean
   try {
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isTraceEnabled()) {
         logger.trace("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
   }
   catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      // A previously detected exception with proper bean creation context already,
      // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
      throw ex;
   } //
   catch (Throwable ex) {
      throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
   }
}

人话描述doCreateBean具体流程:

  1. 实例化 bean
    1. 创建单例bean , 并包装生成 wrapBean
      1. instanceWrapper = createBeanInstance(beanName, mbd, args);
    2. 标记单例bean 是否可以循环依赖, 是的话将其singletonFactory加入到SingletonFactories(三级缓存)中
      1. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                     isSingletonCurrentlyInCreation(beanName));
      2. addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  2. 初始化 bean
    1. populateBean(beanName, mbd, instanceWrapper);
    2. exposedObject = initializeBean(beanName, exposedObject, mbd);
  3. 处理循环依赖 (暂时不了解, 以后会详细处理这个东西)
  4. 注册销毁方法
  5. 返回对象

doCreateBean(beanName,mbd,arg)

  • protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {
	// 1. 实例化bean
	// 1. Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}// 1 利用factory method | constructor autowired | SmartInstantiationAwareBeanPostProcessor  |  no-arg constructor
	if (instanceWrapper == null) {// 1.1 创建单例bean(跳过)
			instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}
	// 1.1. 调用 mergedBeanDefinitionPostProcessor 后置处理器 处理
	// 1.1. Allow post-processors to modify the merged bean definition.
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {//bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.postProcessed = true;
		}
	}
	// 2. 判断单例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));
	if (earlySingletonExposure) {
		if (logger.isTraceEnabled()) {
			logger.trace("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}//添加单例工厂, 已创建 单例bean
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}
	//3. 初始化单例bean
	//3. Initialize the bean instance.
	Object exposedObject = bean;
	try {// 赋值 bean 1. ibp.postProcessAfterInstantiation(); 2. ibp.postProcessProperties()
		populateBean(beanName, mbd, instanceWrapper);
		exposedObject = initializeBean(beanName, exposedObject, mbd);//1. processor.postProcessBeforeInitialization(result, beanName);
	}
	catch (Throwable ex) {
		if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
			throw (BeanCreationException) ex;
		}
		else {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
		}
	}
	// 4 处理循环依赖问题, 这里不讨论
	if (earlySingletonExposure) {
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) { //// TODO: 2021/3/2  
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				for (String dependentBean : dependentBeans) {
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
				if (!actualDependentBeans.isEmpty()) {
					throw new BeanCurrentlyInCreationException(beanName,
							"Bean with name '" + beanName + "' has been injected into other beans [" +
							StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
							"] in its raw version as part of a circular reference, but has eventually been " +
							"wrapped. This means that said other beans do not use the final version of the " +
							"bean. This is often the result of over-eager type matching - consider using " +
							"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}
	// 5. 注册销毁方法
	// 5. Register bean as disposable.
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}

	return exposedObject;
}

主要功能流程图

image-20210402150218139

具体步骤:

PS: 下面过程描述比较乱, 希望见谅. 重点可以选择看图主要功能流程图

实例化
  • 创建 一个bean 对象, 并wrap 一下
instanceWrapper = createBeanInstance(beanName, mbd, args);

利用 factory method || constructor autowired | SmartInstantiationAwareBeanPostProcessor | no-arg constructor 来实例化对象.

  • 核心依旧是利用反射来创建对象.

**以创建 org.springframework.context.event.internalEventListenerFactory 对象为例进行说明: **

image-20210402145529574

PS: 具体的代码流程可以不先看, 保证总体思路清晰在去dfs 升入了解这个方法(也可以不了解) 随你爱好.

AbstractAutowiredCapableBeanFactory.createBeanInstance(args)

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		Class<?> beanClass = resolveBeanClass(mbd, beanName);// 找到mbd的Class

		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}
		//1.  factory method  to get a bean
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}
		//2. constructor autowiring
		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				return instantiateBean(beanName, mbd);
			}
		}
		// 尝试利用 SmartInstantiationAwareBeanPostProcessor 这个接口 获取 constructor
		// Candidate constructors for autowiring?
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// Preferred constructors for default construction?
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}
		// 3. normal no-arg constructor
		// No special handling: simply use no-arg constructor.
		return instantiateBean(beanName, mbd);
	}
属性注入

PS: 对于现阶段的我而言, 不重要, 嫌烦的,代码可以不看, 但是必须要看 汉字部分,结合图示

目前,对我而言, 只需要关注bean的生命周期所做的事情即可, 即

​ 1. ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName);

​ 2. ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);

​ 3. applyPropertyValues(beanName, mbd, bw, pvs); // 处理属性值,类型转化,deep copy 等

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}
		// 给InstantiationAwareBeanPostProcessors 一个机会 赋值,
		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		boolean continueWithPropertyPopulation = true;
		//1 .处理 InstantiationAwareBeanPostProcessor
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		if (!continueWithPropertyPopulation) {
			return;
		}

		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		// 处理 @autowired 注解
		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}
		// 判断是否有 instantiationAware
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
		}
		if (needsDepCheck) {
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}
初始化

PS: 同上, 可以不看,关注点放在 bean上

  1. invokeAwareMethods(beanName, bean);
  2. applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  3. invokeInitMethods(beanName, wrappedBean, mbd);
  4. applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {//1. 执行aware 接口方法 BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
			invokeAwareMethods(beanName, bean);
		}
			//2. 执行初始化方法前, BeanPostProcessor 加强
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {//3. 执行初始化方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}//4. 执行初始化方法后 BeanPostProcessor
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

总结:

  • 需要自己去看几个接口, BeanPostProcessor及其继承接口 ,阅读前必看!!!
  • 本文重点描述了Bean 的生命周期:
    • 实例化 : beforeInstant() -> 实例化 -> afterInstant()
    • 属性注入: postProcessProperties(pvs, bw.getWrappedInstance(), beanName)
    • 初始化: XXXAware-> beforeInit() -> init() -> afterInit()
  • 自己只是看了源码, 文章中难免会存在错误,发现后希望读者可以指出错误(不过估计没有人会看….).
  • 源码阅读建议:BFS 而不是DFS 模式阅读..

参考:

猜你喜欢