超详细解析Spring Bean的创建过程
作者:薛伟同学
Spring Bean 的生命周期
BeanFactory 创建对象
在 BeanFactory 接口中定义了获取 Bean 实例的方法 getBean。
@Test public void testDefaultListableBeanFactory() { // 创建工厂 DefaultListableBeanFactory factory = new DefaultListableBeanFactory(); // 创建 XML 阅读器,并指定关联的工厂 XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory); // 开始解析加载 Bean reader.loadBeanDefinitions(new ClassPathResource("applicationContext.xml")); System.out.println(factory.getBean("user")); }
Spring 工厂创建对象的过程其实就是 factory.getBean("user")
对应的实现,这个创建逻辑可以说是 Spring 中最复杂的地方,其中会完整的体现上面生命周期的各个步骤,以及对单例对象、多实例对象的处理,接下来我们将深入源码,解析整个对象的创建过程。
Bean 创建过程
获取 Bean 的方法是 getBean,其来自 DefaultListableBeanFactory 的父类 AbstractAutowireCapableBeanFactory 的父类 AbstractBeanFactory。有点绕,其实就是 DefaultListableBeanFactory 的爷爷…
【重载】getBean
AbstractBeanFactory#getBean
通过名称获取 Bean,这个名称可以是 ID,也可以是别名。
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory { @Override public Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false); } @Override public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException { return doGetBean(name, requiredType, null, false); } @Override public Object getBean(String name, Object... args) throws BeansException { return doGetBean(name, null, args, false); } ... }
getBean 有多个重载方法,可分为通过 Bean 名称或通过 Class 获取 Bean 对象,这些重载方法底层都是调用 doGetBean 方法。
【从缓存拿或者创建】doGetBean
AbstractBeanFactory#doGetBean
// 为了简洁美观,这里将源码中的部分非核心内容进行了删减 protected <T> T doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) { // 转换名称,返回 Bean 的 ID // 如果是 FactoryBean 类型,则参数 name 会以 & 为前缀。此方法会去掉该修饰符,并返回后面的内容 // 如果传入的是 Bean 的别名,则会找到 Bean 的 ID 返回 final String beanName = transformedBeanName(name); Object bean; // 单例 Bean 只会被创建一次,后续再获取 Bean,直接从单例缓存中获取(共有三级缓存) Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { // 如果存在缓存的 Bean // 获取 Bean,正常 Bean 直接返回,如果是 FactoryBean 则返回 FactoryBean.getObject() bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // 检验逻辑 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(...); } // 父子容器的处理 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // 当父容器不为空并且获取的 Bean 不在子容器定义时,从父容器递归获取 String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // 递归到父容器中寻找 return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { // 将 Bean 标记为已经创建(或将要创建),即将 beanName 加入 alreadyCreated 集合 markBeanAsCreated(beanName); } try { // 获取合并后的父子 Bean,对应 <bean id="p" abstract="true"> 和 <bean id="c" parent="p" 的用法 // 将子标签 bean 的各个属性合并到父标签,生成 RootBeanDefinition 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(...); } // 若存在依赖则需要递归实例化依赖的 bean registerDependentBean(dep, beanName); try { getBean(dep); } // catch... } } if (mbd.isSingleton()) { // 创建单例 Bean sharedInstance = getSingleton(beanName, () -> { try { // 创建 Bean 的核心方法 return createBean(beanName, mbd, args); } // catch... }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // 创建原型 Bean Object prototypeInstance = null; try { beforePrototypeCreation(beanName); 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(...); } try { Object scopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } // catch... } } // catch... } // 将 Bean 的类型转换为 getBean 时指定的 requireType 类型 if (requiredType != null && !requiredType.isInstance(bean)) { try { T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(...); } return convertedBean; } // catch... } return (T) bean; }
简单概述一下整个过程:
- 第一步【转换名称】:解析转换传入的获取 Bean 的名字,可以分为三种情况:
- 传入的直接是 ID,则无须转换
- 传入的是 Bean 的别名,转换成 Bean 的 ID 返回
- 传入的是 FactoryBean 的
&
写法,,转换成 Bean 的 ID 返回
- 第二步【从缓存中获取】:单例作用域的 Bean 只会创建一次,之后会存储在 Spring 的缓存中(共计三层)。如果缓存中存在目标 Bean,则获取 Bean,正常 Bean 直接返回,如果是 FactoryBean 则 返回 FactoryBean.getObject()。获取到 Bean 之后跳到第八步【类型转换】。
- 第三步【父子容器的处理】:如果没有从上面的缓存中拿到数据,说明这次要重新创建 Bean。首先进行父子容器的处理,当父容器不为空并且获取的 Bean 不在当前容器定义时,从父容器递归获取。
- 第四步【标记 Bean 为被创建】:将 Bean 标记为已经创建(或将要创建),即将 beanName 加入 alreadyCreated 集合。
- 第五步【合并父子 Bean】:获取合并后的父子 Bean,对应
<bean id="xx" abstract="true">
和<bean id="c" parent="xx"
的用法,这个步骤会将子标签 bean 的各个属性合并到父标签,生成 RootBeanDefinition。 - 第六步【处理依赖 Bean】:获取当前 Bean 是否配置依赖的其他的 Bean 的名称,若存在依赖则需要递归实例化依赖的其他 Bean。这个用法现在已经很少了,大家可以忽略。
- 第七步【根据作用域创建 Bean】:根据作用域可分为三类:单例(singleton)、原型(prototype)和其他,对应的 if 的三个分支,最后都会调用 createBean 创建 Bean。
- 第八步【类型转换】:如果获取 Bean 的时候传入了期望转换的类型 Class,那么这一步就会进行类型转换,之后就将创建的 Bean 返回给调用者了。
以上就是 getBean 方法的大致流程,其中有两个频繁出现且非常重要的方法,一个是处理 FactoryBean 的 getObjectForBeanInstance方法,另一个是创建 Bean 的核心实现 createBean 方法。
当某个 Bean 的实例化过程比较复杂时,可通过实现 FactoryBean 接口,然后在重写的 getObject 方法中定义实例化 Bean 的逻辑,以后获取该 Bean 时,会通过调用 getObject 方法进行返回。值得注意的是 MyBatis 底层就是通过 FactoryBean 来实现。
【BeanFactory处理】getObjectForBeanInstance
AbstractBeanFactory#getObjectForBeanInstance
protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) { // 如果 beanName 以 & 为前缀,但对应的 Bean 不是 FactoryBean 类型,则抛异常 if (BeanFactoryUtils.isFactoryDereference(name)) { if (beanInstance instanceof NullBean) { return beanInstance; } if (!(beanInstance instanceof FactoryBean)) { throw new BeanIsNotAFactoryException(...); } } // 校验已获取的 Bean // 1、如果该 Bean 不是 FactoryBean 类型,直接返回 // 2、如果是 FactoryBean 类型,且 beanName 以 & 为前缀,说明想获取的是 FactoryBean,也是直接返回 if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) { return beanInstance; } // 从缓存中尝试获取 FactoryBean 创建的对象 Object object = null; if (mbd == null) { object = getCachedObjectForFactoryBean(beanName); } if (object == null) { // 到这里已确定 beanInstance 一定是 FactoryBean 类型,所以进行强转 FactoryBean<?> factory = (FactoryBean<?>) beanInstance; // 获取 Bean 对应的 BeanDefinition if (mbd == null && containsBeanDefinition(beanName)) { mbd = getMergedLocalBeanDefinition(beanName); } // 当前 Bean 是否是用户定义的,而不是应用程序自己定义的 boolean synthetic = (mbd != null && mbd.isSynthetic()); // 解析 FactoryBean 的核心方法 object = getObjectFromFactoryBean(factory, beanName, !synthetic); } return object; }
这个方法很简单,大多是些辅助代码以及一些功能性的判断,真正的核心代码在 getObjectFromFactoryBean 方法中。
【BeanFactory处理】getObjectFromFactoryBean
AbstractBeanFactory#getObjectFromFactoryBean
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { // 如果是单例 Bean if (factory.isSingleton() && containsSingleton(beanName)) { synchronized (getSingletonMutex()) { // 尝试从缓存中获取,缓存中存储的是已经通过 FactoryBean 创建的 bean Object object = this.factoryBeanObjectCache.get(beanName); if (object == null) { // 通过 FactoryBean 创建真正的 Bean,其实就是调用了 factory.getObject() 方法 object = doGetObjectFromFactoryBean(factory, beanName); // 这里大概是在执行上一步 doGetObjectFromFactoryBean 方法过程中,该 bean 已被其它线程创建并缓存了起来 Object alreadyThere = this.factoryBeanObjectCache.get(beanName); if (alreadyThere != null) { object = alreadyThere; } else { // 如果没有 if (shouldPostProcess) { // Bean 是否要进行后置处理 ... try { // 执行后置处理器 object = postProcessObjectFromFactoryBean(object, beanName); } // catch ... } ... } } return object; } } else { // 如果不是单例 bean // 通过 FactoryBean 创建真正的 bean Object object = doGetObjectFromFactoryBean(factory, beanName); if (shouldPostProcess) { try { // 执行后置处理器 object = postProcessObjectFromFactoryBean(object, beanName); } // catch ... } return object; } }
【创建Bean的入口】createBean
AbstractAutowireCapableBeanFactory#createBean
接着进入创建 Bean 的下一步 createBean 方法:
这个 createBean 方法是定义在 AbstractBeanFactory 中的抽象方法,最终的实现是交给了 AbstractAutowireCapableBeanFactory 类实现,所以接下来我们看看 AbstractAutowireCapableBeanFactory 这个类。
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) { RootBeanDefinition mbdToUse = mbd; // 根据设置的 class 属性或 className 来解析得到 Class 引用赋值给 RootBeanDefinition if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // 对 override 属性进行标记和验证,本质上是处理 lookup-method 和 replaced-method 标签 try { mbdToUse.prepareMethodOverrides(); } // catch... try { // 执行 BeanPostProcessors 后置处理器,如果有 Bean 返回,则不执行接下来创建 Bean 的操作,直接返回该 Bean // 实际上这里的代码是不走的 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } } // catch... try { // 最后会执行到这里,这是创建 Bean 的核心方法 Object beanInstance = doCreateBean(beanName, mbdToUse, args); return beanInstance; } // catch... }
【创建Bean的主逻辑】doCreateBean
AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) { BeanWrapper instanceWrapper = null; // 如果是单例,尝试获取对应的 BeanWrapper if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { // 这里是一个关键点,使用对应的策略(工厂方法、构造函数)创建 Bean 实例,以及简单初始化 // BeanWrapper 包装了 Bean 对象,并封装类型转换器 instanceWrapper = createBeanInstance(beanName, mbd, args); } // 从 BeanWrapper 中获取包装的 Bean 实例 final Object bean = instanceWrapper.getWrappedInstance(); // 从 BeanWrapper 获取包装 Bean 的 Class 引用 Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // 执行 MergedBeanDefinitionPostProcessor 后置处理器。 synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } // catch... mbd.postProcessed = true; } } // 检查是否需要提前曝光,避免循环依赖(循环依赖问题会在后面详细讨论) boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // 开始初始化 Bean Object exposedObject = bean; try { // 对 Bean 进行填充,将各个属性值注入,如果存在依赖的 Bean 则进行递归初始化 populateBean(beanName, mbd, instanceWrapper); // 执行一系列的初始化方法 exposedObject = initializeBean(beanName, exposedObject, mbd); } // catch... // 再次检查是否循环依赖 if (earlySingletonExposure) { 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<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { // throw } } } } // 注册 DisposableBean try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } // catch... return exposedObject; }
该方法整体流程如下:
- 如果是单例,尝试从缓存中获取 Bean 的包装器 BeanWrapper,并清除缓存
- 如果不存在对应的 Wrapper,则说明 Bean 未被实例化,创建 Bean 实例
- 执行 MergedBeanDefinitionPostProcessor 后置处理器
- 检查是否需要提前曝光,避免循环依赖
- 属性填充,将所有属性填充至 Bean 的实例中
- 执行一系列的初始化方法(回调钩子接口)
- 再次检查是否存在循环依赖
- 注册 DisposableBean
该过程中有几个需要重点介绍的方法,分别是创建 Bean 实例的 createBeaninstance 方法、注入 Bean 属性的 populateBean 方法以及执行 Bean 初始化方法的 initializeBean 方法。
【创建Bean的核心逻辑】createBeaninstance
AbstractAutowireCapableBeanFactory#createBeaninstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) { Class<?> beanClass = resolveBeanClass(mbd, beanName); if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { throw new BeanCreationException(...); } // 如果有用于创建 Bean 实例的回调方法 Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName); } // 如果工厂方法不为空,则使用工厂方法进行实例化 if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); } // 利用构造函数进行实例化,解析并确定目标构造函数 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); } } // 根据参数确定构造函数 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { return autowireConstructor(beanName, mbd, ctors, args); } // 使用默认的构造函数 return instantiateBean(beanName, mbd); }
以上主要分为:
- 使用工厂方法进行实例化
- 通过构造函数实例化
不管是通过工厂方法还是构造方法来实例化对象,到这里得到的也仅仅是一个 Bean 的最初实例,还不是我们最终期望的 Bean,因为后面还需要对 Bean 实例进行初始化处理,注入相应的属性值等。
【属性填充】populateBean
AbstractAutowireCapableBeanFactory#populateBean
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { // 判断实例化的 Bean 是否为空 if (bw == null) { // 返回是否有为此 Bean 定义的属性值,如果有,则抛异常,提示 “无法将属性值应用于空实例” if (mbd.hasPropertyValues()) { throw new BeanCreationException(...); } // 没有,则跳过属性填充阶段以获取空实例 else { return; } } // 在设置属性之前,先执行 InstantiationAwareBeanPostProcessors 后置处理器,这些后置处理器可以用其它方式注入属性,如字段注入。 boolean continueWithPropertyPopulation = true; 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; } } } } // 当使用了 InstantiationAwareBeanPostProcessors 后置处理器注入属性,则结束属性注入流程,直接返回 if (!continueWithPropertyPopulation) { return; } // 获取 Bean 实例的属性值集合 PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs); // 根据名称自动注入 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } // 根据类型自动注入 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } // 返回此工厂是否拥有 InstantiationAwareBeanPostProcessor boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); // 是否进行依赖检查 boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE); if (hasInstAwareBpps || needsDepCheck) { if (pvs == null) { pvs = mbd.getPropertyValues(); } PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); // 在属性注入前执行 InstantiationAwareBeanPostProcessor 后置处理器 // @Autoware 的实现原理 // 这里涉及一个极其重要的后置处理器实现 AutowiredAnnotationBeanPostProcessor,其主要用来处理 @Autowired 注解,这部分会在后面详细讨论 if (hasInstAwareBpps) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvs == null) { return; } } } } // 进行依赖检查 if (needsDepCheck) { checkDependencies(beanName, mbd, filteredPds, pvs); } } if (pvs != null) { // 这里进行属性的类型转换,例如将字符串的 id 转为数字的 id // 执行属性注入,这里才真正的将属性进行填充,将解析和类型转换好的属性列表(pvs)赋值到包装对象(bw)上 applyPropertyValues(beanName, mbd, bw, pvs); } }
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { // ... // Create a deep copy, resolving any references for values. List<PropertyValue> deepCopy = new ArrayList<>(original.size()); boolean resolveNecessary = false; for (PropertyValue pv : original) { // 遍历解析到的每个属性 if (pv.isConverted()) { deepCopy.add(pv); } else { String propertyName = pv.getName(); // 如果是 JDK 类型,返回的是 TypeStringValue // 如果是要注入其他的 Bean,则是 RuntimeBeanReference 类型 Object originalValue = pv.getValue(); // 这里是个重点,进行属性的解析,如果是 JDK 类型则返回的对应 JDK 的类型 // 如果是 RuntimeBeanReference,则会递归调用工厂的 getBean 获取到要注入的对象 Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); Object convertedValue = resolvedValue; boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName); if (convertible) { // 进行类型准换 convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter); } if (resolvedValue == originalValue) { if (convertible) { // 将类型转换好的数据赋值给 PropertyValue pv.setConvertedValue(convertedValue); } deepCopy.add(pv); } else if (convertible && originalValue instanceof TypedStringValue && !((TypedStringValue) originalValue).isDynamic() && !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) { pv.setConvertedValue(convertedValue); deepCopy.add(pv); } else { resolveNecessary = true; deepCopy.add(new PropertyValue(pv, convertedValue)); } } } if (mpvs != null && !resolveNecessary) { mpvs.setConverted(); } try { // 这里才真正的对创建的包装对象进行了属性的赋值,底层肯定是用到了反射了 bw.setPropertyValues(new MutablePropertyValues(deepCopy)); } catch (BeansException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Error setting property values", ex); } }
【初始化】initializeBean
AbstractAutowireCapableBeanFactory#initializeBean
接着进入 initializeBean 方法,在该方法中会回调许多在 Bean 初始化阶段执行的方法。
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) { // 回调 Aware 系列接口 if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, getAccessControlContext()); } else { invokeAwareMethods(beanName, bean); } // 回调 BeanPostProcessor 后置处理器的 postProcessBeforeInitialization 方法 Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { // 回调 InitializingBean 的 afterPropertiesSet 方法 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { // 回调 BeanPostProcessor 后置处理器的 postProcessAfterInitialization 方法 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }
可以看到,在 Bean 的初始化阶段,分别回调了 Aware 系列接口、BeanPostProcessor 后置处理器、InitializingBean。这三个接口都属于 Spring 的钩子接口,是 Spring 开放出来的扩展接口,可以影响 Bean 的生命周期。
回调 Aware 系列接口
private void invokeAwareMethods(final String beanName, final Object bean) { if (bean instanceof Aware) { // 如果当前 Bean 继承了 BeanNameAware 接口,则回调接口中的 setBeanName 方法,并传递 beanName 参数 if (bean instanceof BeanNameAware) { ((BeanNameAware) bean).setBeanName(beanName); } // 这个 BeanClassLoaderAware 接口传递的是 ClassLoader if (bean instanceof BeanClassLoaderAware) { ClassLoader bcl = getBeanClassLoader(); if (bcl != null) { ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl); } } // 这个 BeanFactoryAware 接口传递的是 AbstractAutowireCapableBeanFactory if (bean instanceof BeanFactoryAware) { ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); } } }
这里被回调的 Aware 接口有三个,分别是 BeanNameAware 、BeanClassLoaderAware、BeanFactoryAware。
回调 BeanPostProcessor 后置处理器的 postProcessBeforeInitialization 方法
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) { Object result = existingBean; // getBeanPostProcessors 方法获取所有的 BeanPostProcessor 后置处理器的实现 // 并循环执行 postProcessBeforeInitialization 方法,参数是当前 Bean 以及 beanName for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { Object current = beanProcessor.postProcessBeforeInitialization(result, beanName); if (current == null) { return result; } result = current; } return result; }
其中有一个后置处理器的实现 ApplicationContextAwareProcessor ,其用来对剩余的 Aware 接口进行回调:
@Override public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException { AccessControlContext acc = null; //... invokeAwareInterfaces(bean); //... return bean; } private void invokeAwareInterfaces(Object bean) { if (bean instanceof Aware) { if (bean instanceof EnvironmentAware) { ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment()); } if (bean instanceof EmbeddedValueResolverAware) { ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver); } if (bean instanceof ResourceLoaderAware) { ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext); } if (bean instanceof ApplicationEventPublisherAware) { ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext); } if (bean instanceof MessageSourceAware) { ((MessageSourceAware) bean).setMessageSource(this.applicationContext); } if (bean instanceof ApplicationContextAware) { ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext); } } }
回调 InitializingBean 的 afterPropertiesSet 方法
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) { //.. ((InitializingBean) bean).afterPropertiesSet(); //.. }
回调 BeanPostProcessor 后置处理器的 postProcessAfterInitialization 方法
@Override public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) { Object result = existingBean; // getBeanPostProcessors 方法获取所有的 BeanPostProcessor 后置处理器的实现 // 并循环执行 postProcessAfterInitialization 方法,参数是当前 Bean 以及 beanName for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { Object current = beanProcessor.postProcessAfterInitialization(result, beanName); if (current == null) { return result; } result = current; } return result; }
注意 Spring AOP 就是通过 BeanPostProcessor 来实现的,创建代理对象就是在初始化阶段执行 postProcessAfterInitialization 中完成的,有一个 AspectJAwareAdvisorAutoProxyCreator 这个类。
到这里,创建 Bean 的核心流程就讨论结束,我这里做一个完整的归纳:
- 调用者通过 getBean 方法调用工厂获取一个 Bean,传入的 name 可以是 Bean 的 id;也可以是别名;也可以是 &name,表示获取原始的 FactoryBean 对象。
- 通过一系列的方法重载,最后会到达 AbstractBeanFactory#doGetBean 方法处理,先要对传入的 name 进行解析,解析出 id。
- 接下来会尝试从单例缓存池中获取已创建好的对象,Spring 底层提供了三级缓存(三个Map)体系来解决循环依赖的问题:singletonObjects、earlySingletonObjects、singletonFactories。
- 如果拿到了缓存数据:对 FactoryBean 类型进行判定,决定是否直接返回缓存对象还是返回 FactoryBean.getObject()。
- 如果没有拿到缓存数据,说明要新建一个 Bean。
- 首先进行父子容器的处理,当父容器不为空并且获取的 Bean 不在子容器定义时,从父容器递归获取。
- 将 Bean 标记为已经创建(或将要创建),即将 beanName 加入 alreadyCreated 集合。
- 父子 Bean 的处理,将子标签 bean 的各个属性合并到父标签,生成 RootBeanDefinition。
- 处理 depends-on,若存在依赖则需要递归实例化依赖的 bean。
- 根据不同的作用域创建 Bean 实例,分为单例、原型和其他,这三种创建的时候都会调用 createBean 方法,这个方法由 AbstractAutowireCapableBeanFactory 提供。
- 首先需要处理 lookup-method 和 replaced-method。
- 然后要将创建实例的职责交给 doCreateBean,这个方法大概有三个重要的步骤:
- 创建实例 createBeaninstance:使用工厂方法实例化还是使用构造函数,默认是无参构造。这里返回的是包装对象,里面还封装了类型转换器的信息。
- 属性填充 populateBean:填充的时候设计到类型转换,底层再通过反射对创建的包装对象进行属性赋值。
- 初始化 initializeBean:在这个步骤,分别回调了 Aware 系列接口、BeanPostProcessor 后置处理器、InitializingBean。
- 如果 getBean 的时候传入了类型(
getBean("user", User.clsss)
),则需要进行类型转换后返回。
以上就是超详细解析Spring Bean的创建过程的详细内容,更多关于Spring Bean创建过程的资料请关注脚本之家其它相关文章!