一、基础概念
IOC，即控制反转。是Spring的一种设计思想。传统程序设计中，我们创建一个对象是通过 new 关键字，是程序主动去创建依赖对象，而在spring中专门有一个容器来创建和管理这些对象，并将对象依赖的其他对象注入到该对象中，这就是我们经常说到的 IOC 容器
所有类的创建、销毁都由spring来控制。对于某一个具体对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫做控制反转
DI，即依赖注入。可以说IOC和DI是同一概念的不同角度描述。
依赖注入是指组件之间的依赖关系由容器在运行期决定，也就是由容器动态将某个依赖关系注入到组件之中。依赖注入的目的不是为了带来更多的功能，而是为了提升组件重用的频率，通过依赖注入机制，我们只需要简单的配置就可以实现
简单来说：就是我们将一个个的bean对象交给IoC去管理，他会帮助我们去创建对象实例、填充属性、初始化、添加监听器等过程。
bean
由spring IOC 容器管理的对象称之为 bean。bean是一个由IOC容器进行实例化、组装和管理的对象。
例如我们经常使用到的 @Service 注解，这个注解就相当于告诉 IOC 容器，这个类需要你帮我创建和管理
BeanDefinition
beanDefinition 就是 bean 的定义信息，用来存储 bean 的所有属性方法定义
BeanFactory 和 ApplicationContext
BeanFactory ：它是一个用于访问 IOC 容器的根接口，提供了完整的 IOC 服务支持
ApplicationContext：BeanFactory 的子接口，在 BeanFactory 的所有功能上，还额外新增了其他高级的特性，比如：事件发布、国际化支持、统一资源加载策略等。正常情况下，我们使用的都是 ApplicationContext。
以电话来举例：我们家里使用的 “座机” 就类似于 BeanFactory，可以进行电话通讯，满足了最基本的需求。
而现在非常普及的智能手机，iPhone、小米等，就类似于 ApplicationContext，除了能进行电话通讯，还有其他很多功能：拍照、地图导航、听歌等。
FactoryBean
一般情况下，我们将 bean 的创建和管理都交给 IOC 容器，spring 会利用反射来实例化bean对象，但是如果我们想自己实现 bean 的创建操作，可以实现吗？肯定可以，FactoryBean就实现了这个需求。
FactoryBean 是一个特殊的 bean ，接口中第一个三个方法 isSingleton()、getObjectType()、getObject() ,它是一个工厂bean，可以自己创建 bena实例，如果一个类实现了 FactoryBean接口，则该类可以自己定义创建实例对象的方法，只需要实现它的 getObject() 方法即可
二、大致过程
三、Spring IOC 的源码解析
Spring IOC的核心方法就在ConfigurableApplicationContext这个类中refresh() 方法，这个方法里面完成了 Spring的初始化、准备bean、实例化bean和扩展功能的实现。
根据注释可以知道，这个方法是用来加载刷新配置，这些配置可能来自java配置、xml文件、properties文件、关系型数据库或者其他格式。
作为一个启动方法，它应当在初始化失败后销毁已经创建的单例，防止占着资源而不使用。也就是说调用这个方法的话，要么所有的单例已经被实例化，要么所有的单例都不存在。
BeansException：bean工厂不能被初始化，抛出BeansException
IllegalStateException：bean工厂已经被初始化了，但是不支持多次刷新，抛IllegalStateException
具体实现
在 AbstractApplicationContext 中进行了实现：
3.1前戏，准备工作----prepareRefresh();
1、设置容器启动时间
2、设置活跃状态为true
3、设置关闭状态为false
4、获取Environment对象，并加载当前系统属性值到Environment对象中
5、准备监听器和事件的集合对象，默认为空集合
3.2创建工厂 obtainFreshBeanFactory（)，也就是IOC容器对象
BeanDefinitionConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
1、创建容器对象:默认是DefaultListableBeanFactory用于存放读取的资源文件
2、使用beanDefinitionReader读取XML文件或者注解等Bean的声明方式
3、解析和加载后生成BeanDefinition，把beanDefinition放入beanDefinitionMap中,最后注册到IOC容器中。
refreshBeanFactory() 刷新bean工厂 当存在beanFactory 销毁 保证只有一个bean工厂
createBeanFactory(),,默认为DefaultListableBeanFactory
loadBeanDefinitions(beanFactory);，这里的beanFactory是对象DefaultListableBeanFactory，这个对象是具体实际干活的类，
这里比较关键的是判断是否是默认的命名空间，如果是默认的命名空间则调用parseDefaultElement方法解析，否则调用parseCustomElement方法解析自定义标签。默认标签有
import，alias，bean，beans
里面的细讲解析这里就不一一列举了，解析完成之后返回对象：AbstractBeanDefinition，最后再包装成包装类BeanDefinitionHolder返回。接下来就是注册beanDefinition了，registerBeanDefinition
3.3prepareBeanFactory(beanFactory)
beanFactory的准备工作，对各种属性进行填充
3.4postProcessBeanFactory(beanFactory) 扩展增强器
覆盖方法做额外的处理，此处我们自己一般不做任何扩展工作，但是可以查看web中的代码，是有具体实现的
3.5invokeBeanFactoryPostProcessors(beanFactory)执行增强器
调用各种beanFactory处理器
3.6 registerBeanPostProcessors（beanFactory) 注册
实例化 注册 beanPostProcessors
3.7initMessageSource() 基本国际化功能 不重要
3.8 initApplicationEventMulticaster() 初始化事件监听器 多播器
3.9 onRefresh() 空的 留给子类来初始化其他的bean
3.10 registerListeners() 注册监听器
3.7~3.10和bean没啥太大影响 主要想完成不同阶段处理不同事情
3.11 finishBeanFactoryInitialization(beanFactory) 完成bean实例化
实例化bean配置文件中配置的单例bean
/**
* 抽象的应用上下文
*/
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();
}
}
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();
}
}
}
}
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);
}
}
doGetBean()
/**
* 抽象的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;
}
}
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;
}
}
getSingleton(beanName, ObjectFactory)
传入一个匿名内部类，供于回调。回调里面是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;
}
}
}
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);
}
}
}
createBean()
获取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);
}
}
}
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;
}
}
总结：
从以下代码中看出，在Spring给我们自动创建Bean之前，我们可以实现InstantiationAwareBeanPostProcessor接口，手动的去创建Bean，并且创建成功后，还可以再执行BeanPostProcessor的后置处理方法。
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;
}
}
createBeanInstance(beanName, mbd, args);
创建Bean的实例：
利用反射创建 Bean的实例 默认调用无参构造函数。如果是有参构造函数 会根据类型，从容器中获取Bean实例，如果容器中没有，则调用 createBean() 创建Bean，又会走同样的流程。
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);
}
}
}
}
populateBean(beanName, mbd, instanceWrapper);
为当前创建的Bean做属性赋值，例如 @Autowired，@Value，@Resource，@Inject …之类的可以自动注入的注解。处理类：AutowiredAnnotationBeanPostProcessor
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实例，可以用它做代理对象。
3.12 finishRefresh();
完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人
439
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
