【Spring源码】IOC实现-bean加载

1、转换对应 beanName

为什么需要将传入的参数 name 转换成对应的 beanName？
　　传入的参数 name 就是 beanName，可能是别名，可能是FactoryBean

怎么转换？

1. 去除 FactoryBean的修饰符，比如 name="&aa"–> name=“aa”
2. 取出指定 alias 所表示的最终 beanName，例如 A 的别名指向 B，B 指向 C，则返回 C

2、缓存中获取单例 bean

这是什么意思？
　　单例在spring的同一个容器内只会被创建一次，后续再获取bean，就直接从单例缓存中获取。 这里是尝试加载，首先尝试从缓存中加载，如果加载不成功则再次尝试从singletonFactories中加载。

为什么要这么做？
　　在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，在spring中创建bean的原则是不等bean创建完成 就会将创建bean的ObjectFactory提早加入到缓存中，一旦下一个bean创建需要依赖上一个bean则直接使用ObjectFactory

源码实现

过程总结

1. 尝试从singletonObjects里获取实例
2. 如果获取不到再从earlySingleton-Objects里面获取
3. 如果还获取不到，再尝试从singletonFactories里面获取beanName对应的ObjectFactory
4. 调用这个ObjectFactory的getObject来创建bean
5. 放到earlySingleton-Objects里
6. 从singletonFacotories里面remove掉这个ObjectFactory

@Override
@Nullable
public Object getSingleton(String beanName) {
    //参数true是允许早期依赖
    return getSingleton(beanName, true);
}
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //检查缓存中是否存在实例
    Object singletonObject = this.singletonObjects.get(beanName);
    //如果缓存为空，且单例bean正在创建中，则锁定全局变量
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            //如果此bean正在加载，则不处理
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                //当某些方法需要提前初始化的时候会直接调用addSingletonFactory把对应的ObjectFactory初始化策略存储在singletonFactory中
                ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    //调用预先设定的getObject方法
                    singletonObject = singletonFactory.getObject();
                    //记录在缓存中，注意earlySingletonObjects和singletonFactories是互斥的
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

3、从 bean 的实例中获取对象

得到 bean 的实例后，我们需要调用 getObjectForBeanInstance 方法来检测正确性（检测当前 bean 是否是 FactoryBean 类型的 bean ），如果是，调用该bean对应的FactoryBean实例中的getObject()作为返回值。
　　getObjectForBeanInstance 方法的过程总结：

1. 对 FactoryBean 正确性的验证
2. 对非 FactoryBean 不做任何处理
3. 对 bean 进行转换（将存储 XML 配置文件的 GernericBeanDefinition 转换为 RootBeanDefinition）
4. 将从 Factory 中解析 bean 的工作委托给 getObjectFromFactoryBean

代码

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

	// 如果指定的 name 是工厂相关（以&为前缀），且 beanInstance 不是 FactoryBean 类型则验证不通过
	if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
		throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
	}

	// 现在我们有个 bean 的实例，这个实例可能会是正常的 bean 或者是 FactoryBean
	// 如果是 FactoryBean 我们使用它创建实例，但如果用户想直接获取工厂实例而不是工厂的 getObject 对应的实例
	// 那么传入的 name应该加入前缀 &
	if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
		return beanInstance;
	}

	// 加载 FactoryBean
	Object object = null;
	if (mbd == null) {
		//从缓存中加载 Bean
		object = getCachedObjectForFactoryBean(beanName);
	}
	//让Bean工厂生产给定名称的Bean对象实例
	if (object == null) {
		// 到这里已经明确知道 beanInstance 一定是 FactoryBean 类型
		FactoryBean factory = (FactoryBean) beanInstance;
		//在所有已经加载的类中检测是否定义 beanName
		if (mbd == null && containsBeanDefinition(beanName)) {
			//将存储 XML 配置文件的 GenericBeanDefinition 转换为 RootBeanDefinition
			//从容器中获取指定名称的Bean定义，如果继承基类，则合并基类相关属性
			mbd = getMergedLocalBeanDefinition(beanName);
		}
		//是否是用户定义而不是应用程序本身定义的
		boolean synthetic = (mbd != null && mbd.isSynthetic());
		object = getObjectFromFactoryBean(factory, beanName, !synthetic);
	}
	return object;
}

4、获取单例

过程

（1）检查缓存是否已经加载过
（2）如果没有加载，则记录beanName的正在加载状态
（3）加载单例前记录加载状态。

可能你会觉得beforeSingletonCreation方法是个空实现，里面没有任何逻辑，但其实这个函数中做了一个很重要的操作：记录加载状态，也就是通过this.singletonsCurrentlyInCreation.add(beanName)将当前正要创建的bean记录在缓存中，这样便可以对循环依赖进行检测。

（4）通过调用参数传入的ObjectFactory的个体Object方法实例化bean
（5）加载单例后的处理方法调用

同步骤3的记录加载状态相似，当bean加载结束后需要移除缓存中对该bean的正在加载状态的记录。

（6）将结果记录至缓存并删除加载bean过程中所记录的各种辅助状态
（7）返回处理结果

源码

public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    // 全局变量需要同步
    synchronized (this.singletonObjects) {
        // 首先检查对应的bean是否已经加载过，因为singleton模式其实就是复用已创建的bean
        Object singletonObject = this.singletonObjects.get(beanName);
        // 如果为空，才可以进行singleton的bean的初始化
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                        "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                        "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
                // 初始化bean
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                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;
                }
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                // 加入缓存
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

5、准备创建 bean

过程
（1）设置class属性或者根据className来解析class
（2）验证MethodOverride属性进行验证及标记

在上述代码中有一个方法：mbd.prepareMethodOverrides();
其实在Spring中确实没有override-method这样的配置，但是我们前面说过，在Spring配置中是存在lookup-method和replace-method的，而这个两个配置的加载其实就是将配置统一存放在BeanDefinition中的methodOverrides属性里，而这个函数的操作也就是针对于这两个配置的。

（3）应用初始化前的后处理器，解析指定bean是否存在应用初始化前的短路操作
（4）创建bean

代码

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;
    
    // 锁定class，根据设置的class属性或者根据className来解析class
    Class resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    // 验证及准备覆盖的方法
    try {
        // 处理override属性
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),beanName, "Validation of method overrides failed", ex);}
    try {
        // 给 BeanPostProcessors 一个机会来返回代理来替代真正的实例（实例化的前置处理）
        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 {
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isDebugEnabled()) {
            logger.debug("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { throw ex; }
    catch (Throwable ex) {throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);}
}

6、循环依赖

循环依赖 vs 循环调用

循环依赖：A 引用 B，B 引用 C，C 引用 A（循环引用）
循环调用：方法间的环调用，无法解决，除非有终结条件，否则就是死循环，最终导致内存溢出。

Spring 如何解决循环依赖

1、构造器

无法解决，只能抛异常（BeanCurrentlyInCreationException）

如在创建TestA类时，构造器需要TestB类，那将去创建TestB，在创建TestB类时又发现
需要TestC类，则又去创建TestC，最终在创建TestC时发现又需要TestA，从而形成一个环，
没办法创建。
　　spring容器将每一个正在创建的bean标识符放在一个“当前创建bean池"中，bean标识
符在创建过程中将一直保持在这个池中，因此如果在创建bean过程中发现自己已经在“当前
创建bean池”里时，将抛出BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的bean将从“当前创建bean池”中清除掉。

测试

＜bean id="testA" class="com.bean.TestA"＞
	 

＜bean id="testB" class="com.bean.TestB"＞
	 

＜bean id="testC" class="com.bean.TestC"＞
	 

过程
1、Spring容器创建"testA”bean，首先去“当前创建bean池”查找是否当前bean正在创建，如果没发现，则继续准备其需要的构造器参数"testB”，并将"testA”标识符放到“当前创建bean池”。
2、Spring容器创建"testB”bean，首先去“当前创建bean池"查找是否当前bean正在创建，如果没发现，则继续准备其需要的构造器参数"testc”，并将"testB”标识符放到“当前创建bean池”。
3、Spring容器创建"testc”bean，首先去“当前创建bean池”查找是否当前bean正在创建，如果没发现，则继续准备其需要的构造器参数"testA”，并将"testC”标识符放到“当前创建bean池”。
4、到此为止Spring容器要去创建"testA”bean，发现该bean标识符在“当前创建bean
池”中，因为表示循环依赖，抛出BeanCurrentlyInCreationException。

2、setter

what：通过Spring容器提前暴露刚完成构造器注入但未完成其他步骤（如setter注入）的bean来完成的

how：解决单例作用域的bean循环依赖。通过提前暴露一个单例工厂方法，从而使其他bean能引用到该bean。

具体步骤：
1、Spring容器创建单例"testA”bean，首先根据无参构造器创建bean，并暴露一个"ObjectFactory”用于返回一个提前暴露一个创建中的bean，并将"testA”标识符放到“当前创建bean池”，然后进行setter注入"testB”
2、Spring容器创建单例"testB”bean，首先根据无参构造器创建bean，并暴露一个"ObjectFactory”用于返回一个提前暴露一个创建中的bean，并将"testB”标识符放到“当前创建bean池”，然后进行setter注入"circle”
3、Spring容器创建单例"testC”bean，首先根据无参构造器创建bean，并暴露一个"ObjectFactory”用于返回一个提前暴露一个创建中的bean，并将"testc”标识符放到“当前创建bean池"，然后进行setter注入“testA”。进行注入"testA”时由于提前暴露了"ObjectFactory"工厂，从而使用它返回提前暴露一个创建中的bean。
4、最后在依赖注入"testB”和"testA”，完成setter注入。

3、prototype范围的依赖处理

对于 “prototype” 作用域 bean，Spring 容器无法完成依赖注入，因为Spring容器不进行缓存 “prototype” 作用域的 bean，因此无法提前暴露一个创建中的 bean 。
对于 “singleton” 作用域 bean，可以通过 "setAIIowCircuIarReferences（false）;” 来禁用循环引用。

7、创建 bean

7.1 创建 bean 的实例（实例化）

实例化逻辑

1. 根据 RootBeanDefinition 中的配置生成 bean 的实例
2. 解析构造函数
3. 进行构造函数的实例化

Spring 在根据参数和类型去判断最终会使用哪个构造函数进行实例化，但判断过程比较耗性能，因此采用缓存机制

实例化的两种情况：
1.通用的实例化（instantiateBean）
　　直接调用实例化策略
2.带有参数的实例化（autowireConstructor）
　　2.1 构造函数参数的确定
　　　　2.1.1 根据参数 explicitArgs 判断（不为空，即为构造函数的参数）
　　　　2.1.2 缓存中获取（缓存中的参数可能是初始类型，也可能是最终类型，因此要经过类型转换器的过滤）
　　　　2.1.3 配置文件获取（信息保存在 BeanDefinition）
　　2.2 构造函数的确定（构造函数、参数名称、参数类型、参数值）
（匹配对应构造函数的方法：参数个数）
　　　　2.2.1 按照 public 、非 public 构造函数的参数数量排序
　　　　2.2.2 获取参数名称：注解、工具类 ParameterNameDiscoverer
　　2.3 根据确定的构造函数转换对应的参数类型（类型转换器：Spring 提供、用户自定义）
　　2.4 构造函数不确定性的验证（父子关系情况）
　　2.5 根据 实例化策略 + 得到的构造函数 + 构造函数参数 --> 实例化 Bean

2.1、2.2 是 基础条件，2.5是组合

实例化策略：
1-用户没有使用需要动态改变的方法（replace、lookup），则使用反射的方式
2-否则，使用动态代理方式，将包含两个特性所对应的逻辑的拦截增强器社设置进去

7.2 记录创建 bean 的 ObjectFactory（处理循环依赖）

处理循环依赖的解决办法：
　　在 B 中创建依赖 A 时，通过 ObjectFactory 提供的实例化方法来中断 A 中的属性填充，使 B 中持有的 A 仅仅是刚刚初始化并没有填充任何属性的 A，这初始化 A 的步骤是在最开始创建 A 的时候进行的，由于 A 与 B 中的 A 所表示的属性地址是一样的，所以在 A 中创建好的属性填充自然可以通过 B 中的 A 获得。

7.3 属性注入（填充）

处理流程

1. postProcessAfterInstantiation 控制程序是否继续进行填充
2. 根据注入类型（byName、byType）提取依赖的 bean，统一存入 PropertyValues中
3. 在属性获取完毕填充前，对属性再次处理（eg：对属性的验证）
4. 将所有 PropertyValues 中的属性填充至 BeanWrapper

获取注入属性：

（1）autowireByName
　　在传入的参数 MutablePropertyValues 中找出已经加载的 bean，并递归实例化，进而加入到 MutablePropertyValues

（2）autowireByType

1. 尝试使用解析器进行解析
2. 对于集合类型，不在解析范围，需要再次对不同集合类型进行不同情况的处理

应用到已经实例化的 bean：

applyPropertyValues

1. 获取所有属性
2. 获取对应的解析器
3. 遍历属性，将属性转换为对应类的对应属性的类型

7.4 初始化 bean（进行用户设定的初始化方法的调用）

1. 激活 Aware 方法（实现 Aware 接口的 bean 在被初始化之后，可以取得相对应的资源）
2. 处理器的应用（BeanPostProcessor，给用户充足的权限更改 / 扩展Spring）
3. 激活自定义的 init 方法

7.5 注册 DisposableBean（销毁方法）

销毁方法的扩展入口
销毁方法还可以通过：配置属性 destroy-method 方法