【Spring源码】Bean对象的创建和从容器中获取对象的过程

文章目录

一、前期准备
- 1.1 环境依赖
- 1.2 实体类
- 1.3 applicationContext.xml
- 1.4 测试代码
二、探究过程
- 2.1 目标
- 2.2 方法
- 2.3 探究创建Bean对象过程
- - 2.3.1 SpringDemo测试类
  - 2.3.2 ClassPathXmlApplicationContext
  - 2.3.3 AbstractApplicationContext
  - 2.3.4 DefaultListableBeanFactory
  - 2.3.5 AbstractBeanFactory
  - 3.3.6 DefaultSingletonBeanRegistry
  - 3.3.7 AbstractAutowireCapableBeanFactory
  - 3.3.8 SimpleInstantiationStrategy
  - 3.3.9 BeanUtils
- 2.4 探究Bean对象加入容器过程
- 2.5 从容器中获取Bean对象的过程
- 2.6 总结
- 2.7 新的疑问

参考视频：https://www.bilibili.com/video/BV1Bq4y1Q7GZ?p=2
通过视频的学习和自身的理解整理出的笔记。

一、前期准备 1.1 环境依赖


    
        org.springframework
        spring-context
        5.1.7.RELEASE
    

    
        org.springframework
        spring-webmvc
        5.1.7.RELEASE

1.2 实体类

简单的User类，在测试过程中创建这个User类的对象。

public class User {
    private Integer id;
    private String name;

    public User() {
        System.out.println("创建了");
    }
}

1.3 applicationContext.xml

在applicationContext.xml配置bean对象。

1.4 测试代码

通过applicationContext.xml配置应用程序的上下文，在容器中创建User对象。

public class SpringDemo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User) context.getBean("user");
    }
}

二、探究过程 2.1 目标

目标：Spring容器中的Bean是何时创建的？为什么我们能从容器中获取到？

我们要带着上面的目标去读源码，只看跟我们目标相关的代码（Bean是何时创建的），不要在读源码的过程中迷失自我，始终要记得我们究竟要探究什么问题。遇到好奇或不懂的地方可以先记录下来，以后再去探究。

2.2 方法

如果调用User的无参构造器创建了User对象，那么控制台将打印【创建了】。

public class User {
    private Integer id;
    private String name;

    public User() {
        System.out.println("创建了");
    }
}

我们通过打断点Debug的方式，时刻观察控制台的输出分析是哪段代码执行结束后创建了User对象。

可以通过【Ctrl + 鼠标左键】查看某个方法的具体实现；如果通过【Ctrl + 鼠标左键】跳转到了接口的抽象方法上，此时，我们需要通过【Ctrl + Alt + 鼠标左键】跳转到具体的实现方法上。

一个接口可以有很多的实现类，但是在Debug的过程中我们无需担心不知道选择哪个实现类，因为程序已经运行了，实现类已经唯一确认，我们通过【Ctrl + Alt + 鼠标左键】就可以跳转到正确的实现类的方法上。

2.3 探究创建Bean对象过程 2.3.1 SpringDemo测试类

在执行完ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");这一行代码后，对象就已经创建好了。那么就说明在创建ClassPathXmlApplicationContext这个对象的过程中创建了Bean对象。

2.3.2 ClassPathXmlApplicationContext

在ClassPathXmlApplicationContext中重载了很多构造器，我们只看程序调用到的构造器。

this(new String[] {configLocation}, true, null);调用了另一个构造器

从xml文件中读取配置，通过parent（不用管它是什么）创建ClassPathXmlApplicationContext对象。

在Debug过程中，发现在执行完refresh()方法后就完成了bean对象的创建。暂时不需要理解这个构造器中其他方法的作用。

2.3.3 AbstractApplicationContext

 refresh()方法

跳转到了AbstractApplicationContext类中的refresh()方法。

在Debug过程中，发现在执行完下面这行代码后创建了bean对象。

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

从名字和注解上我们可以看出来，这个方法可以实例化所有非懒加载的单例对象。

 finishBeanFactoryInitialization()方法

跳转到了AbstractApplicationContext类中的finishBeanFactoryInitialization()方法。

在Debug过程中，发现在执行完下面这行代码后创建了bean对象。

// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();

从名字和注解上我们可以看出来，这个方法是通过bean工厂实例化所有非懒加载的单例对象。

通过【Ctrl + Alt + 左键】跳转。

2.3.4 DefaultListableBeanFactory

preInstantiateSingletons()是ConfigurableListableBeanFactory接口中的方法，DefaultListableBeanFactory是ConfigurableListableBeanFactory接口实现类。

我们只需要看DefaultListableBeanFactory实现类中的preInstantiateSingletons方法即可。

通过for循环实例化所有非懒加载对象，不过这里只包含一个User对象。

上面的代码中，我们可以先了解一下BeanDefinition，他就是描述类详细信息的对象，其中包括我们了解的scope=”singleton”表示单例，lazyInit=false表示非懒加载。

① 通过if语句判断这个对象不是抽象类、是单例、非懒加载。（成立）

if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

② 通过if判断这个对象是不是FactoryBean。（不成立）

if (isFactoryBean(beanName))

所以最后来到了getBean(beanName)方法。

2.3.5 AbstractBeanFactory

 getBean()方法

跳转到AbstractBeanFactory抽象类的getBean方法。

@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

这个方法由调用了doGetBean(name, null, null, false)。

 doGetBean()方法

在这里创建bean对象，通过lambda表达式和匿名内部类来实现的。

最终创建bean对象的代码为createBean(beanName, mbd, args)，调用这个createBean()方法的函数其实在getSingleton()当中。因为这里通过lambda表达式和匿名内部类的方式创建了对象传入了getSingleton()方法中。

虽然createBean(beanName, mbd, args)创建了bean对象，但是我们还是先去看看getSingleton()。

3.3.6 DefaultSingletonBeanRegistry

下面来看看getSingleton()方法，注意他传入了singletonFactory对象

创建bean对象的方法为singletonFactory.getObject()，而这个singletonFactory是传入的参数，也就是上面提到的lambda表示和匿名内部类创建的对象。这个对象里面就包含了getObject方法。

不太懂的朋友可以看看lambda表示和函数式接口。
这个ObjectFactory就是函数式接口，里面包含了getObject方法。

所以这段代码就是实现了3.3.5节中的：

3.3.7 AbstractAutowireCapableBeanFactory

 createBean()方法

下面跳转到createBean()方法中：

beanName：类的名称
mbd：类的定义信息

通过调用doCreateBean(beanName, mbdToUse, args)创建bean对象。

 doCreateBean()方法

通过调用createBeanInstance(beanName, mbd, args)创建bean对象。

 createBeanInstance()方法

在这个方法中经过一系列的分析，使用无参构造器创建对象。

 instantiateBean()方法

通过调用getInstantiationStrategy().instantiate(mbd, beanName, parent)创建bean对象。

3.3.8 SimpleInstantiationStrategy

获取空参构造器，通过Bean工具实例化类对象。

3.3.9 BeanUtils

BeanUtils：JavaBeans的静态方法，用于初始化bean、检查bean的属性类型、复制bean属性等。

通过传入构造器ctor和所需的参数args创建bean对象。最终通过ctor.newInstance(args)创建了对象并返回。

2.4 探究Bean对象加入容器过程

 getSingleton()方法

我们回到【3.3.6节】的DefaultSingletonBeanRegistry的getSingleton()方法中：

我们知道了singletonObject = singletonFactory.getObject()创建了bean对象。

此时对象就是singletonObject，同时令newSingleton = true，再往下看：

if (newSingleton)成立，将执行addSingleton(beanName, singletonObject)。

 addSingleton()方法

将单例对象加入到工厂的单例缓存singletonObjects中

原来这里面已经包含了五个对象：

这段代码运行结束后，新增一个user对象：

2.5 从容器中获取Bean对象的过程

从刚刚创建的容器中获取user对象。

 AbstractApplicaitonContext的getBean()方法

 AbstractBeanFactory的getBean()方法

又回到了doGetBean方法，在创建bean对象的过程中也用到了doGetBean方法。

 AbstractBeanFactory的doGetBean()方法

这时候我们就可以通过方法getSingleton(beanName);获取bean对象，最后返回这个bean对象。

 DefaultSingletonBeanRegistry的getSingleton()方法

下面来看看getSingleton()方法：

2.6 总结

非懒加载的单实例bean会在容器创建的时候创建。容器内部会创建一个beanFactory，使用beanFactory的doGetBean方法来进行创建，并且在创建后会把bean放入一个单例bean的map集合（singletonObjects）中存储。key就是我们配置的bean的名称。

我们调用容器getBean()方法来获取对象的时候，其实也是调用了doGetBean方法。就会从对应的集合中获取到之前创建的对象。

2.7 新的疑问

RootBeanDefination是什么？如何通过bean名获取对应的RootBeanDefinition对象的？

如果是FactoryBean是怎么创建的？

【Spring源码】Bean对象的创建和从容器中获取对象的过程

Java相关栏目本月热门文章