Spring5源码解析——第二部分

一、前情回顾

        在第一部分中，我们主要分析了spring的资源解析，bean工厂刷新部分的源码，如果还没有看过第一部分的朋友可以先去看看第一部分的内容，当前也并不影响阅读第二部分。

        这里再把spring的refresh方法粘贴出来，方便表述一下本文的具体内容：

	@Override
	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，调用子类的实现（委派模式，委派子类实现）
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			//为beanFactory配置容器特性，如类加载器，事件处理器等
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				//注册一些beanFactory的后置处理器
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				//执行beanFactory的后置处理器回调
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				//注册bean的后置处理器
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				//初始化信息源（国际化相关）
				initMessageSource();

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

				// Initialize other special beans in specific context subclasses.
				//调用子类的某些特殊bean的初始化方法
				onRefresh();

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

				// Instantiate all remaining (non-lazy-init) singletons.
				//实例化其他所有的单例bean
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				//发布一些事件
				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.
				//销毁所有的bean
				destroyBeans();

				// Reset 'active' flag.
				//结束刷新方法，重置容器的同步标识
				cancelRefresh(ex);

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

 从本文开始我们分析refresh方法中，自obtainFreshBeanFactory方法之后的内容，看看这部分的代码逻辑。

二、prepareBeanFactory()

        首先是prepareBeanFactory(beanFactory)方法，此方法的主要逻辑是为beanFactory配置容器特性，如类加载器，事件处理器等。我们查看一下此方法源代码：

	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 将Context的类加载器赋予bean工厂
		// getClassLoader方法在父类DefaultResourceLoader中定义，内容简单。
		beanFactory.setBeanClassLoader(getClassLoader());
		//设置bean表达式解析器，主要用于解析Spring EL表达式
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		//添加一个属性编辑器的注册组件，此组件可以注册一些属性编辑器，可以用于数据绑定或者类型转换
		//比如将HTTP的属性绑定到对象上。
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		//设置一个处理ApplicationContextAware接口的bean后置处理器
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		//以下这部分设置的是spring在依赖注入时候需要忽略的接口内容
		//以便自定义这些接口的注入逻辑。
		//举例ApplicationContextAware接口，在bean实例化的时候会判断bean是否实现了本接口
		//如果实现了就调用接口的set方法将ApplicationContext注入。
		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或者ApplicationContext这些实例并没有在bean工厂中定义为bean
		//但是这些实例又应该是可以被AutoWire的，所以就在此处手动注册一下类型与对应实例的关系
		//以便在之后根据类型autowire时候可以正确注入依赖。
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// 尽早添加应用监听检测的bean后置处理器，以便于能够在后续的bean实例化时
		// 能够检测发现实现了ApplicationListener接口的bean并正确使用他们。
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		//String LOAD_TIME_WEAVER_BEAN_NAME = "loadTimeWeaver";
		//如果提供了这样的bean，上下文将使用临时ClassLoader进行类型匹配
		// 以便在特定的情景下切换为临时类加载器进行类加载，以防需要加载的类被全局类加载器缓存
		// 比如AOP的代理类，需要与目标类隔离
		//
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// 设置临时类加载器，此加载器中会根据设置好的类型，对所加载的类进行匹配，符合规定，就加载，否则跳过
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		//注册一些默认的环境bean
		//String ENVIRONMENT_BEAN_NAME = "environment";
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		//String SYSTEM_PROPERTIES_BEAN_NAME = "systemProperties";
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		//String SYSTEM_ENVIRONMENT_BEAN_NAME = "systemEnvironment";
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

        具体的方法内容上面的代码注释已经详细说明，不再赘述。

三、postProcessBeanFactory()

        紧接着便是postProcessBeanFactory方法：

	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

        此方法默认没有提供实现，而是供子类按需去扩展。

四、invokeBeanFactoryPostProcessors()

	//执行beanFactory的后置处理器回调    
    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		//关于这段代码逻辑，上面方法分析过了
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

        看得出来主要逻辑就是invokeBeanFactoryPostProcessors方法了，源码如下:

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

		Set<String> processedBeans = new HashSet<>();
		//默认的DefaultListableBeanFactory实现了BeanDefinitionRegistry接口
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();

			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				//将所有的BeanFactoryPostProcessor分类
				// 因为BeanDefinitionRegistryPostProcessor继承于BeanFactoryPostProcessor
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					//执行BeanDefinitionRegistryPostProcessor独有的postProcessBeanDefinitionRegistry方法
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			//从这里开始，执行beanFactory中注册的BeanDefinitionRegistryPostProcessor（也就是说自定义的）
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			//首先，调用实现PriorityOrdered的BeanDefinition注册表后处理器。
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				//判断是否实现了PriorityOrdered接口（优先级排序）如果是，则实例化并添加到currentRegistryProcessors
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//添加到processedBeans，表示此bean 已经解析
					processedBeans.add(ppName);
				}
			}
			//按照优先级排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//添加到registryProcessors中
			registryProcessors.addAll(currentRegistryProcessors);
			//直接执行这部分BeanDefinitionRegistryPostProcessors
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			//清空
			currentRegistryProcessors.clear();

			//接下来，调用实现Ordered的BeanDefinition注册表PostProcessors。
			//此处重新获取postProcessorNames，可能是防止期间代码会产生新的BeanDefinitionRegistryPostProcessor
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				//判断是否实现了Ordered接口（排序）并且processedBeans中没有包含此后置处理器，防止重复调用
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					//添加到currentRegistryProcessors集合
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//添加到processedBeans，表示此bean 已经解析
					processedBeans.add(ppName);
				}
			}
			//排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//添加到registryProcessors集合
			registryProcessors.addAll(currentRegistryProcessors);
			//执行当前的BeanDefinitionRegistryPostProcessor
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			//最后，调用所有其他BeanDefinition注册表PostProcessors，直到没有其他处理器出现。
			boolean reiterate = true;
			//防止器件产生新的目标类
			while (reiterate) {
				reiterate = false;
				//重新获取bean工厂中BeanDefinitionRegistryPostProcessor类型的bean名称
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					//没有被解析过
					if (!processedBeans.contains(ppName)) {
						//实例化并添加
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				//排序
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			//现在，调用到目前为止处理的所有处理器的postProcessBeanFactory回调。
			//内部是循环调用各个BeanFactoryPostProcessor
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			//如果不是BeanDefinitionRegistry类型，直接执行
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		//紧接着，执行所有自定义的BeanFactoryPostProcessor，逻辑与上面如出一辙
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
				//跳过-已在上述第一阶段处理
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				//实现了PriorityOrdered，加入到此集合
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				//实现了PriorityOrdered，加入到此集合
				orderedPostProcessorNames.add(ppName);
			}
			else {
				//否则加入到此集合
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		//首先，调用实现PriorityOrdered的BeanFactory后处理器。
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		//接下来，调用实现Ordered的BeanFactory PostProcessors。
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		//清除缓存的合并bean定义，因为后处理器可能已经修改了原始元数据，例如替换值中的占位符
		beanFactory.clearMetadataCache();
	}

 五、registerBeanPostProcessors()

        接下来便是registerBeanPostProcessors方法：

	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

	public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		//根据bean类型BeanPostProcessor，获取bean名称数组
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		//更新bean工厂中的bean后置处理器数量，+1是因为接下来手动给bean工厂中注册了一个后置处理器BeanPostProcessorChecker
		//BeanPostProcessorChecker的目的是为了在所有的BeanPostProcessor初始化期间
		//创建的bean无法被所有的BeanPostProcessor处理时，记录log日志
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		//
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));


		//根据是否实现优先级排序接口，进行区分。
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		//遍历所有的后置处理器
		for (String ppName : postProcessorNames) {
			//如果此bean实现了PriorityOrdered接口
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				//放入priorityOrderedPostProcessors列表中
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				//如果实现了MergedBeanDefinitionPostProcessor接口，则放入internalPostProcessors列表
				//MergedBeanDefinitionPostProcessor接口中定义了postProcessMergedBeanDefinition
				//该方法允许修改一个未被实例化之前的bean定义的内容，如修改bean的属性
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			//如果实现了Ordered接口，放入orderedPostProcessorNames列表中
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		//首先，注册实现PriorityOrdered的BeanPostProcessors。
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// 接下来，注册实现Ordered的BeanPostProcessors。
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 现在，注册所有常规BeanPostProcessors。
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// 最后，重新注册所有MergedBeanDefinitionPostProcessor
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// 将后处理器重新注册为ApplicationListeners，用于检测内部bean
		// 将其移动到处理器链的末尾（用于获取代理等）。
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

六、initMessageSource()

        初始化消息源，跟国际化相关，不做重点介绍。

	/**
	 * 初始化消息源
	 */
	protected void initMessageSource() {
		//如果bean工厂中未定义MessageSource类型的名称为messageSource的bean
		// 则新建一个DelegatingMessageSource类型的MessageSource，并注册到bean工厂中
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        //MESSAGE_SOURCE_BEAN_NAME = "messageSource"
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);

			if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
				HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
				if (hms.getParentMessageSource() == null) {

					hms.setParentMessageSource(getInternalParentMessageSource());
				}
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Using MessageSource [" + this.messageSource + "]");
			}
		}
		else {
			// 使用空MessageSource可以接受getMessage调用。
			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 + "]");
			}
		}
	}

七、initApplicationEventMulticaster()

        初始化事件传播器，方法逻辑简单，读者自行阅读。

	/**
	 * 初始化ApplicationEventMultimaster。
	 * 如果bean工厂中没有定义，则使用SimpleApplicationEventMultimaster。
	 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
	 */
	protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        //APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster"
		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 + "]");
			}
		}
	}

八、onRefresh()

        此方法默认没有实现，为模板方法，供子类扩展。

	/**
	 * 模板方法，可以重写以添加特定于上下文的刷新工作。
	 * 在实例化单例之前，在初始化特殊bean时调用。
	 * 此实现为空。
	 * @throws BeansException in case of errors
	 * @see #refresh()
	 */
	protected void onRefresh() throws BeansException {
		// 对于子类：默认情况下什么都不做。
	}

九、registerListeners()

        注册事件监听器，并发布早起事件。

	/**
	 * 添加实现ApplicationListener作为侦听器的bean。
	 * 不会影响其他listener，可以在不使用bean的情况下添加。
	 */
	protected void registerListeners() {
		// 首先注册静态指定的侦听器。
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		//获取ApplicationListener类型的bean名称数组，并注册。
		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);
			}
		}
	}

        第二部分的内容就到这里，初始化bean以及之后的源码放到第三部分。