Spring源码解析之标签的解析下篇

阅读须知

研究了半天markdown也没发现怎么为代码块中的重点代码做特殊标记，所以这里使用//单行注释做代码的简单注释，而/**/多行注释的代码注释的同时会做深入分析，同时为了避免篇幅过长，删掉了Spring原来的注释和空行，建议配合Spring源代码进行阅读，本文对应的Spring源码的版本为4.3.8。

正文

上篇文章我们介绍了Spring默认标签的解析，本文我们来分析一下Spring自定义标签的解析。上篇文章我们了解到Spring的默认标签目前有4个（import、alias、bean、beans），也就是说除了这4个标签以外的标签都是自定义标签（当然这里所说的标签不包括那些以子标签形式存在的如property、value等标签），如我们熟知的事务标签：

<tx:annotation-driven/>

注解扫描标签：

<context:component-scan/>

等都属于自定义标签，下面就让我们来分析一下这些自定义标签是如何解析的，承接上篇文章中自定义标签解析的分支：

public BeanDefinition parseCustomElement(Element ele) {    /*解析自定义元素*/    return parseCustomElement(ele, null);}

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {    //获取命名空间    String namespaceUri = getNamespaceURI(ele);    /*根据命名空间获取NamespaceHandler*/    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);    if (handler == null) {        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);        return null;    }    /*解析自定义标签*/    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));}

public NamespaceHandler resolve(String namespaceUri) {    /*获取所有已经配置的handler映射*/    Map<String, Object> handlerMappings = getHandlerMappings();    //根据命名空间找到对应的映射    Object handlerOrClassName = handlerMappings.get(namespaceUri);    if (handlerOrClassName == null) {        return null;    }    else if (handlerOrClassName instanceof NamespaceHandler) {        //如果已经实例化过，直接返回        return (NamespaceHandler) handlerOrClassName;    }    else {        String className = (String) handlerOrClassName;        try {            //反射加载类            Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);            if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {                throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +                        "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");            }            //实例化对象            NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);            namespaceHandler.init(); //调用init方法            //放入缓存            handlerMappings.put(namespaceUri, namespaceHandler);            return namespaceHandler;        }        catch (ClassNotFoundException ex) {            throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +                    namespaceUri + "] not found", ex);        }        catch (LinkageError err) {            throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +                    namespaceUri + "]: problem with handler class file or dependent class", err);        }    }}

private Map<String, Object> getHandlerMappings() {    if (this.handlerMappings == null) {        synchronized (this) {            if (this.handlerMappings == null) {                try {                    //加载配置                    Properties mappings =                            PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);                    if (logger.isDebugEnabled()) {                        logger.debug("Loaded NamespaceHandler mappings: " + mappings);                    }                    Map<String, Object> handlerMappings = new ConcurrentHashMap<String, Object>(mappings.size());                    //放入缓存                    CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);                    this.handlerMappings = handlerMappings;                }                catch (IOException ex) {                    throw new IllegalStateException(                            "Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);                }            }        }    }    return this.handlerMappings;}

这里就是加载配置文件到内存中，而this.handlerMappingsLocation在调用构造方法初始化时被赋值为META-INF/Spring.handlers，我们来看一下Spring事务自定义标签对应这里的配置，锁定spring-tx包下的META-INF/Spring.handlers：

http\://www.springframework.org/schema/tx=org.springframework.transaction.config.TxNamespaceHandler

所以在解析Spring事务自定义标签时就会找到TxNamespaceHandler并调用其init方法：

public void init() {    registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());    registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());    registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());}

init方法就是注册对应三个标签的解析器，这里用Spring事务标签举例，其他自定义标签大同小异。下面就是解析过程：

public BeanDefinition parse(Element element, ParserContext parserContext) {    /*寻找解析器进行解析*/    return findParserForElement(element, parserContext).parse(element, parserContext);}

private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {    //以<tx:annotation-driven/>为例，这里的localName就是annotation-driven    String localName = parserContext.getDelegate().getLocalName(element);    //根据localName获取解析器，上面注册过annotation-driven的解析器    BeanDefinitionParser parser = this.parsers.get(localName);    if (parser == null) {        parserContext.getReaderContext().fatal(                "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);    }    return parser;}

获取到BeanDefinitionParser后，调用其parse方法进行解析，解析的过程就是根据开发者需求的不同自行实现了，整体来说就是解析配置到注册BeanDefinition的过程。到这里自定义标签的解析就完成了，上篇文章开始的refresh方法我们只分析了前两步，下面我们来看后续的步骤：

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {    beanFactory.setBeanClassLoader(getClassLoader());    //设置SPEL表达式处理器，在bean初始化填充属性时会用到    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));    //添加属性编辑器注册器    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));    //添加Aware接口的BeanPostProcessor    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));    //设置几个忽略自动装配的接口    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.registerResolvableDependency(BeanFactory.class, beanFactory);    beanFactory.registerResolvableDependency(ResourceLoader.class, this);    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);    beanFactory.registerResolvableDependency(ApplicationContext.class, this);    //添加用于发现ApplicationListener的BeanPostProcessor    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));    //增加对静态AOP的支持    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));    }    //添加几个默认的系统环境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());    }}

这里提到了属性编辑器和自动装配的概念，这些我们会在bean创建的文章中进行讲解，这里先留一个悬念。简单介绍一下方法中注册的ApplicationContextAwareProcessor，它实现了BeanPostProcessor，Spring会保证所有bean在实例化的时候都会调用其postProcessAfterInitialization方法，我们可以使用这个方法包装和改变bean，我们来看一下这个方法：

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>() {            @Override            public Object run() {                invokeAwareInterfaces(bean); /*调用Aware接口*/                return null;            }        }, acc);    }    else {        invokeAwareInterfaces(bean); /*调用Aware接口*/    }    return 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(this.embeddedValueResolver);        }        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);        }    }}

当我们的bean实现了某个Aware接口，这里就会调用相关的set方法为我们的bean设置相关资源。下一步的postProcessBeanFactory默认为空实现，留给子类扩展做BeanFactory初始化后的后置处理。接下来就是调用所有注册的BeanFactoryPostProcessor的相关方法，我们以一个例子来说明一下BeanFactoryPostProcessor的用法，我们在使用Spring整合Mybatis的时候会配置一个类MapperScannerConfigurer，用来扫描我们工程中定义的所有Mapper接口，我们来看一下它的层次结构：

这里就会调用它的postProcessBeanDefinitionRegistry方法来扫描我们配置的包完成Mapper相关的BeanDefinition的注册，我们会在Spring整合Mybatis的文章中进行详细描述。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {    /*调用注册的所有BeanFactoryPostProcessor的相关方法*/    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());    //再次确认是否需要增加对静态AOP的支持，这段逻辑在prepareBeanFactory方法中已经执行过，这里因为有可能有新的BeanDefinition注册，所以需要再次确认    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));    }}

public static void invokeBeanFactoryPostProcessors(        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {    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 : beanFactoryPostProcessors) {            //首先调用BeanDefinitionRegistryPostProcessor             if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {                BeanDefinitionRegistryPostProcessor registryPostProcessor =                        (BeanDefinitionRegistryPostProcessor) postProcessor;                        //执行postProcessBeanDefinitionRegistry方法                registryPostProcessor.postProcessBeanDefinitionRegistry(registry);                registryPostProcessors.add(registryPostProcessor);            }            else {                regularPostProcessors.add(postProcessor);            }        }        //从所有注册的BeanDefinition中获取BeanDefinitionRegistryPostProcessor        String[] postProcessorNames =                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);        List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();        for (String ppName : postProcessorNames) {            //首先执行实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));                processedBeans.add(ppName);            }        }        sortPostProcessors(beanFactory, priorityOrderedPostProcessors); //排序        registryPostProcessors.addAll(priorityOrderedPostProcessors);        invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry); //执行postProcessBeanDefinitionRegistry方法        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);        List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();        for (String ppName : postProcessorNames) {            //接下来执行实现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); //执行        boolean reiterate = true;        while (reiterate) {            reiterate = false;            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);            for (String ppName : postProcessorNames) {                //执行剩余的BeanDefinitionRegistryPostProcessor                if (!processedBeans.contains(ppName)) {                    BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);                    registryPostProcessors.add(pp);                    processedBeans.add(ppName);                    pp.postProcessBeanDefinitionRegistry(registry);                    reiterate = true;                }            }        }        //BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor，执行完postProcessBeanDefinitionRegistry方法之后还要执行postProcessBeanFactory方法        invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);    }    else {        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);    }    String[] postProcessorNames =            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);            //剩余的BeanFactoryPostProcessor同样按照实现PriorityOrdered --> 实现Ordered --> 其他的顺序执行    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();    List<String> orderedPostProcessorNames = new ArrayList<String>();    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();    for (String ppName : postProcessorNames) {        //上面已经将所有的BeanDefinitionRegistryPostProcessor都执行完了，这里要将它们排除掉，执行剩余的BeanFactoryPostProcessor        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(beanFactory, priorityOrderedPostProcessors);    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();    for (String postProcessorName : orderedPostProcessorNames) {        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));    }    sortPostProcessors(beanFactory, orderedPostProcessors);    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();    for (String postProcessorName : nonOrderedPostProcessorNames) {        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));    }    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);    beanFactory.clearMetadataCache();}

下一步是注册BeanPostProcessor：

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {    /*注册BeanPostProcessor*/    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);}

public static void registerBeanPostProcessors(        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {        //获取所有BeanPostProcessor的beanName    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;    //注册BeanPostProcessorChecker的作用是在BeanPostProcessor初始化期间有bean被创建了就会打印日志    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));    //和上面BeanFactoryPostProcessor执行的过程非常相似，同样是按照PriorityOrdered --> Ordered --> 其他的顺序进行注册，区别是这里最后加了MergedBeanDefinitionPostProcessor类型的BeanPostProcessor的注册，并且这里不会执行相关方法，BeanPostProcessor的相关方法在bean创建时才会执行。这里看起来有重复注册的问题，不过beanFactory.addBeanPostProcessor是先移除在添加，所以不会重复    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 (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {            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);        }    }    sortPostProcessors(beanFactory, priorityOrderedPostProcessors);    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);    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);        }    }    sortPostProcessors(beanFactory, orderedPostProcessors);    registerBeanPostProcessors(beanFactory, orderedPostProcessors);    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);    sortPostProcessors(beanFactory, internalPostProcessors);    registerBeanPostProcessors(beanFactory, internalPostProcessors);    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));}

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，用于国际化处理，关于Spring的国际化处理，有兴趣的读者可以查阅相关资料进行学习，这里就不做描述了。接下来我们来看应用事件广播器的初始化：

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 + "]");        }    }}

我们以默认事件广播器SimpleApplicationEventMulticaster为例看一下它是如何广播事件的：

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();        if (executor != null) {            executor.execute(new Runnable() {                @Override                public void run() {                    /*通知监听器*/                    invokeListener(listener, event);                }            });        }        else {            /*通知监听器*/            invokeListener(listener, event);        }    }}

protected void invokeListener(ApplicationListener listener, ApplicationEvent event) {    ErrorHandler errorHandler = getErrorHandler();    if (errorHandler != null) {        try {            //将应用事件通知监听器            listener.onApplicationEvent(event);        }        catch (Throwable err) {            errorHandler.handleError(err);        }    }    else {        try {            //将应用事件通知监听器            listener.onApplicationEvent(event);        }        catch (ClassCastException ex) {            String msg = ex.getMessage();            if (msg == null || msg.startsWith(event.getClass().getName())) {                Log logger = LogFactory.getLog(getClass());                if (logger.isDebugEnabled()) {                    logger.debug("Non-matching event type for listener: " + listener, ex);                }            }            else {                throw ex;            }        }    }}

很简单，通知监听器就是调用所有监听器的onApplicationEvent方法将事件传入，由监听器自己决定是否处理当前事件，这是一个典型的观察者模式的实现。而接下来就是监听器的注册：

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);        }    }}

接下来是初始化所有非lazy-init的bean：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {    //初始化类型转换器    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));    }    //如果没有配置value处理器（例如PropertyPlaceholderConfigurer）则注册一个默认的value处理器，主要用于处理注解的value    if (!beanFactory.hasEmbeddedValueResolver()) {        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {            @Override            public String resolveStringValue(String strVal) {                return getEnvironment().resolvePlaceholders(strVal);            }        });    }    //初始化实现LoadTimeWeaverAware的bean    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);    for (String weaverAwareName : weaverAwareNames) {        getBean(weaverAwareName);    }    beanFactory.setTempClassLoader(null);    //冻结BeanDefinition，到这里BeanDefinition就不能再修改了，下面就要初始化了    beanFactory.freezeConfiguration();    /*初始化非lazy-init的单例bean*/    beanFactory.preInstantiateSingletons();}

这里提到的类型转换器我们可以通过配置ConversionServiceFactoryBean来注册我们自定义的类型转换器，就是在这里初始化的。

public void preInstantiateSingletons() throws BeansException {    if (this.logger.isDebugEnabled()) {        this.logger.debug("Pre-instantiating singletons in " + this);    }    //获取所有beanName    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);    for (String beanName : beanNames) {        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);        //非abstract、非lazy-init的单例bean        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {            //FactoryBean的处理            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 { //普通bean初始化                getBean(beanName);            }        }    }    //调用所有初始化的后的回调，Spring4.1的新特性，我们的bean实现了SmartInitializingSingleton后，会在初始化后调用实现的afterSingletonsInstantiated方法，我们可以在里面定义一些bean初始化后需要的逻辑    for (String beanName : beanNames) {        Object singletonInstance = getSingleton(beanName);        if (singletonInstance instanceof SmartInitializingSingleton) {            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;            if (System.getSecurityManager() != null) {                AccessController.doPrivileged(new PrivilegedAction<Object>() {                    @Override                    public Object run() {                        smartSingleton.afterSingletonsInstantiated();                        return null;                    }                }, getAccessControlContext());            }            else {                smartSingleton.afterSingletonsInstantiated();            }        }    }}

bean初始化的过程我们会在后续的文章中进行详细阐述，下面就是最后一步啦：

protected void finishRefresh() {    /*初始化LifecycleProcessor（生命周期处理器）*/    initLifecycleProcessor();    /*调用onRefresh*/    getLifecycleProcessor().onRefresh();    //发送Spring上下文初始化完成事件    publishEvent(new ContextRefreshedEvent(this));    //注册MBean    LiveBeansView.registerApplicationContext(this);}

protected void initLifecycleProcessor() {    ConfigurableListableBeanFactory beanFactory = getBeanFactory();    //用户自定义LifecycleProcessor    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 { /*默认LifecycleProcessor*/        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 + "]");        }    }}

注册完LifecycleProcessor接着会调用它的onRefresh方法，我们以默认的DefaultLifecycleProcessor为例分析一下它的作用：

public void onRefresh() {    /*实现了Lifecycle的bean处理*/    startBeans(true);    this.running = true;}

private void startBeans(boolean autoStartupOnly) {    Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();    Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();    for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet()) {        Lifecycle bean = entry.getValue();        if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {            int phase = getPhase(bean);            LifecycleGroup group = phases.get(phase);            if (group == null) {                group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);                phases.put(phase, group);            }            group.add(entry.getKey(), bean);        }    }    if (!phases.isEmpty()) {        List<Integer> keys = new ArrayList<Integer>(phases.keySet());        Collections.sort(keys);        for (Integer key : keys) {            phases.get(key).start();        }    }}

实现了Lifecycle接口的bean，Spring会保证在启动时调用其start方法，在Spring关闭时调用其stop方法。到这里，整个Spring容器就初始化完成了。