Spring源码分析——Bean的加载

最新推荐文章于 2023-12-07 23:24:20 发布

GeorgiaStar

最新推荐文章于 2023-12-07 23:24:20 发布

阅读量240

点赞数

分类专栏：容器与框架 Java Web学习笔记

本文链接：https://blog.csdn.net/fuzhongmin05/article/details/110524224

版权

Java Web学习笔记同时被 2 个专栏收录

44 篇文章 8 订阅

订阅专栏

容器与框架

25 篇文章 9 订阅

订阅专栏

背景

Spring版本：5.1.14.RELEASE

仔细阅读依赖注入(Dependency Injection)框架是如何实现的这篇博文后，我们大致知道了一个DI容器是如何创建bean的。总体来，bean的创建流程分为如下三步：

定义化：从xml文件中解析bean的定义(获得BeanDefinition实例)，之后创建bean都是通过bean的定义去创建。
实例化：实例化的过程是一个创建Bean的过程，即调用Bean的构造函数，单例的Bean放入单例池中。
初始化：初始化的过程是一个赋值的过程，即调用Bean的setter，设置Bean的属性。

更为关键的是，在这三个阶段中，Spring给我们预留了很多扩展点去做自定义的工作。

在Bean从创建到销毁的整个生命周期中会执行的方法：

有了以上基础知识后，本文解读Spring源码，从getBean()开始一路探讨容器是如何加载到bean的。

bean的加载

追踪源码可以发现ApplicationContext.getBean()的内部实现是BeanFactory.getBean()，而BeanFactory.getBean()的内部实现是AbstractBeanFactory.getBean()，所有AbstractBeanFactory.getBean()方法最终都调用了AbstractBeanFactory.doGetBean()。

流程：
ApplicationContext.getBean()—>BeanFactory.getBean()—>AbstractBeanFactory.getBean()—>AbstractBeanFactory.doGetBean()

核心就是要了解AbstractBeanFactory#doGetBean()方法的的处理逻辑，这个方法写得很长。

/**
 - Return an instance, which may be shared or independent, of the specified bean.
 */
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
		@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

	final String beanName = transformedBeanName(name);
	Object bean;
	//先尝试从缓存中或者ObjectFactory中获取
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null && args == null) {
		if (logger.isTraceEnabled()) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
						"' that is not fully initialized yet - a consequence of a circular reference");
			}
			else {
				logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
			}
		}
		//有时候并不是返回实例本身，而是返回对应的实例。主要处理实现了FactoryBean接口的bean
		//如果某个bean实现了FactoryBean接口，通过getBean方法来获取bean的时候，并不是返回自己的实例，而是返回其getObject()方法的返回值
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}
	// 缓存中不存在该bean的实例
	else {
		//判断原型模式的bean是否已经处于创建过程中，避免循环依赖
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
		//如果本BeanFactory找不到就尝试从父BeanFactory中查找
		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 if (requiredType != null) {
				// No args -> delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}
		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}
		try {
			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);
			// 确保当前bean依赖的bean的初始化
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					// 注册依赖的bean
					registerDependentBean(dep, beanName);
					try {
						//创建当前bean依赖的bean
						getBean(dep);
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}
			//根据单例模式或原型模式创建bean
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, () -> {
					try {
						return createBean(beanName, mbd, args);
					}
					catch (BeansException ex) {
						destroySingleton(beanName);
						throw ex;
					}
				});
				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}
			else if (mbd.isPrototype()) {
				// It's a prototype -> create a new instance.
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}
		   //创建其他作用域的bean
			else {
				String scopeName = mbd.getScope();
				final Scope scope = this.scopes.get(scopeName);
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
				}
				try {
					Object scopedInstance = scope.get(beanName, () -> {
						beforePrototypeCreation(beanName);
						try {
							return createBean(beanName, mbd, args);
						}
						finally {
							afterPrototypeCreation(beanName);
						}
					});
					bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
				catch (IllegalStateException ex) {
					throw new BeanCreationException(beanName,
							"Scope '" + scopeName + "' is not active for the current thread; consider " +
							"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
							ex);
				}
			}
		}
		catch (BeansException ex) {
			cleanupAfterBeanCreationFailure(beanName);
			throw ex;
		}
	}
	// 检查所需的类型是否与实际bean实例的类型匹配，若不匹配做类型转换
	if (requiredType != null && !requiredType.isInstance(bean)) {
		try {
			T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
			if (convertedBean == null) {
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
			return convertedBean;
		}
		catch (TypeMismatchException ex) {
			if (logger.isTraceEnabled()) {
				logger.trace("Failed to convert bean '" + name + "' to required type '" +
						ClassUtils.getQualifiedName(requiredType) + "'", ex);
			}
			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
		}
	}
	return (T) bean;
}

doGetBean()方法很长，其执行的大致流程如下：

transformedBeanName(name)将bean名称的前缀"&"去掉
getSingleton(beanName)尝试从缓存中加载单例
如果bean实现了FactoryBean接口，作处理
isPrototypeCurrentlyIncreation(beanName)原型模式的循环依赖检查
检测父BeanFactory
依赖检测
根据不同的模式调用creatBean()方法创建bean实例
检查类型，如果需要则做类型转换

以上方法中，哪一步是重中之重一目了然。createBean()根据不同的模式创建bean，是实例化一个Bean的主要逻辑。

下面主要分析createBean()方法，该方法是AbstractBeanFactory的protected方法，由子类去实现。Debug跟踪发现该方法的实现在AbstractAutowireCapableBeanFactory类中。

/**
 * Central method of this class: creates a bean instance,
 * populates the bean instance, applies post-processors, etc.
 * @see #doCreateBean
 */
@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;
	//解析指定BeanDefinition的Class，并将已经解析的Class存储在Beandefinition中以供后面使用
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}
	// 对lookup-method和replace-method属性的处理（指定方法的覆盖）
	try {
		mbdToUse.prepareMethodOverrides();
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
				beanName, "Validation of method overrides failed", ex);
	}
	try {
		//调用后置处理器返回代理bean，只针对InstantiationAwareBeanPostProcessor接口
		//的postProcessBeforeInstantiation方法
		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 {
		//真正的创建bean
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isTraceEnabled()) {
			logger.trace("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
	catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
		throw ex;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
	}
}

createBean()方法执行的大致流程如下：

解析指定BeanDefinition的Class，并将已经解析的Class存储在Beandefinition中
对lookup-method和replace-method属性的处理（指定方法的覆盖）
调用后置处理器返回代理bean（只针对InstantiationAwareBeanPostProcessor的before）
执行doCreateBean()，真正的创建bean

Bean的创建过程大部分是在doCreateBean()里面完成的。

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

	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	//如果RootBeanDefinition是单例的，则移除未完成的FactoryBean实例的缓存
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	//获取BeanWrapper中封装的Object对象，其实就是bean对象的实例
	final Object bean = instanceWrapper.getWrappedInstance();
	//获取BeanWrapper中封装的bean的Class
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	synchronized (mbd.postProcessingLock) {
	//bean的生命周期之一，如果实现了MergedBeanDefinitionPostProcessor
	//会在这里调用postProcessMergedBeanDefinition方法
		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;
		}
	}
	//提前缓存单例，以便能够解析循环引用
	//即使是由诸如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));
	}

	//bean的属性填充
	Object exposedObject = bean;
	try {
		//填充属性，处理@AutoWried
		populateBean(beanName, mbd, instanceWrapper);
		//bean的初始化方
		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);
		}
	}

	//如果单例bean已经缓存了，则直接获取      
	if (earlySingletonExposure) {
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			//如果不允许在循环引用的情况下使用setter注入原始bean实例
			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.");
				}
			}
		}
	}
	//注册DisposableBean，如果配置了destroy-methoy，这里需要注册以便于在销毁的时候调用
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}
	return exposedObject;
}

大致如下：

如果RootBeanDefinition是单例的，则移除未完成的FactoryBean实例的缓存
实例化Bean，仅是调用构造器，还没做属性的注入
如果实现了MergedBeanDefinitionPostProcessor，调用postProcessMergedBeanDefinition方法
populateBean()属性填充，处理@Autowired、@Resource等注解
自定义初始化bean，bean生命周期中各种init、Aware、BeanPostProcessor方法的调用都在这一步。调用顺序：Aware—>BeanPostProcessor的before—>@PostConstruct->init—>BeanPostProcessor的after
注册DisposableBean

Bean实例创建过程汇总为下图：