【spring】创建Bean的方法：createBean源码分析

createBean简单介绍

• 本文源码基于spring-framework-5.3.10。
• 这个方法有Bean的一大半生命周期

createBean的核心流程

• 实例化前：InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
• 实例化：推断构造方法
• 后置处理合并后的BeanDefinition：MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
• 实例化后：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
• 属性赋值，自动注入（@Autowired、@Resource、@Value）：InstantiationAwareBeanPostProcessor.postProcessProperties()
• 回调：Aware对象
• 初始化前：BeanPostProcessor.postProcessBeforeInitialization()
• 初始化
• 初始化后：BeanPostProcessor.postProcessAfterInitialization()

源码分析

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

	// 日志打印
	if (logger.isTraceEnabled()) {
		logger.trace("Creating instance of bean '" + beanName + "'");
	}
	// 使用的BeanDefinition
	RootBeanDefinition mbdToUse = mbd;

	// 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.
	// 马上就要实例化Bean了，确保beanClass被加载了
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	// Bean被加载，并且当前BeanDefinition的beanClass属性不是class类型，并且对应的BeanNam不是Null
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		// 重新定义一个BeanDefinition。这里之前的BeanClass属性是字符串！
		mbdToUse = new RootBeanDefinition(mbd);
		// 把上面实例化的Bean设置进去
		mbdToUse.setBeanClass(resolvedClass);
	}

	// Prepare method overrides.
	// 这里主要处理@Lookup注解，进行方法的替代！
	try {
		mbdToUse.prepareMethodOverrides();
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
				beanName, "Validation of method overrides failed", ex);
	}

	try {
		// 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);
	}

	try {
		// spring本身的实例化
		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);
	}
}

确保Bean被加载的方法：resolveBeanClass源码分析

protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)
		throws CannotLoadBeanClassException {

	try {
		// 校验当前BeanDefinition的beanClass属性是Bean的名字还是Bean的class信息：如果beanClass被加载了（beanClass的类型是class），直接返回
		if (mbd.hasBeanClass()) {
			return mbd.getBeanClass();
		}

		// 如果beanClass没有被加载，进行Bean的加载
		if (System.getSecurityManager() != null) {
			return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
					() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
		}
		else {
			return doResolveBeanClass(mbd, typesToMatch);
		}
	}
	catch (PrivilegedActionException pae) {
		ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
		throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
	}
	catch (ClassNotFoundException ex) {
		throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
	}
	catch (LinkageError err) {
		throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
	}
}

真正的创建方法:doResolveBeanClass源码分析

private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
		throws ClassNotFoundException {
	// 得到当前Bean的类加载器
	ClassLoader beanClassLoader = getBeanClassLoader();
	// 定义一个动态的类加载器。有临时类加载器用临时类加载器，没有临时类加载器用现在这个
	ClassLoader dynamicLoader = beanClassLoader;
	// 表示RootBeanDefinition的配置的bean类名需要重新被dynameicLoader加载的标记，默认不需要
	boolean freshResolve = false;

	// 进行类型匹配
	if (!ObjectUtils.isEmpty(typesToMatch)) {
		// When just doing type checks (i.e. not creating an actual instance yet),
		// use the specified temporary class loader (e.g. in a weaving scenario).
		// 一个临时的类加载器，用于类型的匹配校验
		ClassLoader tempClassLoader = getTempClassLoader();
		// 解析的值不一样，走下面的逻辑
		if (tempClassLoader != null) {
			// 吧当前的类加载器赋值给动态类加载器
			dynamicLoader = tempClassLoader;
			// 标记当前的RootBeanDefinition需要被dynamicLoader解析
			freshResolve = true;
			// 他是spring自定义的DecoratingClassLoader类加载器
			if (tempClassLoader instanceof DecoratingClassLoader) {
				// 类加载器强转
				DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
				// 类型匹配！
				for (Class<?> typeToMatch : typesToMatch) {
					dcl.excludeClass(typeToMatch.getName());
				}
			}
		}
	}

	// 获取className：beanClass是名称直接返回，是class返回class对应的Name
	String className = mbd.getBeanClassName();
	if (className != null) {
		// 解析Spring表达式，有可能直接返回了一个Class对象
		Object evaluated = evaluateBeanDefinitionString(className, mbd);
		// 表达式解析的类型不一致
		if (!className.equals(evaluated)) {
			// A dynamically resolved expression, supported as of 4.2...
			// 4.2支持动态的类型。能得到class类型直接返回
			if (evaluated instanceof Class) {
				return (Class<?>) evaluated;
			}
			// 得到的是字符串
			else if (evaluated instanceof String) {
				// BeanName赋值
				className = (String) evaluated;
				// 标记当前的RootBeanDefinition需要被dynamicLoader解析
				freshResolve = true;
			}
			else {
				// 除了class类型和字符串，其他的直接抛异常
				throw new IllegalStateException("Invalid class name expression result: " + evaluated);
			}
		}
		// 类没有被加载的时候，进行加载
		if (freshResolve) {
			// When resolving against a temporary class loader, exit early in order
			// to avoid storing the resolved Class in the bean definition.
			// 类加载器不能为空！
			if (dynamicLoader != null) {
				try {
					// 返回用dynamicLoader具体的类加载器加载类，得到class对象
					return dynamicLoader.loadClass(className);
				}
				catch (ClassNotFoundException ex) {
					if (logger.isTraceEnabled()) {
						logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
					}
				}
			}
			// 加载数组，String，基本类型
			return ClassUtils.forName(className, dynamicLoader);
		}
	}

	// Resolve regularly, caching the result in the BeanDefinition...
	// 定期解析，将结果缓存在BeanDefinition中。可以通过AbstractBeanDefinition#getBeanClass来获取缓存
	return mbd.resolveBeanClass(beanClassLoader);
}

创建Bean使用的类加载器信息

/**
 * 获取类加载器信息的方法
 */
public ClassLoader getBeanClassLoader() {
	return this.beanClassLoader;
}

// 使用的类加载器信息
private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

/**
 * 初始化类加载器的方法
 */
public static ClassLoader getDefaultClassLoader() {
	ClassLoader cl = null;

	// 优先获取线程中的类加载器。通过Thread.currentThread().setContextClassLoader(cl)进行设置
	try {
		cl = Thread.currentThread().getContextClassLoader();
	}
	catch (Throwable ex) {
		// Cannot access thread context ClassLoader - falling back...
	}

	// 线程中类加载器为null的情况下，获取加载ClassUtils类的类加载器
	if (cl == null) {
		// No thread context class loader -> use class loader of this class.
		// 使用和ClassUtils相同的类加载器。简单理解就是和spring-core包放的位置有关系
		cl = ClassUtils.class.getClassLoader();
		if (cl == null) {
			// getClassLoader() returning null indicates the bootstrap ClassLoader
			// 加入ClassUtils是被Bootstrap类加载器加载的，则获取系统类加载器。（jre/lib目录下）
			try {
				cl = ClassLoader.getSystemClassLoader();
			}
			catch (Throwable ex) {
				// Cannot access system ClassLoader - oh well, maybe the caller can live with null...
			}
		}
	}
	return cl;
}

实例化前:resolveBeforeInstantiation源码分析

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	// 如果当前还没有进行实例化钱的操作
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		// Make sure bean class is actually resolved at this point.
		// synthetic表示合成，如果某些Bean式合成的，那么则不会经过BeanPostProcessor的处理。并且他有实例化前的实现：。并且把所有的InstantiationAwareBeanPostProcessor、SmartInstantiationAwareBeanPostProcessor、DestructionAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor加入到BeanPostProcessorCache，判断加入后有没有InstantiationAwareBeanPostProcessor。
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			// 得到class类型
			Class<?> targetType = determineTargetType(beanName, mbd);
			// 得到的class类型不为null
			if (targetType != null) {
				// 循环调用每个postProcessBeforeInstantiation方法，直到有返回值（自己去实例化），或者执行完返回null（让spring去实例化）
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
				// 如果其中一个有返回值，循环调用每个postProcessAfterInitialization方法，直到有一个返回值为null（没有实例化成功）。否则返回具体的值（自己实例化成功）。这里主要是为了Bean的AOP
				if (bean != null) {
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		// bean有值说明实例化成功，下次的这个判断不会进来，否则会继续执行
		mbd.beforeInstantiationResolved = (bean != null);
	}
	// 返回当前的处理过的Bean
	return bean;
}

spring本身的实例化方法

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

	// 实例化bean
	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	// 这个Bean是单例的
	if (mbd.isSingleton()) {
		// 有可能在本Bean创建之前，就有其他Bean把当前Bean给创建出来了（比如依赖注入过程中）。factoryBean需要重新创建
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		// 创建Bean实例：推断构造方法，@Bean的处理
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	// 得到Bean对象
	Object bean = instanceWrapper.getWrappedInstance();
	// 得到Bean的类型
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// 后置处理合并后的BeanDefinition（MergedBeanDefinitionPostProcessor）：比如可以进行初始化方法的设置，比如添加属性值。spring友谊个默认的实现去寻找注入点。
	// Allow post-processors to modify the merged bean definition.
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			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) {
		if (logger.isTraceEnabled()) {
			logger.trace("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}
		// 循环依赖-添加到三级缓存
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		// 属性填充
		populateBean(beanName, mbd, instanceWrapper);  //getBean()

		// 初始化:包括三个回调以及初始化前中后
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	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);
		}
	}

	// 第二次处理循环依赖问题
	if (earlySingletonExposure) {
		// 从一级、二级缓存中获取Bean
		Object earlySingletonReference = getSingleton(beanName, false);
		// 获取到了
		if (earlySingletonReference != null) {
			// 是当前Bean，放入二级缓存
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				// beanName被哪些bean依赖了，现在发现beanName所对应的bean对象发生了改变，那么则会报错
				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 " +
							"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}

	// Register bean as disposable.
	// 处理Bean销毁前要执行的方法
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}

	return exposedObject;
}

属性填充：populateBean源码分析

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	// Bean不存在的时候，直接返回或者抛异常
	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;
		}
	}

	// 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.
	// 实例化后，属性设置之前。循环调用每个实现postProcessAfterInstantiation的方法
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
				return;
			}
		}
	}

	// 得到所有的属性值
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

	// 依赖注入的逻辑
	int resolvedAutowireMode = mbd.getResolvedAutowireMode();
	// 这个判断是spring自带的依赖注入逻辑。可以在@Bean上配置autowire属性配置ByName或者ByType（已过期）
	if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
		// MutablePropertyValues是PropertyValues具体的实现类
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		// Add property values based on autowire by name if applicable.
		// ByName找的是set方法，比如setXxxxx就会找xxxx，setName就会找Name
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		// Add property values based on autowire by type if applicable.
		// ByType找的是set方法，从Bean中找到当前类型的入参，进行传入
		if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}
		pvs = newPvs;
	}

	// 获取是否有实现InstantiationAwareBeanPostProcessor的方法，这里主要使用postProcessProperties方法。
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	// 获取是否需要进行依赖注入
	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

	PropertyDescriptor[] filteredPds = null;
	if (hasInstAwareBpps) {
		// 属性为空，获取需要注入的信息
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			// 这里会调用AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法，会直接给对象中的属性赋值。真正的处理@Autowired、@Resource、@Value注解
			// AutowiredAnnotationBeanPostProcessor内部并不会处理pvs。直接返回自己设置的PropertyValues对象（可以在实例化前设置）。
			PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
			// 这里的含义是程序员自己已经给属性赋值了，就不需要Spring给他赋值。这里是程序员没有赋值，所以需要Spring进行赋值
			if (pvsToUse == null) {
				// 第一次进来一般为空
				if (filteredPds == null) {
					filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
				}
				// 和postProcessProperties类似，但是已经过期了
				pvsToUse = bp.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);
	}

	// 如果当前Bean中的BeanDefinition中设置了PropertyValues，那么最终将是PropertyValues中的值，覆盖@Autowired
	if (pvs != null) {
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

初始化逻辑：initializeBean源码分析

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
	// 这里主要进行了三个Aware回调
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;

	// 初始化前：主要的实现有初始化方法@postconstruct，很多的Aware回调都在初始化前
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	// 初始化：
	try {
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				(mbd != null ? mbd.getResourceDescription() : null),
				beanName, "Invocation of init method failed", ex);
	}

	// 初始化后：aop
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

private void invokeAwareMethods(String beanName, Object bean) {
	// 实现了Aware以及其子类
	if (bean instanceof Aware) {
		// BeanNameAware回调
		if (bean instanceof BeanNameAware) {
			((BeanNameAware) bean).setBeanName(beanName);
		}
		// BeanClassLoaderAware回调
		if (bean instanceof BeanClassLoaderAware) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		// BeanFactoryAware回调
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

结束语

• 获取更多本文的前置知识文章，以及新的有价值的文章，让我们一起成为架构师！
• 关注公众号，可以让你对MySQL、并发编程、spring源码有深入的了解！
• 关注公众号，后续持续高效的学习JVM！
• 这个公众号，无广告！！！每日更新！！！