IOC容器创建Bean对象
简单了解Bean工厂
我们要关注一个接口BeanFactory，它是Spring IOC容器的根接口，也是容器的入口。
类的描述中已经清楚的说明了：
用于访问 Spring bean 容器的根接口。
这是 bean 容器的基本客户端视图；进一步的接口，如ListableBeanFactory和org.springframework.beans.factory.config.ConfigurableBeanFactory可用于特定目的。
我们来看一下这个接口里面的方法。
我们可以看到有各种各样的getBean方法，让我们可以从容器中获取到各种各样的Bean对象。
BeanFactory有一个实现类DefaultListableBeanFactory我们要重点关注下。
这个类的类图如下图所示：
创建Bean对象
有了Bean的定义信息之后，Spring容器就可以开始创建对象了。
Bean对象的创建分为实例化和初始化两个步骤。
在我们日常使用Java创建对象的过程中，可能对这两个步骤没有分得这么清楚。
实例化就是给Bean对象开辟空间进行存储，并给对象里的属性赋初始值的过程。
初始化就是给对象做一些初始化的操作，例如填充属性、执行初始化方法。接下来我们就来聊聊Bean对象的实例化和初始化的过程。
实例化
在之前的介绍中，我们也已经知道了，Spring Bean对象的创建是通过反射的方式实现的。但是口说无凭，我们来看看代码。
@SpringBootApplication
public class SpringCodeStudyApplication {
public static void main(String[] args) {
SpringApplication.run(SpringCodeStudyApplication.class, args);
}
}
我们从Spring boot程序启动的地方开始看起，上面的代码我们一定不陌生，因为这个是每一个Spring Boot程序启动的地方。我们执行这个main方法，即可启动Spring Boot应用程序。
它的底层是怎么做到的呢？
/**
* Static helper that can be used to run a {@link SpringApplication} from the
* specified source using default settings.
* @param primarySource the primary source to load
* @param args the application arguments (usually passed from a Java main method)
* @return the running {@link ApplicationContext}
*/
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
return run(new Class<?>[] { primarySource }, args);
}
/**
* Static helper that can be used to run a {@link SpringApplication} from the
* specified sources using default settings and user supplied arguments.
* @param primarySources the primary sources to load
* @param args the application arguments (usually passed from a Java main method)
* @return the running {@link ApplicationContext}
*/
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
return new SpringApplication(primarySources).run(args);
}
我们进一步点击SpringApplication的run方法，发现run方法又调用了另外一个重载的run方法，最后调用的是SpringApplication这个类中的非静态的run方法。
我们点击进入这个非静态run方法看看。
/**
* Run the Spring application, creating and refreshing a new
* {@link ApplicationContext}.
* @param args the application arguments (usually passed from a Java main method)
* @return a running {@link ApplicationContext}
*/
public ConfigurableApplicationContext run(String... args) {
...
}
这个run方法的注释告诉我们，这个方法运行Spring应用程序，创建并刷新一个新的ApplicationContext。
这个ApplicationContext是什么？
我们去查看类图，发现了它是BeanFactory的子接口，换句话说，它就是Spring容器啊。这意味着在这个方法里将会创建并且准备好我们要使用的IOC容器。
那我们进一步看看这个方法里做了什么？
...
context = createApplicationContext();
...
refreshContext(context);
createApplicationContext方法，从意思上我们也可以理解，这个方法创建了IOC容器。关键是refreshContext方法是做什么用的呢？
我们进一步查看这个方法。
private void refreshContext(ConfigurableApplicationContext context) {
if (this.registerShutdownHook) {
shutdownHook.registerApplicationContext(context);
}
refresh(context);
}
/**
* Refresh the underlying {@link ApplicationContext}.
* @param applicationContext the application context to refresh
*/
protected void refresh(ConfigurableApplicationContext applicationContext) {
applicationContext.refresh();
}
我们发现refreshContext方法最后调用了容器applicationContext的refresh方法。
我们查看这个方法的注释，我们发现了，原来这个方法内部实例化了所有的单例Bean对象。
所以我们得出了结论，refreshContext方法是对容器进行初始化操作的，至少包含了对容器内单例Bean对象的创建。
这不就是我们要找的方法吗？看来我们要找的Bean对象实例化的代码就在这个applicationContext的refresh方法里面。
我们进入refresh方法看看。
我们发现这个方法有三个实现，不过看起来，AbstractApplicationContext这个类比较像是我们要找的目标。
进入到AbstractApplicationContext类的refresh方法，我们发现了这样的代码。
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
注释中表示finishBeanFactoryInitialization方法会实例化单例Bean对象，说明了这个是我们的目标。
我们进入finishBeanFactoryInitialization方法看看，发现了实例化单例对象的其实调用的是Bean工厂beanFactory的preInstantiateSingletons方法。
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
这里的beanFactory其实指的是DefaultListableBeanFactory这个类。
进入到DefaultListableBeanFactory的preInstantiateSingletons方法，我们发现了我们距离Bean对象实例化的代码越来越近了。
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
...
else {
getBean(beanName);
}
}
}
这段代码告诉我们，它将会触发所有单例Bean对象的初始化。它这里做了判断，根据Bean的定义信息，也就是BeanDefinition，这个Bean必须是非抽象的，单例的，且不是懒加载的，才会被创建。
而创建的方法就是调用getBean方法，传入了Bean的名称。
我们进入getBean方法。
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
发现getBean方法调用了doGetBean方法。看到这个以do开头的方法，我们就要注意了，真正关键的代码就快要出现了。
进入doGetBean方法，我们发现了代码。
createBean(beanName, mbd, args);
进一步进入createBean方法，发现它的实现类在AbstractAutowireCapableBeanFactory上，它是AbstractBeanFactory的子类。
在createBean方法中，我们发现了如下代码
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
又是一个do开头的方法，我们知道，我们又得打起精神了，这里就是创建Bean对象的实际操作方法。
进一步进入doCreateBean方法。
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
我们发现了createBeanInstance的方法，心态要崩了呀，Spring的源码怎么嵌套地这么深，要看一个实现咋就这么难。让我们打起精神，胜利就在前方，就快要找到创建Bean对象的方法了。
我们进入createBeanInstance方法，看到了如下代码。
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
这段代码表示使用无参的构造器，我觉得我们就快要找到反射创建Bean对象的代码了。
进入instantiateBean方法，我们看到了代码。
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
我的天啊，胜利的曙光就要来了。这个代码显示获取实例化策略来实例化代码。
我们进入instantiate方法，我们发现进入的类是SimpleInstantiationStrategy。
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
}
else {
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// Must generate CGLIB subclass.
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
在这代码里，我们发现了什么？
Constructor<?>类型，终于出现了反射部分的代码。这个方法先获取到了Bean对象实例化要用到的构造器对象，再调用BeanUtils.instantiateClass方法进行实例化。
我们继续进入BeanUtils.instantiateClass方法。
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
...
return ctor.newInstance(argsWithDefaultValues);
...
}
终于，我们要找到的反射代码终于出现了。文章来源：https://www.toymoban.com/news/detail-452981.html
Spring通过获取到Bean对象的构造器，并调用了newInstance方法实例化了对象。文章来源地址https://www.toymoban.com/news/detail-452981.html
到了这里，关于4.是人就能学会的Spring源码教程-IOC容器创建Bean对象的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
