本文基于Spring5注解版进行分析
继上一篇文章Spring 底层源码解析（一）扫包注册Bean继续分析Bean的创建过程。
前言：如果您对Spring的底层感兴趣，想知道怎么帮我们创建Bean的，创建Bean经历了说明，那您可以花点时间，认真阅读下本篇文章，相信会给你不少收获的。文章结尾有详细总结
此方法将会创建所有的非懒加载的Bean
先来看一张简单的Bean的生命周期图，
Spring创建Bean看着和后置处理器()息息相关啊
BeanPostProcessor
Spring Bean创建源码流程图
对bean的创建描述得非常清晰，请认真观看，跟着流程图走一遍代码。
走源码
1.0.0：finishBeanFactoryInitialization()
/**
* 抽象的应用上下文
*/
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
/**
* Finish the initialization of this context's bean factory,
* initializing all remaining singleton beans.
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 省略部分代码...
// 注册值解析器
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 尽早初始化LoadTimeWeaverAware beans，以便尽早注册它们的转换器。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时类加载器进行类型匹配。
beanFactory.setTempClassLoader(null);
// 允许缓存所有bean定义元数据，不期望进一步的更改。
beanFactory.freezeConfiguration();
// 实例化所有剩余的(非惰性初始化)Bean。 重点分析
beanFactory.preInstantiateSingletons();
}
}
2.0.0：beanFactory.preInstantiateSingletons();
/**
* IOC 容器之一 存放所有注册的Bean定义信息
*/
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
@Override
public void preInstantiateSingletons() throws BeansException {
// 拿到Bean工厂所有注册的BeanName
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 触发所有非惰性单例beans的初始化...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
// 省略很多代码... 如果是实现了 FactoryBean 的类
getBean(beanName);
}
else {
// 从容器中获取Bean，如果容器没有则创建
// 重点分析
getBean(beanName);
}
}
}
// 为所有适用的beans触发初始化后回调...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
// 省略很多代码... 执行 {@link SmartInitializingSingleton} 的后置处理器
// smartSingleton.afterSingletonsInstantiated();
}
}
}
}
## 3.0.0：getBean(beanName);
/**
* 抽象的Bean工厂
*/
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
@Override
public Object getBean(String name) throws BeansException {
// 核心在这里 doGetBean
return doGetBean(name, null, null, false);
}
}
4.0.0：doGetBean()
获取Bean或创建Bean的核心方法，内部逻辑很多
这里面有创建单实例Bean，创建多实例Bean(原型)，针对Scope作用域创建Bean。
我这里主要分析创建单实例Bean，详情查看4.0.1，4.0.2
/**
* 抽象的Bean工厂
*/
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 拿到Bean name
final String beanName = transformedBeanName(name);
Object bean;
// 4.0.1分析：检查是否在三级缓存中有Bean 为了防止循环依赖问题
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 省略日志输出...
// 获取到Bean的实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// 如果在缓存中没有获取到
else {
// 检查是否有循环依赖
// this.prototypesCurrentlyInCreation 保存当前正常创建的Bean name
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查是否有 父工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
/**
* 省略一大推代码....
* 父工厂同样是调用 getBean() -> doGetBean()
*/
}
// 将指定的bean标记为已经创建(或即将创建)。这允许bean工厂优化其重复缓存
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 拿到Bean的定义信息
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查Bean是否是抽象类
checkMergedBeanDefinition(mbd, beanName, args);
// 优先创建 {@link DependsOn} @DependsOn 注解所依赖的Bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 省略一大推代码...
// 同样是调用 getBean(beanName) 创建Bean
}
}
// 4.0.2：这里是我们重点分析的 创建单实例Bean
// 是否是单实例
if (mbd.isSingleton()) {
// 4.0.2分析： 重点分析
// 获取或创建 Bean单实例，传入一个匿名内部类，供回调使用
sharedInstance = getSingleton(beanName, () -> {
try {
// 5.0.0 重点分析
// 在获取Bean没有的情况下 创建Bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// 创建Bean异常，清除掉对此 beanName 的缓存信息
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 如果Bean是原型 （多实例）
else if (mbd.isPrototype()) {
// 它是一个原型->创建一个新实例。
Object prototypeInstance = null;
try {
// 缓存当前创建原型实例的信息
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 清除当前缓存创建原型实例的信息
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 如果不是单实例，不是原型，则检查 Scope 作用域
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)) {
// 省略大段代码...
}
return (T) bean;
}
}
4.0.1：Object sharedInstance = getSingleton(beanName);
先从容器中查找有没有Bean实例，如果没有从当前正在创建Bean的缓存中查找(二级缓存，三级缓存)，如果查找到，将不会去执行创建Bean过程，
这里处理了循环依赖的问题
/**
* IOC容器之一，存放所有创建的单实例Bean
*/
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
@Override
@Nullable
/**
* 获取单实例Bean
*/
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
/**
* 返回在给定名称下注册的(原始)单例对象。
* 检查已经实例化的单件，并允许早期对当前创建的单例的引用(解析循环引用)
* @param beanName
* @param allowEarlyReference 在没有查询到已经创建的Bean，是否查找正在创建的Bean
* @return
*/
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从容器中获取，已经创建好的单实例Bean this.singletonObjects 可以说就是IOC的容器
Object singletonObject = this.singletonObjects.get(beanName);
/**
* isSingletonCurrentlyInCreation(beanName)
* 此 beanName 是否在当前正在创建的单实例集合中
* 此处 处理循环依赖起到关键作用
*/
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从婴儿对象集合中获取 (二级缓存)
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
// 从三级缓存中获取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
// 如果有
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// 放到婴儿对象集合中 (二级缓存)
this.earlySingletonObjects.put(beanName, singletonObject);
// 从三级缓存移除
this.singletonFactories.remove(beanName);
}
}
}
}
// bean or null
return singletonObject;
}
}
4.0.2：getSingleton(beanName, ObjectFactory)
查看4.0.0代码块标注的 4.0.2。
传入一个匿名内部类，供于回调。回调里面是createBean()创建Bean，及其重要。
sharedInstance = getSingleton(beanName, () -> {
try {
// 5.0.0 重点分析
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
/**
* IOC容器之一，存放所有创建的单实例Bean
*/
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/**
* 从容器中获取单实例Bean，如果没有，则调用ObjectFactory.getObject(){#singletonFactory}创建新的对象
* @param beanName the name of the bean
* @param singletonFactory 对象工厂创建单实例Bean
* with, if necessary
* @return the registered singleton object
*/
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 先从容器中获取 this.singletonObjects 所有单实例的缓存集合
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
// 容器正在销毁 抛出异常 --> 一般创建不会发生这种情况，除非人为
}
/**
* 创建Bean前的准备工作
* this.singletonsCurrentlyInCreation.add(beanName)
* 当前正在创建Bean的集合 添加该 beanName
*/
beforeSingletonCreation(beanName);
// 标记Bean是否创建成功
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
/**
* 回调参数中 {#singletonFactory}的获取对象的方法
*/
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// singleton对象是否同时隐式出现了-->如果是，则继续，因为异常指示该状态。
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
/**
* 创建Bean前的准备工作
* this.singletonsCurrentlyInCreation.remove(beanName)
* 当前正在创建Bean的集合 移除该 beanName
*/
afterSingletonCreation(beanName);
}
/**
* 4.0.3
* 如果创建Bean成功，则往容器里面添加该Bean
*/
if (newSingleton) {
// 4.0.3 重点分析
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
}
4.0.3：addSingleton(beanName, singletonObject);
Bean创建成功，添加到IOC容器中。
/**
* IOC容器之一，存放所有创建的单实例Bean
*/
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/**
* 将给定的单例对象添加到该工厂的单例缓存中。
* <p>必需是单实例
* @param beanName the name of the bean
* @param singletonObject the singleton object
*/
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 创建好的Bean缓存 key -> value
this.singletonObjects.put(beanName, singletonObject);
// 从三级缓存移除
this.singletonFactories.remove(beanName);
// 从二级缓存移除
this.earlySingletonObjects.remove(beanName);
// 创建好的BeanName缓存 array
this.registeredSingletons.add(beanName);
}
}
}
5.0.0：createBean()
4.0.0获取bean的匿名内部类回调。
这里开始创建单实例Bean，也是Bean的生命周期的开始。
重点 重点 重点。其他可以不关注，这里一定要认真，因为将了解到Spring是如何帮我们创建的Bean，创建Bean又经历过什么。
sharedInstance = getSingleton(beanName, () -> {
try {
// 5.0.0 重点分析
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
/**
* 创建Bean工作抽象类
*/
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 这个类的中心方法:创建一个bean实例，
* 填充bean实例，应用后处理器，等等。
* @see #doCreateBean
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
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 {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
/** 5.0.1 重点分析
*
* 给bean后置处理器一个机会返回一个代理，而不是目标bean实例。
* 应用此 InstantiationAwareBeanPostProcessor 后置处理器
* 如果有返回Bean， 直接 return
*/
// 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 {
/**
* 5.0.2 非常重点分析
* Spring 真正的开始创建Bean
*/
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
// 返回创建的 Bean
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
}
5.0.1：resolveBeforeInstantiation(beanName, mbdToUse);
方法名翻译：实例化前解决，
注释翻译：给bean后置处理器一个机会返回一个代理，而不是目标bean实例。
解释：应用InstantiationAwareBeanPostProcessor.后置处理器，如果有返回一个实例对象，则创建Bean过程结束，直接返回此实例对象。
/**
* 创建Bean工作抽象类
*/
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 在实例化前应用后处理器，解决是否存在指定bean的实例化前快捷方式。
* @param beanName
* @param mbd
* @return
*/
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
// 省略了部分代码.... 以下为关键代码
// 拿到要创建Bean的类型
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
/**
* 应用所有的 {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation}
* Bean后置处理器
*/
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
/**
* 如果Bean不等于空
* 应用所有的 {@link BeanPostProcessor#postProcessAfterInitialization}
* Bean后置处理器
*/
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
return bean;
}
}
5.0.1总结：
从以下代码中看出，在Spring给我们自动创建Bean之前，我们可以实现InstantiationAwareBeanPostProcessor接口，手动的去创建Bean，并且创建成功后，还可以再执行BeanPostProcessor的后置处理方法。
5.0.2：doCreateBean(beanName, mbdToUse, args);
/**
* 创建Bean工作抽象类
*/
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 创建Bean
* @param beanName
* @param mbd
* @param args
* @return
* @throws BeanCreationException
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// 实例化bean。.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
/**
* 从未完成创建的单实例Bean的缓存中移除
* 解决循环依赖，防止重复创建Bean
*/
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
/**
* 5.0.3：重点解析
* 利用反射创建 Bean的实例 默认调用无参构造函数
*
* 注意：如果是有参构造函数 会根据类型，从容器中获取Bean实例，
* 如果容器中没有，则调用 createBean() 创建Bean，又会走同样的流程
*
* instanceWrapper 是一个Bean的包装对象
*/
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 拿到Bean的实例
final Object bean = instanceWrapper.getWrappedInstance();
// Bean的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 允许后处理器修改合并的bean定义。
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
/**
* 应用所有的 {@link MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition}
* 后置处理器
*/
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) {
/**
* 5.0.4 重点解析
* 向三级缓存添加当前创建的Bean
*/
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 初始化bean实例。
Object exposedObject = bean;
try {
/**
* 5.0.5：重点解析
*
* 为属性赋值 @Autowired @Value @Resource ... 自动注入之类的注解
*/
populateBean(beanName, mbd, instanceWrapper);
/**
* 5.0.6: 重点解析
*
* 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);
}
}
if (earlySingletonExposure) {
/**
* 省略一大推代码.....
* 移除掉缓存Bean 处理循环依赖
*/
}
// 如果实现了 {@link DisposableBean} (Spring容器关闭回调销毁方法)
// 注册到 this.disposableBeans 集合中
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
}
5.0.3：createBeanInstance(beanName, mbd, args);
创建Bean的实例：
利用反射创建 Bean的实例 默认调用无参构造函数。如果是有参构造函数 会根据类型，从容器中获取Bean实例，如果容器中没有，则调用 createBean() 创建Bean，又会走同样的流程。
5.0.4：addSingletonFactory(beanName, ObjectFactory)
向三级缓存添加当前正在创建的Bean，为了处理循环依赖。
已经创建好的Bean实例缓存中 添加当前创建的Bean
/**
* IOC 容器之一，存放所有的Bean
*/
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/**
* 向三级缓存中添加创建的 Bean
* @param beanName
* @param singletonFactory
*/
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
// 如果不存在 已经创建好的Bean缓存中
// this.singletonObjects 存放所有已经创建好的Bean
if (!this.singletonObjects.containsKey(beanName)) {
// 三级缓存中添加当创建的Bean
this.singletonFactories.put(beanName, singletonFactory);
// 二级缓存中移除当前正在创建的Bean
this.earlySingletonObjects.remove(beanName);
// 已经创建好的Bean实例缓存中 添加当前创建的Bean
this.registeredSingletons.add(beanName);
}
}
}
}
5.0.5：populateBean(beanName, mbd, instanceWrapper);
为当前创建的Bean做属性赋值，例如 @Autowired，@Value，@Resource，@Inject …之类的可以自动注入的注解。处理类：AutowiredAnnotationBeanPostProcessor
5.0.6：initializeBean(beanName, exposedObject, mbd);
开始Bean 的生命周期，执行特定的Aware接口回调，Bean的初始化方法，执行所有的BeanPostProcessor后置处理器。
/**
* 创建Bean工作抽象类
*/
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 初始化给定的bean实例，应用工厂回调 以及init方法和bean后处理器。
*/
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
// 省略部分代码...
else {
/**
* 执行一系列的 Aware接口 BeanNameAware, BeanClassLoaderAware, BeanFactoryAware
*/
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
/**
* 应用所有的 {@link BeanPostProcessor#postProcessBeforeInitialization}
* 初始化方法执行前的 通知方法
*/
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
/**
* 执行初始化方法 例如：
* @Bean(initMethod = "init()")
* 实现接口的{@link InitializingBean#afterPropertiesSet()}
* JSR规范的初始化方法 @PostConstruct
*/
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()) {
/**
* 应用所有的 {@link BeanPostProcessor#postProcessAfterInitialization}
*
* wrappedBean这个Bean会用作 当前创建Bean的存储，所有后置处理器可以修改Bean，或者代理Bean
*/
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
}
1 执行一系列的 Aware接口回调方法 BeanNameAware, BeanClassLoaderAware, BeanFactoryAware
2 执行所有的 BeanPostProcessor.postProcessAfterInitialization()前置通知方法。
3 执行初始化方法 例如：
@Bean(initMethod = “init()”)，
实现接口的{@link InitializingBean#afterPropertiesSet()}
JSR规范的初始化方法 @PostConstruct
4 执行所有的 BeanPostProcessor.postProcessAfterInitialization()置通知方法。
到此Spring创建Bean的流程就结束，接下来总结一下。
- 创建Bean的时候，会先记录当前创建的Bean，实例化Bean后，先在三级缓存中，保存信息，为了解决循环依赖问题。（A依赖B，B依赖A）
- 实例化Bean之前，会先创建有@DependsOn注解的Bean
- 实例化Bean之前，会先执行该InstantiationAwareBeanPostProcessor后置处理器，看看能不能先创建Bean实例，如果可以，则Spring不在创建Bean。
- Spring帮我们实例化Bean的时候，反射去调用构造函数，默认是选择无参构造函数，如果没有无参构造函数，那构造函数的参数会根据类型，去IOC容器中获取，IOC容器没有，Spring会创建该类型的Bean。
- Spring帮我们实例化Bean后，先执行MergedBeanDefinitionPostProcessor后置处理器。
- Spring帮我们实例化Bean后，开始为对象属性赋值，根据类型去IOC容器中获取对象，如果没有则创建。
- 对于依赖关系的类 例如：A 依赖 B，B会先于A实例化并赋值。
- Bean属性赋值完后，先执行BeanNameAware，BeanClassLoaderAware，BeanFactoryAware的回调赋值方法。
- 预先执行BeanPostProcessor.postProcessBeforeInitialization()初始化方法执行前的前置通知。
- 再执行初始化方法 @Bean(initMethod = “init()”) InitializingBean实现接口，JSR规范注解 @PostConstruct。
- 最后执行BeanPostProcessor.postProcessAfterInitialization()初始化方法执行后的后置通知。
- BeanPostProcessor后置处理器的通知方法，可以返回Bean对象，返回的Bean对象用于替换当前创建的Bean实例，可以用它做代理对象。
个人理解：
注解启动Spring容器，扫包是用后置处理器工作的，在创建Bean的过程中，经历过许多后置处理器。然而AOP创建代理对象，也是在后置处理器里工作的。说明后置处理器在Spring源码中起到非常核心的作用。
以后说到Spring的核心的时候，IOC， DI， AOP，还可以在加一个后置处理器BeanFactoryPostProcessor，BeanPostProcessor，
Spring为何要用这么多后置处理器去工作？
就拿一点来说：我们要在Bean实例化完成去创建代理对象，只需要实现一个后置处理器的接口，完全不需要更改任何源码。 用Spring开发，非常易于拓展，非常佩服设计Spring的人。
一定要深入搞懂Spring的后置处理器，这对我们用Spring开发的时候，非常方便。
觉得对您有帮助，就点个赞呗。😀
4448
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
