本文详细解析了Spring框架中Bean的创建过程，包括BeanDefinition对象的作用、Bean的实例化及初始化流程，以及如何通过BeanFactory接口创建不同作用域的Bean。
概述
spring创建bean时需要一个重要的对象，那就是BeanDefinition对象，spring在创建BeanFactory时会把xml配置文件和注解信息转换为一个个BeanDefinition对象，BeanDefinition对象存储的是单个bean的配置信息，比如依赖类、scope、是否延迟加载等等，对于BeanDefinition的创建过程，可以阅读我的Spring4.3.x 浅析xml配置的解析过程系列，如
把<bean>标签转换成BeanDefinition对象
解析context命名空间之annotation-config标签
解析context命名空间之component-scan标签
解析aop命名空间之config标签
解析aop命名空间之aspectj-autoproxy标签
拿到BeanDefinition对象和一切准备工作完成后，Spring就开始根据BeanDefinition对象创建第一的bean。那Spring容器是怎么创建bean的呢？这就是这篇文章讨论的内容。
在spring容器的初始化过程中，BeanFactory对象创建完成后，容器就会创建并执行bean工厂后处理器对象，然后在注册Bean后处理器时会创建Bean后处理器对象，初始化消息资源时会创建MessageSource对象，初始化事件传播器时会创建ApplicationEventMulticaster对象。前面所有应用内部级的对象创建完成后，容器才会初始化所有业务级的非延迟加载单例对象。关于spring容器的初始化过程见Spring4.3.x 容器的刷新过程，下面从spring容器创建非延迟加载单例对象来探讨bean的创建过程。
创建bean的过程
Spring容器在刷新过程中以AbstractApplicationContext的finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)方法为初始化容器中所有非延迟加载单例bean的入口，这个方法的源码如下。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化ConversionService
// 在ConfigurableApplicationContext接口中声明：String CONVERSION_SERVICE_BEAN_NAME = "conversionService";
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// 注册一个默认的内部value解析器
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
@Override
public String resolveStringValue(String strVal) {
return getEnvironment().resolvePlaceholders(strVal);
}
});
}
// 初始化LoadTimeWeaverAware对象来支持注册他们的transformers
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时类加载器来做类型匹配
beanFactory.setTempClassLoader(null);
// 允许缓存所有的bean元数据定义，不希望今后再更改工厂的配置
beanFactory.freezeConfiguration();
// 初始化所有非延迟单例bean
beanFactory.preInstantiateSingletons();
}finishBeanFactoryInitialization方法中创建bean的代码是最后一句，调用ConfigurableListableBeanFactory接口的preInstantiateSingletons()方法，这个方法的实现代码在DefaultListableBeanFactory类中，源码如下。
@Override
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// 复制一份Bean名称
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// 触发所有非延迟加载单例bean的初始化
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
// 获取FactoryBean对象
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit; // 标识FactoryBean是否需要马上初始化Bean
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
} else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
// 创建Bean
getBean(beanName);
}
} else {
// 创建Bean
getBean(beanName);
}
}
}
for (String beanName : beanNames) {
// 获取指定的Bean，此步骤会使用BeanFacotry对象获取对应的Bean
Object singletonInstance = getSingleton(beanName);
// 触发所有SmartInitializingSingleton对象的afterSingletonsInstantiated()方法
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
smartSingleton.afterSingletonsInstantiated();
return null;
}
}, getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}preInstantiateSingletons()方法调用BeanFactory接口的getBean(String name)方法来创建Bean，此方法的实现代码在AbstractBeanFacotry中，源码如下。
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}这里简单说一下BeanFactory的5个getBean重载方法的实现最终都是调用AbstractBeanFacotry类的doGetBean方法，它有4个参数，第一个参数为字符串类型的name参数，可以是bean的ID或者别名；第二个参数为Class类型的requiredType参数，指定需要获取的Bean的类型；第三个参数为Object数组的args参数，用于指定构造方法的参数；第四个参数为布尔类型的typeCheckOnly，true表示只做类型检查，false不仅要检查类型，还要把bean标识为已创建。这个方法的源码如下。
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// 首先从singleton缓存中查找手动注册的单例对象
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
} else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 返回sharedInstance自身
// 如果sharedInstance为FactoryBean对象，则返回它所创建的Bean实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
// 检查beanName是否指向的是一个正在创建的prototype对象，是则抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查当前BeanFacotry中是否存在对应的BeanDefintion对象
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 不存在，则从父BeanFactory中获取Bean
String nameToLookup = originalBeanName(name);
if (args != null) {
// 根据指定的构造器参数创建Bean
return (T) parentBeanFactory.getBean(nameToLookup, args);
} else {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
// 把bean标识为已创建
markBeanAsCreated(beanName);
}
try {
// 获取RootBeanDefinition对象
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查BeanDefintion是否合格，如果它代表的是一个抽象类，则抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
// 获取bean所依赖的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
// 初始化所有依赖的Bean
for (String dependsOnBean : dependsOn) {
if (isDependent(beanName, dependsOnBean)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
}
registerDependentBean(dependsOnBean, beanName);
getBean(dependsOnBean);
}
}
// 创建Bean实例
if (mbd.isSingleton()) {
// 创建单例bean
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
// 创建Bean
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
// bean为prototype，创建新的实例
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
// 创建bean
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
// 创建其它作用域的Bean
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, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
// 创建bean
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实例的类型是否与requiredType匹配
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
// 如果不匹配则进行类型转换
return getTypeConverter().convertIfNecessary(bean, requiredType);
} catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type [" +
ClassUtils.getQualifiedName(requiredType) + "]", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}在doGetBean方法中，不管是哪种作用域的Bean，都会调用createBean方法来创建Bean实例，createBean方法在AbstractBeanFactory中被定义为抽象方法，它的实现在AbstractAutowireCapableBeanFactory类中，源码如下。
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 从bean的定义中获取正确的Class对象
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
// 准备方法重写，这个是通过<lookup-method>标签定义的
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 执行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);
}
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}AbstractAutowireCapableBeanFactoryd的createBean会调用resolveBeforeInstantiation方法来执行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法，如果这个方法返回的bean不为null，则bean创建完成。否则将调用看AbstractAutowireCapableBeanFactory类的doCreateBean方法创建bean的，doCreateBean方法的源码如下。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
// 初始化bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建Bean实例，并返回其包装器
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
// 到这一步，Bean已经实例化完成，但还没定制bean的属性
// 此时，执行MergedBeanDefinitionPostProcessor对象的postProcessMergedBeanDefinition方法
// 比如处理@Autowired、@Value等注解
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
// 为了解决bean之间的循环引用，需要提前缓存单例的Bean的引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 为单例bean添加ObjectFactory对象
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
// 此处将执行SmartInstantiationAwareBeanPostProcessor后处理器的getEarlyBeanReference方法
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// 初始化bean的
Object exposedObject = bean;
try {
// 设置bean的属性值
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
// 调用bean后处理器以及InitializingBean的afterPropertiesSet方法
// =>和init-method方法
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) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(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.");
}
}
}
}
try {
// 如果bean需要在工厂关闭前被销毁，则注册bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}doCreateBean方法是实例化和初始化bean的战场，它调用createBeanInstance方法创建bean的实例和BeanWrapper对象；调用populateBean方法设置bean的属性；调用initializeBean方法执行Bean后处理器和InitializingBean对象的afterPropertiesSet方法以及init-method方法；最后调用registerDisposableBeanIfNecessary方法注册bean的销毁方法。
总结
（1）不管是什么作用域的bean，都会通过AbstractAutowireCapableBeanFactory类的doCreateBean方法来创建。doCreateBean方法是创建bean的主要战场。
（2）只要调用BeanFactory对象的任意一个getBean方法都会触发bean的创建，BeanFactory接口提供了5个getBean重载方法。
扫一扫
469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
