Spring容器初始化核心流程源码分析

发表于 更新于 分类于

Spring容器初始化核心流程

原代码如下(AbstractApplicationContext.refresh)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 准备刷新容器
        prepareRefresh();
        // 告诉子容器刷新容器
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        // 准本beanFactory
        prepareBeanFactory(beanFactory);
        try {
            // 对beanFactory做一定的处理（接口，由子类去实现）
            postProcessBeanFactory(beanFactory);
            // 初始化并回调已经注册的BeanFactoryPostProcessor beans
            invokeBeanFactoryPostProcessors(beanFactory);
            // 注册BeanPostProcessors
            registerBeanPostProcessors(beanFactory);
            // 初始化 messageSource
            initMessageSource();
            // 初始化广播事件
            initApplicationEventMulticaster();
            //初始化其他特殊的bean（接口，由子类去实现）
            onRefresh();
            // Check for listener beans and register them.
            registerListeners();
            //初始化单列的bean
            finishBeanFactoryInitialization(beanFactory);
            // 完成初始化
            finishRefresh();
        }
    }
}

Spring容器BeanFactoryPostProcessor实现源码分析

方法实现AbstractApplicationContext.invokeBeanFactoryPostProcessors()

1
2
3
4
5
6
7
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

可以看出其核心代码封装在 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(),接下来看看该方法源码，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, 
List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    //存放已经初始的bean的名称，避免重复初始化，初始化是调用beanFactory.getBean()进行初始化
    Set<String> processedBeans = new HashSet<>();
    //判断是否支持 BeanDefinitionRegistryPostProcessor，如果支持，则处理实例化并调用 BeanDefinitionRegistryPostProcessor
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        //存放普通的 BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        //BeanDefinitionRegistryPostProcessor，其主要作用是允许添加Bean的定义
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
        //将所有的beanFactoryPostProcessors分成BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor两部分
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =(BeanDefinitionRegistryPostProcessor) postProcessor;
                //回调 BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry方法
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }else {
                regularPostProcessors.add(postProcessor);
            }
        }
        
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
        // 第一次 在容器中查找所有实现了BeanDefinitionRegistryPostProcessor接口的bean名称
        String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            //筛选出实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的bean，并且对bean进行实例化
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                //添加到processedBeans中，避免重复初始化
                processedBeans.add(ppName);
            }
        }
        // 对所有的实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor进行排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        //回调 BeanDefinitionRegistryPostProcessor的 postProcessBeanDefinitionRegistry方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        //注意，这个地方将currentRegistryProcessors清空了，后面还会使用这个list
        currentRegistryProcessors.clear();


        // 第二次 在容器中查找所有实现了BeanDefinitionRegistryPostProcessor接口的bean名称
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                 //筛选出实现了Ordered接口的BeanDefinitionRegistryPostProcessor的bean，并且对bean进行实例化
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                //添加到processedBeans中，避免重复初始化
                processedBeans.add(ppName);
            }
        }
        // 对所有的实现了Ordered接口的BeanDefinitionRegistryPostProcessor进行排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        //回调 BeanDefinitionRegistryPostProcessor的 postProcessBeanDefinitionRegistry方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        //注意，这个地方将currentRegistryProcessors清空了，后面还会使用这个list
        currentRegistryProcessors.clear();
         
        boolean reiterate = true;
        // 这里为什么要用循环？因为在调用invokeBeanDefinitionRegistryPostProcessors时可能添加新的
        // BeanDefinitionRegistryPostProcessor bean定义，
        // 所以需要循环查找，直到实例化所有的BeanDefinitionRegistryPostProcessor bean
        while (reiterate) {
            reiterate = false;
            //第二次 在容器中查找所有实现了BeanDefinitionRegistryPostProcessor接口的bean名称,
            // 这次主要是处理普通的BeanDefinitionRegistryPostProcesso（未实现Order和PriorityOrdered接口）
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            //回调 BeanDefinitionRegistryPostProcessor的 postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();
        }

        //回调 BeanFactoryPostProcessor的 postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }else {
        //回调 BeanFactoryPostProcessor的 postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }
    
    
    // ============================================= 小小的分隔一下 ===========================================
          
    // 第一次 在容器中查找所有实现了BeanFactoryPostProcessor接口的bean名称
    String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            //如果已经初始化了，则啥也不干
        }else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    //排序
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    //回调 BeanFactoryPostProcessor的 postProcessBeanFactory方法
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 实例化并调用Ordered接口的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    //实例化并调用未排序的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // 清理数据
    beanFactory.clearMetadataCache();
}

BeanFactoryPostProcessor 的实现代码不难，只要耐者性子阅读，不难读懂其代码，执行流程整理如下:

  • 判断容器是否支持BeanDefinitionRegistry，如果支持，则实例化并调用BeanDefinitionRegistry.registerBeanDefinition方法，如果不支持 则调用已经实例化 BeanFactoryPostProcessor的postProcessBeanFactory方法
    • 处理BeanDefinitionRegistry步骤一：调用已经实例化BeanDefinitionRegistryPostProcessor的BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry方法
    • 处理BeanDefinitionRegistry步骤二：在容器中查找实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor并进行实例化和回调
    • 处理BeanDefinitionRegistry步骤三：在容器中查找实现Ordered接口的BeanDefinitionRegistryPostProcessor并进行实例化和回调
    • 处理BeanDefinitionRegistry步骤四：在容器中查找其他BeanDefinitionRegistryPostProcessor并进行实例化和回调
  • 在容器中查找实现PriorityOrdered接口的BeanFactoryPostProcessor并进行实例化和回调
  • 在容器中查找实现Ordered接口的BeanFactoryPostProcessor并进行实例化和回调
  • 在容器中查找实现其他BeanFactoryPostProcessor并进行实例化和回调

可以看出容器在处理BeanDefinitionRegistry和BeanFactoryPostProcessor的流程基本一致 回调优先级顺序：PriorityOrdered > Ordered > 其他

BeanFactoryPostProcessor 存在的意义

  • BeanFactoryPostProcessor 扩展主要是允许用户更改bean的定义，生命周期、属性等等
  • Spring容器会确保在创建普通Bean之前创建所有的BeanFactoryPostProcessor Bean
  • 自定义BeanFactoryPostProcessor bean不应该与普通bean进行交互或者依赖，这样做可能会导致对象提前实例化，违反容器原则，造成意外的副作用，如果需要bean实例交互，则考虑实现BeanPostProcessor

BeanDefinitionRegistryPostProcessor　存在的意义

BeanDefinitionRegistryPostProcessor继承BeanFactoryPostProcessor，允许向容器中注册新的bean定义，Spring 扫描XMl及注解的实现都是基于该扩展

Spring 注册BeanPostProcessor源码分析

实现方法：PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this),源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    //获取当前已经定义的 BeanPostProcessor bean
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // 注册 BeanPostProcessorChecker 后置处理器，用于检查在注册BeanPostProcessor期间有无普通bean初始化，如果有初始化，则会打印警告日志
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    
    // 第一步：将BeanPostProcessor 根据priorityOrdered，Ordered，普通进行分类,并初始化注册 priorityOrdered BeanPostProcessor
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    // 存放实现 MergedBeanDefinitionPostProcessor 接口的BeanPostProcessor bean
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            //实例化 priorityOrdered BeanPostProcessor
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    //排序 priorityOrdered BeanPostProcessor
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    //注册 priorityOrdered BeanPostProcessor
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    //初始化并注册 Ordered BeanPostProcessor
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    //排序
    sortPostProcessors(orderedPostProcessors, beanFactory);
    //注册
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    //初始化并注册 普通 BeanPostProcessor
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    //注册，注意这里并没有进行排序
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // 重新注册 内部内部PostProcessor (MergedBeanDefinitionPostProcessor)，仔细阅读的读者可能发现，在前面已经注册了，
    //这里为什么还要重新注册呢？请看后面继续分析！
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    //重新注册 ApplicationListenerDetector 
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

我们先来看看核心注册方法registerBeanPostProcessors()的实现，源码如下：

1
2
3
4
5
private static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
    for (BeanPostProcessor postProcessor : postProcessors) {
        beanFactory.addBeanPostProcessor(postProcessor);
    }
}

源码仅仅是做了循环处理，addBeanPostProcessor是BeanFactory的一个接口，在 AbstractApplicationContext.addBeanPostProcessor()实现，其源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    // 尝试移除原来的 beanPostProcessor
    this.beanPostProcessors.remove(beanPostProcessor);
    // 标记 InstantiationAwareBeanPostProcessor 已经注册，@PostConstruct注解在该后置处理器实现
    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
        this.hasInstantiationAwareBeanPostProcessors = true;
    }
    //标记 DestructionAwareBeanPostProcessor 已经注册 @destory注解在该后置处理器实现
    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
        this.hasDestructionAwareBeanPostProcessors = true;
    }
    // 注册 beanPostProcessor
    this.beanPostProcessors.add(beanPostProcessor);
}

在这里可以初步看出为什么需要重复注册的端倪，实际上是为了将BeanPostProcessor 放到list的后面，在进行 BeanPostProcessor回调的时候，在后面调用

initMessageSource

始化MessageSource组件，负责国际化处理，在处理都语言时非常有用，实现多语言，可参考：https://www.jianshu.com/p/4fdf3b505444

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //判断beanFactory中是否有名字为messageSource的bean，MESSAGE_SOURCE_BEAN_NAME = "messageSource";
    //如果没有，新建DelegatingMessageSource类作为messageSource的Bean
     (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
    }else {
        // 创建一个空的messageSource 
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    }
}

initApplicationEventMulticaster

初始化时间广播组件，用于容器时间传播

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
	 * Initialize the ApplicationEventMulticaster.
	 * Uses SimpleApplicationEventMulticaster if none defined in the context.
	 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
	 */
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //判断容器中是否有名字为applicationEventMulticaster的bean，APPLICATION_EVENT_MULTICASTER_BEAN_NAME=applicationEventMulticaster
    //如果没有，则创建一个 SimpleApplicationEventMulticaster 对象，并注册为bean
    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);
    }
}

onRefresh

空方法，为子类提供扩展接口

registerListeners

注册事件监听

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
protected void registerListeners() {
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

finishBeanFactoryInitialization

初始化非单例的bean

finishRefresh

完成刷新