异常将上下文初始化事件发送到类的侦听器实例._Spring源码阅读系列之初始化容器整体流程介绍...

上篇文章提到，因为 Spring 源码非常庞大，所以阅读 Spring 源码的最直接有效的办法就是 Debug，后续源码也是基于这种方式去读。接下来看看一个最简单的例子

1. 创建一个UserService接口和其实现类

public interface UserService {
void save();
}

public class UserServiceImpl implements UserService {
@Override
public void save() {
        System.out.println("执行user信息保存操作");
    }
}

---

2. 创建一个applicationContext.xml文件

<?xml version="1.0" encoding="UTF-8"?>
"http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">"userService" class="UserServiceImpl">

---

3. 编写一个 JUnite 测试类

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JuniteTest {
@Test
public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// 1.通过byType的方式获取bean实例
        UserService service = context.getBean(UserService.class);
        service.save();
        System.out.println("-----------");
// 2.通过byName的方式获取bean实例
        UserService service1 = (UserService) context.getBean("userService");
        service1.save();
    }
}

---

4. 从 Junite 测试类 创建Context开始，debug 进去可以看到下面这段代码

public ClassPathXmlApplicationContext(
      String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)throws BeansException {

super(parent);
    setConfigLocations(configLocations);
if (refresh) {
// 这里就是真正初始化Spring容器的地方，也就是我在上一篇文章最后提供的那张图里的流程
// 有同学会问，那Tomcat启动的时候是怎么初始化Spring容器的呢？
// 其实也比较简单，一般在Tomcat里面的web.xml文件配置了一个监听器，大概长这个样子
//
//  org.springframework.web.context.ContextLoaderListener
//
// 该监听器调用contextInitialized()方法，一路点进去可以看到最后也是调用了AbstractApplicationContext.refresh()方法
      refresh();
    }
}

---

5. 找到了 Spring 容器初始化的入口，接下来就来详细看看我们单测里面用到的userService实例是怎么被创建出来的

public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// Step1：其主要作用就是为当前的context上下文初始化一些基础参数
// 比如说：初始化时间，活动状态，日志信息等等，暂时不重要，不需要关注其太多的实现细节
      prepareRefresh();

// Tell the subclass to refresh the internal bean factory.
// Step2: 从注释上看是通知子类去刷新内部bean工厂。解释的好像也特别抽象不知道它到底想干啥
// **重要** 其实在这个方法里面做了几个非常重要的事情，创建bean工厂，并将BeanDefinitions对象(bean实例的定义，这个对象也会贯穿整个Spring源码)存到bean工厂中
// 创建出来的ConfigurableListableBeanFactory，这个bean工厂会贯穿整个Spring源码
// 它功能是存放beanDefinition定义，后续创建出来的bean实例也存放这这个工厂里面
// 暂时先理解到这里就可以了，后续我们会展开其里面的具体实现
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// Prepare the bean factory for use in this context.
// Step3：配置bean工厂的上下文，
// 比如在这个里面配置了ClassLoader，
// 配置了BeanPostProcessor(bean后置处理器，这玩意儿会在bean实例初始化前后做一些增强工作，后面会详细介绍)
// 注册了三个默认bean实例，分别是 “environment”、“systemProperties”、“systemEnvironment” 了解即可
      prepareBeanFactory(beanFactory);

try {
// Allows post-processing of the bean factory in context subclasses.
// Step4：本方法没有具体实现，是一个扩展点，开发人员可以根据自己的情况做具体的实现
        postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.
// Step5：bean工厂后置处理器，主要是对beanFactory对象做一些后置操作
// 和registerBeanPostProcessor名字有点像，只不过后者操作的对象bean实例
// 后续会深入了解其实现原理
        invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
// Step6：注册所有实现了BeanPostProcessor接口的对象，
// 注意：这里只是注册实例，并没有执行其方法，方法具体调用时机是在bean实例初始化前后执行的
        registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.
// Step7：初始化message资源，做一些国际化相关操作，了解即可
        initMessageSource();

// Initialize event multicaster for this context.
// Step8：初始化事件广播器，用于发送相关事件
// 比如注册了一个bean实例的时候就会发送一个事件
        initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
// Step9：在一些特定的context中初始化一些特殊的bean，没有具体实现，留给开发者自定义一些操作
        onRefresh();

// Check for listener beans and register them.
// Step10：注册监听器，了解即可
        registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.
// Step11：初始化所有非懒加载的bean实例，注意是非懒加载的bean
//**非常重要** 我们代码中需要用到的bean实例几乎都是从这里创建出来的，后面会展开其具体实现
        finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.
// Step12：完成上线文刷新，发布上下文初始化完毕的事件
        finishRefresh();
      }

catch (BeansException ex) {
if (logger.isWarnEnabled()) {
          logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
        }

// Destroy already created singletons to avoid dangling resources.
// 当创建bean发生异常时，先销毁已经创建出来的单例bean实例，从而避免资源一直被占用。
// 这样的做法有点像关闭资源链接，比如当程序联系MySQL或Redis的时候，程序发生异常时需要将链接断开一样
        destroyBeans();

// Reset 'active' flag.
// 重置上下文的标识
        cancelRefresh(ex);

// Propagate exception to caller.
throw ex;
      }

finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
// Step13：重置公共的一些缓存数据
        resetCommonCaches();
      }
    }
}

---

总结

Spring 容器初始化，共经历了 13 步；其中尤其需要重点关注的是：

• Step2，初始化 Spring 容器，并构建了BeanDefinition定义
• Step5，BeanFactoryPostProcessor，对BeanFactory做一些后置操作
• Step7，BeanPostProcessor，对 bean 实例在初始化前后做一些增强工作Step11，对剩余所有的非懒加载的BeanDefinition(bean 定义)执行 bean 实例化操作

下一篇文章我们来讲讲 Step2，obtainFreshBeanFactory()实现原理。

---

欢迎关注我，共同学习