《系列二》-- 1、BeanFactory.getBean 总览

目录

• 一句话概括
• 1 书接上回
• 2 揭开 doGetBean() 的神秘面纱, 重要操作一览
• 3 必要的课外知识
  • 3.1 bean 的作用域 Scope 有哪些
  • 3.2 FactoryBean 是什么
  • 3.3 什么是循环依赖
• 4 深入了解 doGetBean
  • 1) 深入了解 doGetBean() 之 尝试从缓存 [单例] 读取bean
  • 2) bean 与 FactoryBean
  • 3) 深入了解 doGetBean() 之 ParentBeanFactory
  • 4) 深入了解 doGetBean() 之 BeanDefinition 对象的处理
  • 5) 不同作用域(Scope) bean 的加载动作
  • 6) 深入了解 doGetBean() 之 《如何从零开始创建bean》
  • 7) 深入了解 doGetBean() 之: 从零开始的单例bean创建
  • 8) 深入了解 doGetBean() 之 原型(多例) bean 的加载
  • 9) 深入了解 doGetBean() 之: 其它作用域的bean创建
  • 10) 深入了解 doGetBean() 之 生成的 bean类型检查
• 5 系列二 getBean() 总结
• 6 后续展望

阅读之前要注意的东西：本文就是主打流水账式的源码阅读，主导的是一个参考，主要内容需要看官自己去源码中验证。全系列文章基于 spring 源码 5.x 版本。

写在开始前的话：

阅读spring 源码实在是一件庞大的工作，不说全部内容，单就最基本核心部分包含的东西就需要很长时间去消化了：

• beans
• core
• context

实际上我在博客里贴出来的还只是一部分内容，更多的内容，我放在了个人，fork自 spring 官方源码仓了； 而且对源码的学习，必须是要跟着实际代码层层递进的，不然只是干巴巴的文字味同嚼蜡。

https://gitee.com/bokerr/spring-framework-5.0.x-study

这个仓设置的公共仓，可以直接拉取。

Spring源码阅读系列--全局目录.md

一句话概括

本文以走马观花的姿态，简单分析了一波 spring 容器创建bean的大致环节，后续将通过单独的文章进行细讲其中的没个环节。

本文将包含后文的链接，根据感兴趣的内容自取即可。

1 书接上回

我们已经知道了spring 是怎么解析标签的。

现在我们解析完标签并注册到 BeanFactoryRegistry 接口进行管理了，接下来我们要用解析的结果创建bean了

记得开篇说的那两行代码么：

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class XmlBeanFactoryTest {
	BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("bean.xml"));
	Object object = beanFactory.getBean("action");
}

现在正式进入第二行代码的流程：

Object object = beanFactory.getBean("action");

同理 【Shift + Ctrl + 鼠标左键】 尝试找到 getBean 的实现类，这里发现有多个符合条件的实现类；

再解析 XmlBeanFactory 的类图，那么显而易见，我们应该看 AbstractBeanFactory 类的 getBean() 方法

然后再层层递进，我们来到了 AbstractBeanFactory.doGetBean() 方法，这个方法的方法体非常长，如果不考虑其中细节，我们只需要讲解这一个方法大致就可以知道 BeanFactory.getBean() 最基本的实现，及其重要环节。

2 揭开 doGetBean() 的神秘面纱, 重要操作一览

实际上在spring 的5.x版本中， doGetBean()方法体非常的长, 应该在 150 行左右了，或许屏幕前的你会嗤之以鼻，就这？

如果平时有严格讲究clean code 规范，那么 超过 50 行的方法都是不合理的。(刚毕业时在某家公司见过 2700 多行的方法，虽然离职许久了，但是我敢肯定时至今日，那些代码必定还在"成长"。)

下边我会贴一串处理后的伪代码，主要用来展示 doGetGean() 方法的骨架：

protected  T doGetBean(
    String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    // 1. 转换/提取beanName  name 可能为：FactoryBean 、 别名alias 等
    
    String beanName = transformedBeanName(name);
    Object bean;
    
    // 2. 尝试直接从缓存中获取，或者从 singletonFactories 中的 ObjectFactory 获取
    
    //  - 检查缓存中或者实例工厂中是否有对应实例
    Object sharedInstance = getSingleton(beanName);  // 第一次尝试从单例bean池中获取缓存的 bean 实例
    if (sharedInstance != null && args == null) {
        // && 2.1 如果 bean 原型是FactoryBean 类型，则通过其 getObject() 方法生成真正的 bean 
        //    && 2.2 否则直接返回 sharedInstance 本身作为: 待获取的bean
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {

        // 3. 缓存中不存在，那么就要从头再来了， 从前文 xml 标签解析到的 BeanDefinition 开始，逐步生成真正的 bean 对象    
        // 3.1 存在无法消解的循环引用
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    
        // 3.2 parentBeanFactory 检查 
        // parentBeanFactory 不为空  && 当前加载的XML中不包含 beanName 映射的类时，会尝试从 parentBeanFactory 获取
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 3.2.1 当前工厂没能获取到相关 bean 向 parentBeanFactory 询问
            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 {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
        
        // 4. 暂停一下, 能走到这一步说明：
        // 4.1 第一,从缓存取不到，那么是第一次加载当前bean; 
        // 4.2 第二，没有进入上述的 parentBeanFactory 的流程里，说明 当前 的BeanFactory 里有带获取bean 的定义。
    
        // 5 类比 * 提前暴露，如果该配置生效，通过检查则，视为该 bean 已经创建
        if (!typeCheckOnly) {
            // 标记该 bean 已经被创建过
            markBeanAsCreated(beanName);
        }
    
        // 6. 正式进入，从零开始创建一个 bean 的过程
        try {
            // 6.1 对 bean 的后续处理都是针对 RootBeanDefinition 进行的，所以需要：
            // 将存储的 XML 配置文件的 GenericBeanDefinition 转化为 RootBeanDefinition  -->  ChildBeanDefinition
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);  // 老熟人了，第一个系列的文章讲的就是怎么得到她
            
            // 6.2 校验  mbd 对应的类是否为抽象类，[ 当前代码版本: spring 5.1 ]
            checkMergedBeanDefinition(mbd, beanName, args);
    
            // Guarantee initialization of beans that the current bean depends on.
            // 6.3 获取引用关系, 实例化依赖的 bean [需要spring容器注入的依赖]
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) { //  无法处理的， 循环依赖抛异常 TODO
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    registerDependentBean(dep, beanName);  //  记录bean的name 记录他们之间的引用关系，被销毁时根据关系去销毁
                    try {
                        getBean(dep);  // 递归创建当前bean，依赖的其它 bean
                    } catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }
    
            // 7. 创建bean自身
            // 它依赖的 bean [ 加载/创建 ] 完毕， 最终到了加载其本身的时刻 (根据它的 beanDefinition 创建真正的 bean 实例)
            if (mbd.isSingleton()) {  
                // 7.1 单例模式
                // 第二次尝试从单例bean缓存池中获取该bean实例；若无法从缓存中获取（未被加载），从头开始加载该 bean 的实例
                // 具体加载行为由 createBean()方法负责
                // 回调 getObject().createBean()前: 实例化前的准备工作 -- before[PostProcessor(后置处理器)]
                // 回调 getObject().createBean()后: 实例化完后的补充工作 -- after[PostProcessor(后置处理器)]
                sharedInstance = getSingleton(beanName, new ObjectFactory