当调用 BeanFactory.getBean 方法获取 Bean 时,如果 Bean 还未创建,则会触发 Bean 的创建,本文主要关注 Bean 的创建过程。
何时创建
在 Spring Bean 的获取过程 有提到 Singleton、Prototype 和 其他 Scope 类型的 Bean 创建,当获取不到所需的 Bean 实例时会触发创建 Bean,而这个创建 Bean 的操作是通过一个 createBean(beanName, mbd, args)
方法实现的。createBean(beanName, mbd, args)
是定义在 AbstractBeanFactory 中的一个方法,并且是在 AbstractAutowireCapableBeanFactory 中实现的,它的方法签名如下:
1 | Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) |
AbstractAutowireCapableBeanFactory 是 AbstractBeanFactory 的子类,具有了 getBean 的能力。另外它还实现了 AutowireCapableBeanFactory 接口,需要提供 Autowire 的能力。

AbstractBeanFactory 定义了 getBean 的流程,而把创建 Bean 的工作交给了子类去实现,AbstractAutowireCapableBeanFactory 是其子类,定义了 createBean 的流程。
当遇到以下几种情况时,都会触发 Bean 的创建
- 若 Bean 定义为 Singleton,并且从 DefaultSingletonBeanRegistry 的缓存中未获取到 Bean
- 若 Bean 定义为 Prototype,每一次获取 Bean 时
- 若 Bean 定义为其他 Scope,从 Scope 上下文中未获取到 Bean
createBean
这是 AbstractAutowireCapableBeanFactory 最核心的一个方法,它的功能包括:创建 bean 实例、填充 bean 的属性、调用 postProcessor 等
解析 Bean Class
这里是为了确保 Bean Class 一定是解析过的
1 | // 解析 Bean Class |
具体的实现如下:
1 | protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch) |
通常 BeanDefinition 中有设置 Class,上一步会直接返回。若未设置,则会调用 doResolveBeanClass 方法解析 Bean Class
1 | private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch) |
准备方法 Overrides
1 | mbdToUse.prepareMethodOverrides() |
具体操作是交给了 AbstractBeanDefinition 的 prepareMethodOverrides 方法
1 | public void prepareMethodOverrides() throws BeanDefinitionValidationException { |
resolveBeforeInstantiation
给 BeanPostProcessors 一个机会,可以创建 bean 的代理出来,这样就不走后面的创建 bean 逻辑
1 | Object bean = resolveBeforeInstantiation(beanName, mbdToUse); |
当符合一定条件时:
- 通过 InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法创建 Bean 实例
- 若上一步创建的实例不为空,则通过 BeanPostProcessor 的 postProcessAfterInitialization 方法对实例进行处理
整体的流程控制代码如下:
1 | protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { |
InstantiationAwareBeanPostProcessor 创建实例的代码:
1 | protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) { |
创建好实例之后,BeanPostProcessor 的回调
1 | public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) |
doCreateBean
若上一步未创建 Bean,则执行下面的 doCreateBean 创建 Bean 流程
1 | Object beanInstance = doCreateBean(beanName, mbdToUse, args) |
createBeanInstance
创建 java bean 并封装到 beanWrapper 中,执行完 beanWrapper 的初始化。
- 解析 Bean Class
- 判断 Bean Class 是否允许访问(public)
- 若设置了 instanceSupplier,则通过它创建 Bean 实例
- 若设置了 factoryMethodName,则通过工厂方法创建
- 若已经解析过构造函数,再次创建相同的 bean,则进行短路处理
- 通过 SmartInstantiationAwareBeanPostProcessor 获取到构造函数,然后创建 Bean(区分有无参数)
- 使用默认的无参构造函数创建 Bean
1 | protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { |
applyMergedBeanDefinitionPostProcessors
调用 MergedBeanDefinitionPostProcessor 处理 beanDefinition。
1 | protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) { |
这里可以对合并后的 BeanDefinition 进行处理,添加所需的东西,比如解析 Autowire 注解等
addSingletonFactory
如果是 Singleton bean,并且允许循环引用,并且当前 bean 正在创建中,则通过添加 SingletonFactory 的方式提前将 bean 暴露出去
1 | boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && |
暴露出去的 bean 还可以通过 SmartInstantiationAwareBeanPostProcessor 的 getEarlyBeanReference 方法进一步处理
1 | protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { |
populateBean
下面就可以填充 bean 的属性,各种 autowire 都是在这里处理的
postProcessAfterInstantiation
这是在 properties 设置之前的操作,可以对 bean 的状态进行修改。若返回 false 则表示不需要后续的属性填充,直接返回
1 | boolean continueWithPropertyPopulation = true; |
其中 postProcessAfterInstantiation 的方法签名如下:
1 | boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException |
autowire byName 和 byType
对应 xml 中配置的 autowire="byType"
和 autowire="byName"
1 | if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) { |
postProcessProperties
如果存在 InstantiationAwareBeanPostProcessors,则回调 postProcessProperties 方法,Autowire 注解的依赖注入也是在这里处理的
1 | for (BeanPostProcessor bp : getBeanPostProcessors()) { |
postProcessProperties 方法的签名如下:
1 | PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException |
postProcessPropertyValues 方法的签名如下:
1 | PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException |
applyPropertyValues
应用给定的 property values,解析指向其他 bean 的引用。必须使用深拷贝,这样才不会永久修改引用的属性值。
1 | if (pvs != null) { |
它的核心代码是:
1 | protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { |
initializeBean
初始化 bean,包括 aware、postProcessBeforeInitialization、InitializingBean 的 afterPropertiesSet、bean自定义的 init 方法、postProcessAfterInitialization 等
invokeAwareMethods
调用 aware 方法,包括 BeanNameAware、BeanClassLoaderAware 和 BeanFactoryAware 对应的方法
1 | private void invokeAwareMethods(final String beanName, final Object bean) { |
postProcessBeforeInitialization
调用 postProcessBeforeInitialization 方法
1 | if (mbd == null || !mbd.isSynthetic()) { |
它会遍历调用所有的 BeanPostProcessor 的 postProcessBeforeInitialization 方法,如果有一个返回 null,则忽略后续的 BeanPostProcessor。
1 | public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException { |
这是 bean 初始化之前的扩展点,可以对 bean 的初始化做一些准备工作,比如调用一些其他的 Aware 接口的 set 方法。例如 ApplicationContextAwareProcessor 的 postProcessBeforeInitialization 方法实现如下:
1 | public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException { |
invokeInitMethods
调用初始化方法,包括 InitializingBean 的 afterPropertiesSet 方法,以及 bean 自定义的 init 方法
1 | protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) |
postProcessAfterInitialization
调用 postProcessAfterInitialization 方法
1 | if (mbd == null || !mbd.isSynthetic()) { |
这里的控制逻辑与 postProcessBeforeInitialization 类似
1 | public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException { |
这是 bean 初始化之后的扩展点,通常 postProcessAfterInitialization 方法不需要对 bean 做任何操作,直接原样返回
检查是否有冲突
1 | if (earlySingletonExposure) { |
registerDisposableBeanIfNecessary
如果当前 bean 需要 destroy,则将其注册到 disposableBeans 中
Singleton 类型的 bean
1 | if (mbd.isSingleton()) { |
它实际上是调用了 DefaultSingletonBeanRegistry 的 registerDisposableBean 方法,将自己注册到了 disposableBeans 中
1 | public void registerDisposableBean(String beanName, DisposableBean bean) { |
其他类型的 bean
1 | Scope scope = this.scopes.get(mbd.getScope()); |
它是向 Scope 中注册了一个 DisposableBeanAdapter 类型的回调。DisposableBeanAdapter 封装了要 destroy 的 bean,在其 destroy 方法中进行相关操作
1 | public void destroy() { |
流程图
Spring Bean 创建的主要流程如下: