ben的笔记
首页 > java > Spring IOC容器的创建过程源码分析

Spring IOC容器的创建过程源码分析

作者：bin
目录
[隐藏]

Spring容器的创建过程、Bean的创建过程，主要在refresh函数中完成，通常我们使用下面的方法去创建、以及初始化容器：

AnnotationConfigApplicationContext annotationConfigApplicationContext =
new AnnotationConfigApplicationContext(Config.class);

annotationConfigApplicationContext.refresh();
//最终调用到AbstractApplicationContext.refresh()

在Spring Boot中，提供了run方法

 SpringApplication.run(SpringBin.class, args);
//最终调用到AbstractApplicationContext.refresh()

AbstractApplicationContext.refresh()代码如下：

public void refresh(){ 
synchronized (this.startupShutdownMonitor) {
// 1.准备初始化beanFactory的准备工作
prepareRefresh();
// 2.告诉子类刷新内部bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3.beanFactory的预准备工作
prepareBeanFactory(beanFactory);
try {
    //4.在beanFactory创建，并预准备完成后，允许子类执行一些postProcess
    postProcessBeanFactory(beanFactory);
    // 5.执行beanFactory的PostProcessor，
    invokeBeanFactoryPostProcessors(beanFactory);
    // 6.注册beanPostProcessor
    registerBeanPostProcessors(beanFactory);
    // 7.做国际化，消息绑定，消息解析
    initMessageSource();
    // 8.初始化事件派发器
    initApplicationEventMulticaster();
    // 9.留给子类，在容器刷新时，可以重写这个方法自定义逻辑
    onRefresh();
    // 10.将时间监听器,添加到事件派发器中,并且将早起事件先派发
    registerListeners();
    // 11.初始化所有剩下的单实例bean
    finishBeanFactoryInitialization(beanFactory);
    // 12.完成容器创建，派发创建事件等
    finishRefresh();
....

然后我们逐个来看每个方法都做了什么

1.prepareRefresh()

prepareRefresh主要完成，初始化beanFactory的准备工作

protected void prepareRefresh() {
...
// 初始化属性配置，主要给继承AbstractApplicationContext的子类实现
initPropertySources();
// 验证属性合法性
getEnvironment().validateRequiredProperties();
//保存早期事件
this.earlyApplicationEvents = new LinkedHashSet<>();

2.obtainFreshBeanFactory()

刷新bean工厂的实例，其中2个都是抽象方法，由子类来做具体实现

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        //调用到GenericApplicationContext.refreshBeanFactory()
	refreshBeanFactory();
        //调用到GenericApplicationContext.refreshBeanFactory()
	return getBeanFactory();
}

GenericApplicationContext类部分内容如下

//默认工厂在类初始化就创建好了
public GenericApplicationContext() {
    this.beanFactory = new DefaultListableBeanFactory();
}
....

//在刷新工厂时，只是设置了一个唯一id
@Override
protected final void refreshBeanFactory() throws IllegalStateException {
    ....
    this.beanFactory.setSerializationId(getId());
}
....

//直接将beanFacotry返回
@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
    return this.beanFactory;
}

3.prepareBeanFactory()

在上一步中，beanFactory只是一个默认的工厂，什么都是空的，在这一步中，对beanFactory进行准备工作，设置一些属性

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    //设置类加载器
    beanFactory.setBeanClassLoader(getClassLoader());
    ....
    
    //添加bean部分BeanPostProcessor 
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    //设置忽略的自动装配的接口，基础类这些接口的，不能自动注入到工厂中
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    ....

    //在bean属性的注入时，如果根据第一个参数指定类型注入，就直接注入第二个参数的对象
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    ....

    //添加bean部分BeanPostProcessor 
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 添加编译时，对aspectJ支持
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      ....
    }

    // 向单例容器中注册一些基础对组件
    // 注册类3个：ENVIRONMENT_BEAN_NAME、SYSTEM_PROPERTIES_BEAN_NAME、SYSTEM_ENVIRONMENT_BEAN_NAME
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }   
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

4.postProcessBeanFactory()

在beanFactory创建，并预准备完成后，允许子类执行一些postProcess

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//do nothing
}

5.invokeBeanFactoryPostProcessors()

在这步之前，beanFactory的创建以及预准备工作已经做完了，接下来按排序执行实现BeanDefinitionRegistryPostProcessor接口的postProcess，再排序执行其他beanFactoryProcessor

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
....

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {
....
//找到实现BeanDefinitionRegistryPostProcessor接口的postProcess，
//并且根据PriorityOrdered.class和Ordered.class排序
String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
//执行这些postProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
....


//同理，并且根据PriorityOrdered.class和Ordered.class排序，执行其他的beanFactoryProcessor
String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

6.registerBeanPostProcessors()

注册beanPostProcessor(bean的后置处理器，拦截bean的创建过程),根据优先级排序，注册beanPostProcessor

public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//获取所有的beanPostPocessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
....

//注册实现PriorityOrdered.class的BeanPostProcessor
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
....

//注册实现Ordered.class的BeanPostProcessor
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
....

//注册没实现排序的BeanPostProcessor
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
....

//最后注册实现MergedBeanDefinitionPostProcessor接口的BeanPostProcessor
//对@Autowired和@Value的支持
registerBeanPostProcessors(beanFactory, internalPostProcessors);
....
}

7.initMessageSource()

做国际化，消息绑定，消息解析

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //如果有messageSource就直接赋值
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        ....
    }
    else {

        // 如果没有，就自己创建一个默认的
        //一般可以用于取出国际化配置文件中的某个值，能按区域取
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
    }
}

8.initApplicationEventMulticaster()

注册时间派发器，如果bean工厂中有就直接使用，如果没有就注册一个默认的

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //如果容器中有，就使用容器中的事件派发器
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    ....
    }
    else {
        //如果没有配置，就使用一个默认的事件派发器
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    ....
    }
}

9.onRefresh()

留给子类，在容器刷新时，可以重写这个方法自定义逻辑

protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
}

10.registerListeners()

注册时间监听器，并且派发早期事件

protected void registerListeners() {
    //bean工厂中获取实现来ApplicationListener.class到监听器
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // 派发早期事件
    Set earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

11.finishBeanFactoryInitialization()

执行到这一步，bean工厂的初始化工作就已经完全结束了，剩下就初始化所有剩下的单实例bean

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    ....
    beanFactory.preInstantiateSingletons();

跳过不重要的信息，直接看preInstantiateSingletons方法，
其中getBean的执行过程，可以参考篇文章：Spring geBean()方法执行过程

@Override
public void preInstantiateSingletons() throws BeansException {
//拿到所有的beanDefinitionNames(bean定义信息)
List beanNames = new ArrayList<>(this.beanDefinitionNames);

//全部bean都尝试加载
for (String beanName : beanNames) {
    RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    //确定是否需要加载
    if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        if (isFactoryBean(beanName)) {
            //工厂bean加载方式
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            ....
        }
        else {
            //普通bean加载方式
            getBean(beanName);
        }
    }
}

// 所有的bean都实例化完成后，
//查看所有的bean是否实现SmartInitializingSingleton接口
//执行afterSingletonsInstantiated()发放
smartSingleton.afterSingletonsInstantiated();
....

12.finishRefresh()

完成容器创建后的派发创建事件等

protected void finishRefresh() {
//清除上下文级别的资源缓存（例如来自扫描的ASM元数据）。
clearResourceCaches();

// 初始化生命周期处理器，可以通过实现LifecycleProcessor.class       
// 接口，来接收容器的刷新、和关闭回调
initLifecycleProcessor();

// 调用生命周期处理器的刷新回调
getLifecycleProcessor().onRefresh();

// 发布容器刷新完成的事件
publishEvent(new ContextRefreshedEvent(this));

// 暴露一些MBean相关的东西(大多数时候这个步骤并不关心)
LiveBeansView.registerApplicationContext(this);
}

您必须 [ 登录 ] 才能发表留言！