• Spring源码分析：非懒加载的单例Bean初始化前后的一些操作

    之前两篇文章Spring源码分析：非懒加载的单例Bean初始化过程（上）和Spring源码分析：非懒加载的单例Bean初始化过程（下）比较详细地分析了非懒加载的单例Bean的初始化过程，整个流程始于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
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();
     
            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
     
            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);
     
            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);
     
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);
     
                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);
     
                // Initialize message source for this context.
                initMessageSource();
     
                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();
     
                // Initialize other special beans in specific context subclasses.
                onRefresh();
     
                // Check for listener beans and register them.
                registerListeners();
     
                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);
     
                // Last step: publish corresponding event.
                finishRefresh();
            }
     
            catch (BeansException ex) {
                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();
     
                // Reset 'active' flag.
                cancelRefresh(ex);
     
                // Propagate exception to caller.
                throw ex;
            }
        }
    }

    之前重点分析的是finishBeanFactoryInitialization方法，这个方法完成了所有非懒加载的单例Bean的初始化。今天我回头重看了一下refresh()方法，发现前面有一些方法还是忽略了没有去特别在意，其实他们都是Spring整个启动流程中的重要组成部分，下面就来分析一下finishBeanFactoryInitialization方法前面的一些方法。

    obtainFreshBeanFactory方法之前已经详细分析过了，就从prepareBeanFactory方法开始。

    PrepareBeanFactory方法

    看一下PrepareBeanFactory方法的实现：

    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
    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Tell the internal bean factory to use the context's class loader etc.
        beanFactory.setBeanClassLoader(getClassLoader());
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this));
     
        // Configure the bean factory with context callbacks.
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
     
        // BeanFactory interface not registered as resolvable type in a plain factory.
        // MessageSource registered (and found for autowiring) as a bean.
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
     
        // Detect a LoadTimeWeaver and prepare for weaving, if found.
        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            // Set a temporary ClassLoader for type matching.
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
     
        // Register default environment beans.
        if (!beanFactory.containsBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
            Map systemProperties;
            try {
                systemProperties = System.getProperties();
            }
            catch (AccessControlException ex) {
                systemProperties = new ReadOnlySystemAttributesMap() {
                    @Override
                    protected String getSystemAttribute(String propertyName) {
                        try {
                            return System.getProperty(propertyName);
                        }
                        catch (AccessControlException ex) {
                            if (logger.isInfoEnabled()) {
                                logger.info("Not allowed to obtain system property [" + propertyName + "]: " +
                                        ex.getMessage());
                            }
                            return null;
                        }
                    }
                };
            }
            beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, systemProperties);
        }
     
        if (!beanFactory.containsBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
            Map<String,String> systemEnvironment;
            try {
                systemEnvironment = System.getenv();
            }
            catch (AccessControlException ex) {
                systemEnvironment = new ReadOnlySystemAttributesMap() {
                    @Override
                    protected String getSystemAttribute(String variableName) {
                        try {
                            return System.getenv(variableName);
                        }
                        catch (AccessControlException ex) {
                            if (logger.isInfoEnabled()) {
                                logger.info("Not allowed to obtain system environment variable [" + variableName + "]: " +
                                        ex.getMessage());
                            }
                            return null;
                        }
                    }
                };
            }
            beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, systemEnvironment);
        }
    }

    首先是第3行，配置当前上下文ClassLoader

    接着是第4行，这是一个表达是语言处理器，可以使用#{bean.xxx}的方式来调用相关属性值

    接着是第5行，这是一个属性编辑器，具体没怎么用过

    接着是第8行，第8行增加了一个ApplicationContextAwareProcessor用于上下文回调，它是BeanPostProcessor的实现类，跟一下这个接口的两个方法postProcessBeforeInitialization和postProcessAfterInitialization即可知道这个方法的作用是：

    • 如果Bean是EmbeddedValueResolverAware接口的实现类，则调用setEmbeddedValueResolver方法，传入当前BeanFactory
    • 如果Bean是ResourceLoaderAware接口的实现类，则调用setResourceLoader方法，传入当前上下文ApplicationContext
    • 如果Bean是ApplicationEventPublisherAware的实现类，则调用setApplicationEventPublisher方法，传入当前上下文ApplicationContext
    • 如果Bean是MessageSourceAware的实现类，则调用setMessageSource方法，传入当前上下文ApplicationContext
    • 如果Bean是ApplicationContextAware的实现类，则调用setApplicationContext方法，传入当前上下文ApplicationContext

    接着是第9行~第12行，意思是Bean如果是这些接口的实现类，则不会被自动装配，自动装配见【Spring9】Autowire（自动装配）机制

    接着是第16行~第19行，意思是修正依赖，这里是一些自动装配的特殊规则，比如是BeanFactory接口的实现类，则修正为当前BeanFactory

    接着是第22行~第26行，意思是如果自定义的Bean中没有一个名为”loadTimeWeaver”的Bena，则会添加一个LoadTimeWeaverAwareProcessor

    最后是第29行~第77行，意思是如果自定义的Bean中没有名为”systemProperties”和”systemEnvironment”的Bean，则注册两个Bena，Key为”systemProperties”和”systemEnvironment”，Value为Map，这两个Bean就是一些系统配置和系统环境信息，具体可以写这么一段代码测试一下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public class TestSpring {
     
        @SuppressWarnings("unchecked")
        @Test
        public void testSpring() {
            ApplicationContext ac = new ClassPathXmlApplicationContext("spring/spring.xml");
     
            Map<String, String> systemPropertiesBean = (Map<String, String>)ac.getBean("systemProperties");
            for (Map.Entry<String, String> entry : systemPropertiesBean.entrySet()) {
                System.out.println(entry.getKey() + "--->" + entry.getValue());
            }
     
            System.out.println("==============================华丽的分隔符==============================");
            Map<String, String> systemEnvironmentBean = (Map<String, String>)ac.getBean("systemEnvironment");
            for (Map.Entry<String, String> entry : systemEnvironmentBean.entrySet()) {
                System.out.println(entry.getKey() + "--->" + entry.getValue());
            }
        }
     
    }

    涉及个人信息，运行结果我就不贴了，大家可以自己试试，至此整个PrepareBeanFactory方法的细节已经分析完毕了。

    invokeBeanFactoryPostProcessors方法

    这个是整个Spring流程中非常重要的一部分，是Spring留给用户的一个非常有用的扩展点，BeanPostProcessor接口针对的是每个Bean初始化前后做的操作而BeanFactoryPostProcessor接口针对的是所有Bean实例化前的操作，注意用词，初始化只是实例化的一部分，表示的是调用Bean的初始化方法，BeanFactoryPostProcessor接口方法调用时机是任意一个自定义的Bean被反射生成出来前。

    OK，看一下源码：

    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
    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // Invoke BeanDefinitionRegistryPostProcessors first, if any.
        Set<String> processedBeans = new HashSet<String>();
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
            List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
                    new LinkedList<BeanDefinitionRegistryPostProcessor>();
            for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryPostProcessor =
                                (BeanDefinitionRegistryPostProcessor) postProcessor;
                        registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                        registryPostProcessors.add(registryPostProcessor);
                }
                else {
                    regularPostProcessors.add(postProcessor);
                }
            }
            Map<String, BeanDefinitionRegistryPostProcessor> beanMap =
                    beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
            List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans =
                    new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());
            OrderComparator.sort(registryPostProcessorBeans);
            for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
                postProcessor.postProcessBeanDefinitionRegistry(registry);
            }
            invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
            processedBeans.addAll(beanMap.keySet());
        }
        else {
            // Invoke factory processors registered with the context instance.
            invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);
        }
     
        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
     
        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
        List<String> orderedPostProcessorNames = new ArrayList<String>();
        List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
        for (String ppName : postProcessorNames) {
            if (processedBeans.contains(ppName)) {
                // skip - already processed in first phase above
            }
            else if (isTypeMatch(ppName, PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            }
            else if (isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            }
            else {
                nonOrderedPostProcessorNames.add(ppName);
            }
        }
     
        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
        OrderComparator.sort(priorityOrderedPostProcessors);
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
     
        // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
        for (String postProcessorName : orderedPostProcessorNames) {
            orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        OrderComparator.sort(orderedPostProcessors);
        invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
     
        // Finally, invoke all other BeanFactoryPostProcessors.
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
        for (String postProcessorName : nonOrderedPostProcessorNames) {
            nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    }

    我们可以自己实现BeanFactoryPostProcessor接口并实现postProcessBeanFactory方法，在所有Bean加载的流程开始前，会调用一次postProcessBeanFactory方法。分析一下这段代码，首先我们使用的是DefaultListableBeanFactory，它是BeanDefinitionRegistry的子类，因此进入第4行的判断。

    整个判断获取的是当前有的BeanFactoryPostProcessor并调用postProcessBeanFactory，这些BeanFactoryPostProcessor是前置通过AbstractApplicationContext的addBeanFactoryPostProcessor方法添加的而不是配置文件里面配置的BeanFactoryPostProcessor的实现Bean，因此这个判断没有任何可执行的BeanFactoryPostProcessor。

    接着40行~41行这两行，获取的是beanDefinitionMap中的Bean，即用户自定义的Bean。

    接着第45行~61行，这里分出了三个List，表示开发者可以自定义BeanFactoryPostProcessor的调用顺序，具体为调用顺序为：

    • 如果BeanFactoryPostProcessor实现了PriorityOrdered接口（PriorityOrdered接口是Ordered的子接口，没有自己的接口方法定义，只是做一个标记，表示调用优先级高于Ordered接口的子接口），是优先级最高的调用，调用顺序是按照接口方法getOrder()的实现，对返回的int值从小到大进行排序，进行调用
    • 如果BeanFactoryPostProcessor实现了Ordered接口，是优先级次高的调用，将在所有实现PriorityOrdered接口的BeanFactoryPostProcessor调用完毕之后，依据getOrder()的实现对返回的int值从小到大排序，进行调用
    • 不实现Ordered接口的BeanFactoryPostProcessor在上面的BeanFactoryPostProcessor调用全部完毕之后进行调用，调用顺序就是Bean定义的顺序

    最后的第63行~第80行就是按照上面的规则依次调用BeanFactoryPostProcessor的postProcessBeanFactory方法。

    registerBeanPostProcessors方法

    接下来看看registerBeanPostProcessors方法，顾名思义，就是注册自定义的BeanPostProcessor接口。看一下代码实现：

    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
    protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
     
        // Register BeanPostProcessorChecker that logs an info message when
        // a bean is created during BeanPostProcessor instantiation, i.e. when
        // a bean is not eligible for getting processed by all BeanPostProcessors.
        int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
        beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
     
        // Separate between BeanPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
        List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
        List<String> orderedPostProcessorNames = new ArrayList<String>();
        List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
        for (String ppName : postProcessorNames) {
            if (isTypeMatch(ppName, PriorityOrdered.class)) {
                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                priorityOrderedPostProcessors.add(pp);
                if (pp instanceof MergedBeanDefinitionPostProcessor) {
                    internalPostProcessors.add(pp);
                }
            }
            else if (isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            }
            else {
                nonOrderedPostProcessorNames.add(ppName);
            }
        }
     
        // First, register the BeanPostProcessors that implement PriorityOrdered.
        OrderComparator.sort(priorityOrderedPostProcessors);
        registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
     
        // Next, register the BeanPostProcessors that implement Ordered.
        List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
        for (String ppName : orderedPostProcessorNames) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            orderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        OrderComparator.sort(orderedPostProcessors);
        registerBeanPostProcessors(beanFactory, orderedPostProcessors);
     
        // Now, register all regular BeanPostProcessors.
        List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
        for (String ppName : nonOrderedPostProcessorNames) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            nonOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
     
        // Finally, re-register all internal BeanPostProcessors.
        OrderComparator.sort(internalPostProcessors);
        registerBeanPostProcessors(beanFactory, internalPostProcessors);
     
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector());
    }

    整体代码思路和invokeBeanFactoryPostProcessors方法类似，但是这里不会调用BeanPostProcessor接口的方法，而是把每一个BeanPostProcessor按照顺序放入一个List中，到时候按顺序调用。

    具体代码思路可以参考invokeBeanFactoryPostProcessors，这里就根据代码总结一下BeanPostProcessor接口的调用顺序：

    • 优先调用PriorityOrdered接口的子接口，调用顺序依照接口方法getOrder的返回值从小到大排序
    • 其次调用Ordered接口的子接口，调用顺序依照接口方法getOrder的返回值从小到大排序
    • 接着按照BeanPostProcessor实现类在配置文件中定义的顺序进行调用
    • 最后调用MergedBeanDefinitionPostProcessor接口的实现Bean，同样按照在配置文件中定义的顺序进行调用

    initMessageSource方法

    initMessageSource方法用于初始化MessageSource，MessageSource是Spring定义的用于实现访问国际化的接口，看一下源码：

    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
    protected void initMessageSource() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
            this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
            // Make MessageSource aware of parent MessageSource.
            if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
                HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
                if (hms.getParentMessageSource() == null) {
                    // Only set parent context as parent MessageSource if no parent MessageSource
                    // registered already.
                    hms.setParentMessageSource(getInternalParentMessageSource());
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Using MessageSource [" + this.messageSource + "]");
            }
        }
        else {
            // Use empty MessageSource to be able to accept getMessage calls.
            DelegatingMessageSource dms = new DelegatingMessageSource();
            dms.setParentMessageSource(getInternalParentMessageSource());
            this.messageSource = dms;
                beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                        "': using default [" + this.messageSource + "]");
            }
        }
    }

    这个if…else…判断比较好理解：

    • 如果自定义了名为”messageSource”的Bean，那么直接实例化Bean，该Bean必须是MessageSource接口的实现Bean，顺便该Bean如果是HierarchicalMessageSource接口的实现类，强转为HierarchicalMessageSource接口，并设置一下parentMessageSource
    • 如果没有自定义名为”messageSource”的Bean，那么会默认注册一个DelegatingMessageSource并加入

    initApplicationEventMulticaster方法

    initApplicationEventMulticaster方法是用于初始化上下文事件广播器的，看一下源码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    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);
            if (logger.isDebugEnabled()) {
                logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
            }
        }
        else {
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                        APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                        "': using default [" + this.applicationEventMulticaster + "]");
            }
        }
    }

    和initMessageSource方法一样，这个if…else…判断也比较好理解：

    • 如果自定义了名为”applicationEventMulticaster”的Bean，就实例化自定义的Bean，但自定义的Bean必须是ApplicationEventMulticaster接口的实现类
    • 如果没有自定义名为”ApplicationEventMulticaster”的Bean，那么就注册一个类型为SimpleApplicationEventMulticaster的Bean

    整个Spring的广播器是观察者模式的经典应用场景之一，这个之后有时间会分析Spring广播器的源码。

    onRefresh方法

    接下来简单说说onRefresh方法，AbstractApplicationContext中这个方法没有什么定义：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    /**
     * Template method which can be overridden to add context-specific refresh work.
     * Called on initialization of special beans, before instantiation of singletons.
     * <p>This implementation is empty.
     * @throws BeansException in case of errors
     * @see #refresh()
     */
    protected void onRefresh() throws BeansException {
        // For subclasses: do nothing by default.
    }

    看一下注释的意思：一个模板方法，重写它的作用是添加特殊上下文刷新的工作，在特殊Bean的初始化时、初始化之前被调用。在Spring中，AbstractRefreshableWebApplicationContext、GenericWebApplicationContext、StaticWebApplicationContext都实现了这个方法。

    registerListeners方法

    registerListeners方法顾名思义，用于注册监听器：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    /**
     * Add beans that implement ApplicationListener as listeners.
     * Doesn't affect other listeners, which can be added without being beans.
     */
    protected void registerListeners() {
        // Register statically specified listeners first.
        for (ApplicationListener listener : getApplicationListeners()) {
            getApplicationEventMulticaster().addApplicationListener(listener);
        }
        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let post-processors apply to them!
        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
        for (String lisName : listenerBeanNames) {
            getApplicationEventMulticaster().addApplicationListenerBean(lisName);
        }
    }

    这里先向applicationEventMulticaster中注册一些静态的、特定的监听器。

    finishRefresh方法

    最后一步，结束Spring上下文刷新：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    /**
     * Finish the refresh of this context, invoking the LifecycleProcessor's
     * onRefresh() method and publishing the
     * {@link org.springframework.context.event.ContextRefreshedEvent}.
     */
    protected void finishRefresh() {
        // Initialize lifecycle processor for this context.
        initLifecycleProcessor();
     
        // Propagate refresh to lifecycle processor first.
        getLifecycleProcessor().onRefresh();
     
        // Publish the final event.
        publishEvent(new ContextRefreshedEvent(this));
    }

    这里面分了三步，第一步，初始化LifecycleProcessor接口：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    protected void initLifecycleProcessor() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
            this.lifecycleProcessor =
                    beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
            }
        }
        else {
            DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
            defaultProcessor.setBeanFactory(beanFactory);
            this.lifecycleProcessor = defaultProcessor;
            beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate LifecycleProcessor with name '" +
                        LIFECYCLE_PROCESSOR_BEAN_NAME +
                        "': using default [" + this.lifecycleProcessor + "]");
            }
        }
    }

    流程和initMessageSource方法、initApplicationEventMulticaster方法基本类似：

    • 先找一下有没有自定义名为”lifecycleProcessor”的Bean，有的话就实例化出来，该Bean必须是LifecycleProcessor的实现类
    • 没有自定义名为”lifecycleProcessor”的Bean，向Spring上下文中注册一个类型为DefaultLifecycleProcessor的LifecycleProcessor实现类

    第二步，调用一下LifecycleProcessor的onRefresh方法。

    第三步，由于之前已经初始化了：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public void publishEvent(ApplicationEvent event) {
        Assert.notNull(event, "Event must not be null");
        if (logger.isTraceEnabled()) {
            logger.trace("Publishing event in " + getDisplayName() + ": " + event);
        }
        getApplicationEventMulticaster().multicastEvent(event);
        if (this.parent != null) {
            this.parent.publishEvent(event);
        }
    }

    后记

    再看AbstractApplicationContext的refresh方法，从中读到了很多细节：

    • Spring默认加载的两个Bean，systemProperties和systemEnvironment，分别用于获取环境信息、系统信息
    • BeanFactoryPostProcessor接口用于在所有Bean实例化之前调用一次postProcessBeanFactory
    • 可以通过实现PriorityOrder、Order接口控制BeanFactoryPostProcessor调用顺序
    • 可以通过实现PriorityOrder、Order接口控制BeanPostProcessor调用顺序
    • 默认的MessageSource，名为”messageSource”
    • 默认的ApplicationEventMulticaster，名为”applicationEventMulticaster”
    • 默认的LifecycleProcessor，名为”lifecycleProcessor”

    除了这些，在整个refresh方法里还隐藏了许多细节，这里就不一一罗列了，多读源码，会帮助我们更好地使用Spring。
  • 相关阅读:
    java后台生成图片二维码
    layui框架下的摸索与学习
    eclipse/myeclipse中js/java的自动提示只有4个字符怎么解决
    Git日常操作指令
    node指南开发练习笔记（1）-- express
    echart全国主要城市某数据的显示
    微信公众号开发获取当前位置
    显示上传图片
    移动端Safari onclick事件兼容
    Plupload上传插件自定义图片的修改
  • 原文地址：https://www.cnblogs.com/downey/p/7404679.html
Copyright © 2020-2023  润新知