Spring之SpringContext

一、概述

1.Spring Context概念

创建上下文并将BeanPostProcessor加载到spring

2.Spring Application Context概念

Spring通过应用上下文（Application Context）装载bean的定义并把它们组装起来。Spring应用上下文全权负责对象的创建和组装。

3. 关系

（1）Spring Context 模块核心是Spring Context

（2）Spring Context 核心是Spring Application Context

（3）Spring Application Context 的核心方法是 AbstractApplicationContext

二、AbstractApplicationContext之刷新源码分析

1. 基础源码

高效记忆：Spring应用文刷新 — 刷机

（1）手机系统太卡了于是自己刷机。首先 准备刷机环境 （准备刷新上下文环境），准备好后老系统 初始化并加载 定义信息（初始化BeanFactory，并加载bean definitions信息）

（2）然后进行系统 配置 并（对beanFacotry进行配置）开始系统 激活 并提交过程（激活BeanFactoryPostProcessors）

（3）再进行验证码 注册 并提交过程（注册BeanPostProcessors），注册后新系统 初始化信息资源、广播 且注册监听器（初始化MessageSource、初始化事件广播器、注册事件监听器）

（4）最后系统 热加载弹粒 并（构造热加载单例bean）完成刷机 （完成刷新过程,通知生命周期处理器），如果刷机 错误 就 销户并修改 激活标识（销毁bean、修改active标识）

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();   // #1 准备刷新上下文环境

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // #2 初始化BeanFactory，并加载bean definitions信息

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);    // #3 对beanFacotry进行配置

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);    // #4  提供给子类扩展的预留方法

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);   // #5 激活BeanFactoryPostProcessors

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);    // #6 注册BeanPostProcessors

				// Initialize message source for this context.
				initMessageSource();    // #7 初始化MessageSource

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();  // #8 初始化事件广播器

				// Initialize other special beans in specific context subclasses.
				onRefresh();    // #9 提供给子类初始化其他的Bean

				// Check for listener beans and register them.
				registerListeners();    // #10 注册事件监听器

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);   // #11 构造热加载单例bean

				// Last step: publish corresponding event.
				finishRefresh();    // #12 完成刷新过程,通知生命周期处理器
			}

			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.
				destroyBeans(); // #13 出错了，销毁bean

				// Reset 'active' flag.
				cancelRefresh(ex);  // #14 出错了，修改active标识

				// 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...
				resetCommonCaches();
			}
		}
	}

2.初始化并加载 obtainFreshBeanFactory

AbstractApplicationContext—obtainFreshBeanFactory ----> AbstractRefreshableApplicationContext—refreshBeanFactory

protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) { // #1 如果已存在BeanFactory，销毁原来的BeanFactory
        destroyBeans();
        closeBeanFactory();
    }
    try {
        DefaultListableBeanFactory beanFactory = createBeanFactory();   // #2 创建DefaultListableBeanFactory
        beanFactory.setSerializationId(getId());
        customizeBeanFactory(beanFactory);
        // #3 加载bean definitions信息，loadBeanDefinitions是抽象方法，不同实现类会从不同的配置中获取bean definitions信息，
        // 如AnnotationConfigWebApplicationContext，XmlWebApplicationContext。
        loadBeanDefinitions(beanFactory);   
        synchronized (this.beanFactoryMonitor) {
            this.beanFactory = beanFactory;
        }
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

3.激活 BeanFactoryPostProcessors

（1）BeanFactoryPostProcessor是spring提供的扩展接口，可以通过BeanFactoryPostProcessor对beanFactory进行自定义处理，如修改其他BeanDefinition的配置。

（2）BeanFactoryPostProcessor可以调整beanFactory，甚至修改BeanDefinition，如CustomEditorConfigurer，将用户定义的PropertyEditor注册到beanFactory中，以便后续使用。

（3）BeanDefinitionRegistryPostProcessor可以注册新的BeanDefinition，如ConfigurationClassPostProcessor，是实现springboot很关键的类

AbstractApplicationContext—invokeBeanFactoryPostProcessors ----> PostProcessorRegistrationDelegate—invokeBeanFactoryPostProcessors

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    Set<String> processedBeans = new HashSet<String>();
	// #1 如果beanFactory是BeanDefinitionRegistry，需要处理BeanFactoryPostProcessors，
	// BeanDefinitionRegistryPostProcessor，否则只处理BeanFactoryPostProcessors
    if (beanFactory instanceof BeanDefinitionRegistry) {    
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
        List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
                new LinkedList<BeanDefinitionRegistryPostProcessor>();
		// #2 方法参数beanFactoryPostProcessors是AbstractApplicationContext---beanFactoryPostProcessors属性，
		// 用户可以通过AbstractApplicationContext---addBeanFactoryPostProcessor方法添加BeanFactoryPostProcessor。这里对beanFactoryPostProcessors参数进行分类
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {              if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryPostProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                registryPostProcessors.add(registryPostProcessor);
            }
            else {
                regularPostProcessors.add(postProcessor);
            }
        }

		// #3 获取beanFactory已经存在的BeanDefinitionRegistryPostProcessor，这里并没有直接构建BeanDefinitionRegistryPostProcessor，而且通过beanName获取
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);    

        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); 
                // #4 获取实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor，添加到priorityOrderedPostProcessors     
                processedBeans.add(ppName);
            }
        }
        // #5 对priorityOrderedPostProcessors排序
        sortPostProcessors(beanFactory, priorityOrderedPostProcessors);     
        // #6 排序结果添加到registryPostProcessors
        registryPostProcessors.addAll(priorityOrderedPostProcessors);   
         // #7 调用BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
        invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);   

        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
        for (String ppName : postProcessorNames) {
        	// #8 处理实现了Ordered的BeanDefinitionRegistryPostProcessor
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {   
                orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(beanFactory, orderedPostProcessors); 
        registryPostProcessors.addAll(orderedPostProcessors);
        invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);    

        // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
            	// #9 处理剩余的BeanDefinitionRegistryPostProcessor
                if (!processedBeans.contains(ppName)) { 
                    BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
                    registryPostProcessors.add(pp);
                    processedBeans.add(ppName);
                    pp.postProcessBeanDefinitionRegistry(registry);
                    reiterate = true;
                }
            }
        }

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);   
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);    
    }

    ...
}

4.初始化事件广播 initApplicationEventMulticaster

4.1 Spring事件体系包括三个组件：

ApplicationEvent事件，ApplicationListener事件监听器，ApplicationEventMulticaster事件广播器。

4.2 事件广播器负责管理事件监听器，并将事件广播给监听器。

AbstractApplicationContext — initApplicationEventMulticaster

rotected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);    //#1 使用用户定义的事件广播器
        if (logger.isDebugEnabled()) {
            logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);   //#2 使用默认的事件广播器
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                    APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                    "': using default [" + this.applicationEventMulticaster + "]");
        }
    }
}

4.3 spring事件

（1）spring提供了context start，stop，close，refresh等事件，ApplicationListener — onApplicationEvent负责处理spring中的事件。

（2）我们可以通过实现ApplicationListener接口自行处理事件，也可以通过PublishListener自定义事件监听器。

使用默认的事件广播器 AbstractApplicationContexton — publishEvent ----> SimpleApplicationEventMulticaster — multicastEvent

public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
        Executor executor = getTaskExecutor();  // #1 如果配置了Executor，使用Executor多线程处理
        if (executor != null) {
            executor.execute(new Runnable() {
                public void run() {
                    invokeListener(listener, event);
                }
            });
        }
        else {
            invokeListener(listener, event);    // #2 否则单线程处理
        }
    }
}

5.注册事件监听器

AbstractApplicationContext — registerListeners将初始化事件监听器ApplicationListener，并绑定到事件广播器上。

protected void registerListeners() {
    for (ApplicationListener<?> listener : getApplicationListeners()) { // #1 getApplicationListeners()获取的是AbstractApplicationContext --- applicationListeners，用户可以通过AbstractApplicationContext --- addApplicationListener添加事件监听器
将AbstractApplicationContext#applicationListeners注册到applicationEventMulticaster
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);   // #2 将上下文中的ApplicationListener注册到applicationEventMulticaster
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;   // #3 发布在此之前已发生的事件
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

6.构造热加载单例bean

AbstractApplicationContext — finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));    //#1 初始化ConversionService，后面注入属性要使用
    }

    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {    //#2 初始化StringValueResolver，用于解析bean属性引用的properties配置
            @Override
            public String resolveStringValue(String strVal) {
                return getEnvironment().resolvePlaceholders(strVal);
            }
        });
    }

    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);   //#3 初始化LoadTimeWeaverAware
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    beanFactory.setTempClassLoader(null);

    beanFactory.freezeConfiguration();

    // Instantiate all remaining (non-lazy-init) singletons.
    beanFactory.preInstantiateSingletons(); //#4 构造热加载单例bean
}

AbstractApplicationContext — preInstantiateSingletons

public void preInstantiateSingletons() throws BeansException {
    ...

    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { // #1 判断是否为非抽象类的热加载单例bean
            if (isFactoryBean(beanName)) {
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                            @Override
                            public Boolean run() {
                                return ((SmartFactoryBean<?>) factory).isEagerInit();
                            }
                        }, getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
            }
            else {
                getBean(beanName);  // #2 构造bean：如果非FactoryBean，构造bean。如果FactoryBean并且FactoryBean.isEagerInit为true，构造bean。
            }
        }
    }
    ...
}

7. 完成刷新 finishRefresh

LifecycleProcessor也是spring提供的扩展点， 通过它可以在spring content start，stop，onRefresh等时刻自定义一些额外操作

protected void finishRefresh() {
    // Initialize lifecycle processor for this context.
    initLifecycleProcessor();   // #1 初始化LifecycleProcessor

    // Propagate refresh to lifecycle processor first.
    getLifecycleProcessor().onRefresh();    // #2 调用LifecycleProcessor#onRefresh()方法

    // Publish the final event.
    publishEvent(new ContextRefreshedEvent(this));  // #3 发布事件

    // Participate in LiveBeansView MBean, if active.
    LiveBeansView.registerApplicationContext(this);
}

参考链接1

---

随心所往，看见未来。Follow your heart，see light！

*欢迎点赞、关注、留言，收藏及转发，一起学习、交流！