ApplicationContext 扩展功能 - litter-fish/ReadSource GitHub Wiki

ApplicationContext的继承体系

容器启动方式

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

创建ClassPathXmlApplicationContext实例

// org/springframework/context/support/ClassPathXmlApplicationContext.java
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    this(new String[] {configLocation}, true, null);
}

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

    super(parent);
    // 设置配置路径
    setConfigLocations(configLocations);
    if (refresh) {
        refresh();
    }
}

配置路径的设置

// org/springframework/context/support/AbstractRefreshableConfigApplicationContext.java
public void setConfigLocations(String[] locations) {
    if (locations != null) {
        Assert.noNullElements(locations, "Config locations must not be null");
        this.configLocations = new String[locations.length];
        for (int i = 0; i < locations.length; i++) {
            // 解析给定路径，如果包含特殊字符，将被替换为设置的环境变量值
            this.configLocations[i] = resolvePath(locations[i]).trim();
        }
    }
    else {
        this.configLocations = null;
    }
}

扩展功能

// org/springframework/context/support/AbstractApplicationContext.java
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        // 准备刷新上下文环境，
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        // 初始化BeanFactory，并解析XML配置文件
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        // 对BeanFactory进行各种功能的填充
        // @Qualifier、@Autowired注解解析
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            // 子类覆盖方法做额外处理
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            // 激活各种BeanFactory的处理器
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            // 注册BeanPostProcessor，注册拦截Bean创建Bean处理器，只是注册
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            // 为上下文初始化message
            initMessageSource();

            // Initialize event multicaster for this context.
            // 初始化应用消息广播，并放入"applicationEventMulticaster"bean中
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            // 留给子类进行其他bean的初始化
            onRefresh();

            // Check for listener beans and register them.
            // 在所有bean中找到 Listener bean，注册到消息广播器中
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            // 初始化剩下的单例bean
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            // 完成刷新操作，通知生命周期处理器LifecycleProcessor刷新过程，同时发出ContextRefreshedEvent通知
            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.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }
    }
}

准备刷新上下文环境

// org/springframework/context/support/AbstractApplicationContext.java
protected void prepareRefresh() {
    this.startupDate = System.currentTimeMillis();

    synchronized (this.activeMonitor) {
        this.active = true;
    }

    if (logger.isInfoEnabled()) {
        logger.info("Refreshing " + this);
    }

    // Initialize any placeholder property sources in the context environment
    // 个性化属性的处理和设置
    initPropertySources();

    // Validate that all properties marked as required are resolvable
    // see ConfigurablePropertyResolver#setRequiredProperties
    // 对属性的校验
    getEnvironment().validateRequiredProperties();
}

通过自定义实现ApplicationContext的类，然后重写initPropertySources方法添加验证要求，实现系统属性或环境变量进行准备和验证

public class MyClassPathXmlApplicationContext extends MyClassPathXmlApplicationContext {
    public MyClassPathXmlApplicationContext(String... configLocations) throws BeansException {
		super(configLocations);
	}
    
    protected void initPropertySources() {
		getEnvironment().setRequiredProperties("VAR");
	}
}

初始化BeanFactory，并解析XML配置文件

// org/springframework/context/support/AbstractApplicationContext.java
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 初始化BeanFactory，并解析XML配置文件，并将BeanFactory存储在当前实体属性中
    refreshBeanFactory();
    // 返回当前实体的beanFactory实例
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    return beanFactory;
}

初始化BeanFactory，并解析XML配置文件，并将BeanFactory存储在当前实体属性中

// org/springframework/context/support/AbstractRefreshableApplicationContext.java
protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        // 创建DefaultListableBeanFactory
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        // 指定序列化ID
        beanFactory.setSerializationId(getId());
        // 定制beanFactory，设置相关属性，设置是否可以覆盖同名称的不同定义的对象，设置bean之间是否可以循环依赖
        // 设置@Qualifier、@Autowired注解的解析器
        customizeBeanFactory(beanFactory);
        // 初始化XmlBeanDefinitionReader，并解析XML配置文件
        loadBeanDefinitions(beanFactory);
        synchronized (this.beanFactoryMonitor) {
            this.beanFactory = beanFactory;
        }
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

上述逻辑首先创建DefaultListableBeanFactory、指定序列化ID、定制beanFactory、加载BeanDefinition、最后记录全局beanFactory。

定制beanFactory，在基本的容器功能下，会增加一些ApplicationContext特定的能力：是否允许覆盖、是否允许循环依赖、并提供了注解@Qualifier、@Autowired的支持

// org/springframework/context/support/AbstractRefreshableApplicationContext.java
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    // 设置是否可以覆盖同名称的不同定义的对象
    if (this.allowBeanDefinitionOverriding != null) {
        beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    // 设置bean之间是否可以循环依赖
    if (this.allowCircularReferences != null) {
        beanFactory.setAllowCircularReferences(this.allowCircularReferences);
    }
    // @Qualifier、@Autowired注解
    beanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
}

通过实现自己的ApplicationContext类，可以进行属性：允许覆盖、允许循环依赖的设置

public class MyClassPathXmlApplicationContext extends MyClassPathXmlApplicationContext {
    public MyClassPathXmlApplicationContext(String... configLocations) throws BeansException {
		super(configLocations);
	}
    
    protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
		 super.setAllowBeanDefinitionOverriding(false);
        super.setAllowCircularReferences(false);
        super.customizeBeanFactory(beanFactory);
	}
}

加载BeanDefinition

// org/springframework/context/support/AbstractXmlApplicationContext.java
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // Create a new XmlBeanDefinitionReader for the given BeanFactory.
    // 为beanFactory创建 XmlBeanDefinitionReader
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    // Configure the bean definition reader with this context's
    // resource loading environment.
    // 设置 beanDefinitionReader 环境变量
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

    // Allow a subclass to provide custom initialization of the reader,
    // then proceed with actually loading the bean definitions.
    // 对BeanDefinitionReader进行设置
    initBeanDefinitionReader(beanDefinitionReader);
    loadBeanDefinitions(beanDefinitionReader);
}

对BeanFactory进行功能扩展

// org/springframework/context/support/AbstractApplicationContext.java
protected void 	prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // Tell the internal bean factory to use the context's class loader etc.
    // 设置beanFactory的classLoader为当前context的classLoader
    beanFactory.setBeanClassLoader(getClassLoader());
    // 设置beanFactory的表达式处理器
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
    // 为beanFactory添加一个默认的PropertyEditor
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // Configure the bean factory with context callbacks.
    // 添加一个BeanPostProcessor ApplicationContextAwareProcessor
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    // 设置一些忽略的自动装配接口，忽略ApplicationContextAwareProcessor中postProcessBeforeInitialization方法的Aware
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    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.
    // 增加对AspectJ的支持
    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.
    // 注册默认的环境bean
    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());
    }
}

增加SPEL的支持

beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());

上述代码会设置容器的默认表达式解析处理器为StandardBeanExpressionResolver，当进行bean实例化的属性填充时会使用其解析spel表达式

// org.springframework.beans.factory.support.AbstractBeanFactory
protected Object evaluateBeanDefinitionString(String value, BeanDefinition beanDefinition) {
    if (this.beanExpressionResolver == null) {
        return value;
    }
    Scope scope = (beanDefinition != null ? getRegisteredScope(beanDefinition.getScope()) : null);
    // beanExpressionResolver被设置为StandardBeanExpressionResolver实例
    return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));
}

为beanFactory添加属性编辑器的支持

自定义属性编辑器的使用首先，定义一个继承PropertyEditorSupport的类，并重写其setAsText方法

public class PhoneEditor extends PropertyEditorSupport {
    public void setAsText(String text) throws java.lang.IllegalArgumentException {
    }
}

接着进行配置，将其注册到Spring中

<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
	<property name="CustomEditors">
		<map>
			<entry key="com.test.Phone">
				<bean id="phoneEditor" class="com.test.PhoneEditor"></bean>
			</entry>
		</map>
	</property>
</bean>

注册Spring自带的属性编辑器CustomDateEditor

首先，自定义类实现PropertyEditorRegistrar接口，实现方法registerCustomEditors

public class CustomDatePropertyEditor implements PropertyEditorRegistrar { 
     @Override
     public void registerCustomEditors(PropertyEditorRegistry registry) {
         registry.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yy-MM-dd"), true));
     }
}

接着，配置bean注册到Spring中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="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">

    <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
        <property name="propertyEditorRegistrars">
            <list>
                <bean class="com.test.CustomDatePropertyEditor"/>
            </list>
        </property>
    </bean>
</beans>

实现原理，首先在实例化bean的时候会进行初始化

// org/springframework/beans/factory/support/ConstructorResolver.java
public BeanWrapper autowireConstructor(
			final String beanName, final RootBeanDefinition mbd, Constructor<?>[] chosenCtors, final Object[] explicitArgs) {

		BeanWrapperImpl bw = new BeanWrapperImpl();
		this.beanFactory.initBeanWrapper(bw);
        // 省略其他逻辑
 }

接着会使用注册的自定义编辑器初始化给定的BeanWrapper

// org/springframework/beans/factory/support/AbstractBeanFactory.java
protected void initBeanWrapper(BeanWrapper bw) {
    bw.setConversionService(getConversionService());
    // 使用注册的自定义编辑器初始化给定的BeanWrapper
    registerCustomEditors(bw);
}

然后使用两种自定义方式处理

protected void registerCustomEditors(PropertyEditorRegistry registry) {
    PropertyEditorRegistrySupport registrySupport =
            (registry instanceof PropertyEditorRegistrySupport ? (PropertyEditorRegistrySupport) registry : null);
    if (registrySupport != null) {
        registrySupport.useConfigValueEditors();
    }
    // 自定义属性编辑器
    if (!this.propertyEditorRegistrars.isEmpty()) {
        for (PropertyEditorRegistrar registrar : this.propertyEditorRegistrars) {
            try {
                registrar.registerCustomEditors(registry);
            }
            catch (BeanCreationException ex) {
                // 。。。。。
            }
        }
    }
    // 注册Spring自带的属性编辑器CustomDateEditor
    if (!this.customEditors.isEmpty()) {
        for (Map.Entry<Class<?>, Class<? extends PropertyEditor>> entry : this.customEditors.entrySet()) {
            Class<?> requiredType = entry.getKey();
            Class<? extends PropertyEditor> editorClass = entry.getValue();
            registry.registerCustomEditor(requiredType, BeanUtils.instantiateClass(editorClass));
        }
    }
}

添加一个BeanPostProcessor处理器ApplicationContextAwareProcessor

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

在bean的初始化前后执行一些逻辑，实现Aware接口的bean做一些处理

class ApplicationContextAwareProcessor implements BeanPostProcessor {

	private final ConfigurableApplicationContext applicationContext;


	/**
	 * Create a new ApplicationContextAwareProcessor for the given context.
	 */
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
	}

    // 初始化前调用
	public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
		AccessControlContext acc = null;

		if (System.getSecurityManager() != null &&
				(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
						bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
						bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged(new PrivilegedAction<Object>() {
				public Object run() {
					invokeAwareInterfaces(bean);
					return null;
				}
			}, acc);
		}
		else {
			invokeAwareInterfaces(bean);
		}

		return bean;
	}
    // 实现Aware接口的bean做处理
	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof EnvironmentAware) {
				((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
			}
			if (bean instanceof EmbeddedValueResolverAware) {
				((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(
						new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
			}
			if (bean instanceof ResourceLoaderAware) {
				((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
			}
			if (bean instanceof ApplicationEventPublisherAware) {
				((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
			}
			if (bean instanceof MessageSourceAware) {
				((MessageSourceAware) bean).setMessageSource(this.applicationContext);
			}
			if (bean instanceof ApplicationContextAware) {
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
			}
		}
	}
    // 初始化后调用
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		return bean;
	}

}

激活BeanFactoryPostProcessor处理器

BeanFactoryPostProcessor处理器：该处理器是一个容器级的处理器你可以在bean进行实例化之前修改bean的内存属性定义，如果定义了多个该处理器可通过order属性决定其执行顺序。

// org/springframework/context/support/AbstractApplicationContext.java
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    Set<String> processedBeans = new HashSet<String>();
    // 对BeanDefinitionRegistry类型的处理
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 记录通过硬编码方式注册的BeanFactoryPostProcessor类型的处理器
        List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
        // 记录通过硬编码方式注册的BeanDefinitionRegistryPostProcessor类型的处理器
        List<BeanDefinitionRegistryPostProcessor> registryPostProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
        /**
         * 硬编码注册的后处理器
         */
        for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryPostProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                // 对于BeanDefinitionRegistryPostProcessor类型，先调用其postProcessBeanDefinitionRegistry方法
                registryPostProcessor.postProcessBeanDefinitionRegistry(registry);

                // 硬编码方式注册的BeanDefinitionRegistryPostProcessor类型的注册器
                registryPostProcessors.add(registryPostProcessor);
            }
            else {
                // 硬编码方式注册的BeanFactoryPostProcessor类型的注册器
                regularPostProcessors.add(postProcessor);
            }
        }

        /**
         * 配置注册的后处理器
         */
        Map<String, BeanDefinitionRegistryPostProcessor> beanMap =
                beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
        // 记录通过配置方式注册的BeanDefinitionRegistryPostProcessor类型的注册器
        List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans = new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());
        OrderComparator.sort(registryPostProcessorBeans);
        // 对BeanDefinitionRegistryPostProcessor类型的处理
        for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }

        // 激活postProcessBeanFactory方法，
        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!
    // 配置中BeanFactoryPostProcessor的类型
    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));
    }

    // 按照Order进行排序
    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);
}

BeanDefinitionRegistryPostProcessor解说

从上图可知BeanDefinitionRegistryPostProcessor继承BeanFactoryPostProcessor，并提供了自己的postProcessBeanDefinitionRegistry方法

// 实例化bean之前能够修改bean的元数据
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
// 提供注册bean到Spring容器的功能
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

注册BeanPostProcessor

实现BeanPostProcessor接口的处理器，主要是在bean的实例化及初始化前后进行一些处理，此处只是进行一些注册操作

// org/springframework/context/support/AbstractApplicationContext.java
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.
    // BeanPostProcessorChecker 是一个普通的信息打印，
    // 在Spring 的配置中的后处理器还没有被注册就已经开始了bean的初始化时变会打印出BeanPostProcessorChecker设定的信息
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // Separate between BeanPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 使用PriorityOrdered排序
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    // MergedBeanDefinitionPostProcessor类型的特殊处理器
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
    // 使用Ordered排序
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    // 无序BeanPostProcessor
    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.
    // 注册所有实现PriorityOrdered的BeanPostProcessor
    OrderComparator.sort(priorityOrderedPostProcessors);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    // 注册所有实现Ordered的BeanPostProcessor
    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.
    // 注册所有无序的BeanPostProcessor
    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.
    // 注册所有实现MergedBeanDefinitionPostProcessor的BeanPostProcessor
    OrderComparator.sort(internalPostProcessors);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);
    // 添加ApplicationListener探测器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector());
}

上述操作首先根据是否实现接口PriorityOrdered、Ordered进行分组，接着根据分组排序进行注册处理器，最后还会添加ApplicationListener探测器。

注册处理器

// org/springframework/context/support/AbstractApplicationContext.java
private void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

    for (BeanPostProcessor postProcessor : postProcessors) {
        // 加入处理器集合，bean实例化时会进行调用
        beanFactory.addBeanPostProcessor(postProcessor);
    }
}

// org/springframework/beans/factory/support/AbstractBeanFactory.java
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    // 先移除已经存在的
    this.beanPostProcessors.remove(beanPostProcessor);
    // 再加入
    this.beanPostProcessors.add(beanPostProcessor);
    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
        this.hasInstantiationAwareBeanPostProcessors = true;
    }
    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
        this.hasDestructionAwareBeanPostProcessors = true;
    }
}

初始化消息资源

MessageSource消息资源的主要实现类

ResourceBundleMessageSource：提供仅通过资源名加载国际化资源 ReloadableResourceBundleMessageSource：提供定时刷新功能，允许在不重启系统的情况下，重新加载资源 StaticMessageSource：允许通过编码方式加载资源

初始化应用消息广播

注册Listener

// org/springframework/context/support/AbstractApplicationContext.java
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 listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
}

初始化非延迟加载的单例

// org/springframework/context/support/AbstractApplicationContext.java
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));
    }

    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // Stop using the temporary ClassLoader for type matching.
    beanFactory.setTempClassLoader(null);

    // Allow for caching all bean definition metadata, not expecting further changes.
    // 冻结所有bean定义，
    beanFactory.freezeConfiguration();

    // Instantiate all remaining (non-lazy-init) singletons.
    // 初始化剩下的单例bean
    beanFactory.preInstantiateSingletons();
}

数据转换的另一种方式

定义一个实体类

public class User implements Serializable{
    
    private String loginName;
    private Date birthDay;
    // 省略get/set
}

定义转换类实现Converter接口

public class StringToDateConverter implements Converter<String, Date>{

    // 日期类型模板：如yyyy-MM-dd，通过配置时注入
    private String datePattern;
    
    public void setDatePattern(String datePattern) {
        this.datePattern = datePattern;
    }

    // Converter<S,T>接口的类型转换方法
    @Override
    public Date convert(String date) {
        try {
            SimpleDateFormat dateFormat = new SimpleDateFormat(this.datePattern);
            // 将日期字符串转换成Date类型返回
            return dateFormat.parse(date);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("日期转换失败!");
            return null;
        }   
    }
}

配置XML注册到

 <bean id="conversionService" 
    class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="StringToDateConverter"
            p:datePattern="yyyy-MM-dd"></bean>
        </list>
    </property>
</bean>

冻结所有bean定义

// org/springframework/beans/factory/support/DefaultListableBeanFactory.java
public void freezeConfiguration() {
    this.configurationFrozen = true;
    synchronized (this.beanDefinitionMap) {
        this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
    }
}

完成刷新操作

// org/springframework/context/support/AbstractApplicationContext.java
protected void finishRefresh() {
    // Initialize lifecycle processor for this context.
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    // 启动所有实现lifecycle的bean
    getLifecycleProcessor().onRefresh();

    // Publish the final event.
    // 广播事件
    publishEvent(new ContextRefreshedEvent(this));

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