现在我们再来看ApplicationContext的refresh方法：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
...............
}
1、 前面梳理了obtainFreshBeanFactory方法，现在我们再来看prepareBeanFactory方法:
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
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 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);
// Register early post-processor for detecting inner beans as ApplicationListeners.
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
if (!beanFactory.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());
}
}
这里首先是设置StandardBeanExpressionResolver(BeanExpressionResolver)，表达式转换，我们看其定义的静态变量就能大概明白其作用：
public class StandardBeanExpressionResolver implements BeanExpressionResolver {
/** Default expression prefix: "#{" */
public static final String DEFAULT_EXPRESSION_PREFIX = "#{";
/** Default expression suffix: "}" */
public static final String DEFAULT_EXPRESSION_SUFFIX = "}";
...................
}
然后添加一个BeanPostProcessor接口的实现(ApplicationContextAwareProcessor)，这个要结合下面的ignoreDependencyInterface一起了解，这里将EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware添加到了ignoreDependencyInterface List中了，我们这些Aware接口都有对应的setter方法，将这些接口添加到ignoreDependencyInterface中，就是在进行Bean对象属性设置的时候忽略调用这些的接口的设置，那在哪里设置呢？就是在ApplicationContextAwareProcessor中设置：
class ApplicationContextAwareProcessor implements BeanPostProcessor {
............
@Override
@Nullable
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
AccessControlContext acc = null;
............
else {
invokeAwareInterfaces(bean);
}
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);
}
}
}
.................
}
这里用一个小demo来说明下，例如创建MyEnvironmentAware ，然后将其添加到.xml（或者注解注入）：
public class MyEnvironmentAware implements EnvironmentAware {
@Override
public void setEnvironment(Environment environment) {
System.out.println("environment");
}
}
然后可以看到：
这里应该需要明白为什么需要这样设计，我的理解是我们可以看到EnvironmentAware、ApplicationContextAware、ApplicationEventPublisherAware这些，其实设置的都是一些这个ApplicationContext级别的组件，例如设置容器本身、Environment环境，是注入SpringMVC自己创建的对象，并不是使用者自己外部主动创建的(当然使用这也可以去拓展)。
同时与这个ignoreDependencyInterface类似的还有下面的registerResolvableDependency，可以看到这里也添加了一些系统级别的对象BeanFactory、ApplicationContext等。前面是通过Aware去设置，这个是如果你直接注入，例如直接通过@Autowired直接去注入一个BeanFactory，你自己并没有主动去创建这个BeanFactory，但注入这个BeanFactory去获取的时候其并不为空，就是通过这个registerResolvableDependency处理的，而且这里还需要注意一个点，你是能通过List注入接收多个实现了同一个接口的实现类，同时这里registerResolvableDependency的几个接口Spring还有另外的作用，例如如果你自己也实现了一个BeanFactory，这个时候就有多个BeanFactory了，但Spring并不会报发现多个BeanFactory实现并且没有设置Primary去指定优先，而是会默认使用Spring自己的(这个逻辑主要是在DefaultListableBeanFactory类的findAutowireCandidates方法)，这里就不具体展开了，例如：
public class MyBeanFactory implements BeanFactory { .............. }public class SpringController{ @Autowired private BeanFactory beanFactory; @Autowired private List<BeanFactory> beanFactoryList; @RequestMapping(value = "/spring", method = RequestMethod.GET) public String springMethod() { return "springMethod"; } }
2、ApplicationListenerDetector
beanFactory.registerResolvableDependency之后，这里会添加一个BeanPostProcessor(ApplicationListenerDetector)，其是用来添加Listener类型的Bean的的：
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean instanceof ApplicationListener) {
Boolean flag = this.singletonNames.get(beanName);
if (Boolean.TRUE.equals(flag)) {
// singleton bean (top-level or inner): register on the fly
this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
}
.............
return bean;
}
3、添加BeanPostProcessor(LoadTimeWeaverAwareProcessor)后，注册一些环静变量到BeanFactory
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());
}
public Map<String, Object> getSystemEnvironment() {
..............
return (Map) System.getenv();
............
}
public Map<String, Object> getSystemProperties() {
return (Map) System.getProperties();
..............
}
4、postProcessBeanFactory(beanFactory)方法
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}
可以看到这里添加了一个BeanPostProcessor(ServletContextAwareProcessor)，并忽略了两个接口ServletContextAware、ServletConfigAware，与上面的类似，这里也是在BeanPostProcessor进行对应设置
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (getServletContext() != null && bean instanceof ServletContextAware) {
((ServletContextAware) bean).setServletContext(getServletContext());
}
if (getServletConfig() != null && bean instanceof ServletConfigAware) {
((ServletConfigAware) bean).setServletConfig(getServletConfig());
}
return bean;
}
通过这个方法可以看到其进行Bean对于这两个对象的设置。
5、invokeBeanFactoryPostProcessors(beanFactory)方法
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
..........
}
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
...........
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
..............
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
..........
}
这个invokeBeanFactoryPostProcessors方法有一大堆，有对这些接口进行sort排序，我们简单说下，这里主要是从BeanFactory获取两种接口BeanDefinitionRegistryPostProcessor、BeanFactoryPostProcessor。
@FunctionalInterface public interface BeanFactoryPostProcessor { void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException; }public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor { void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException; }
然后这些这两个接口的方法，这两个接口也怎样用呢，这个在前面网站有提到我个人的理解，一是看入参，出参，二看接口对应方法的调用时机。所以BeanFactoryPostProcessor 接口这里我的理解是，BeanFactory已经创建了、自定义BeanDefintion也已经加载，所以这里就能对这些解析操作，而BeanDefinitionRegistryPostProcessor，我们就是对BeanDefinitionRegistry进行操作（当然如果我们能确认类型，我们也可以进行类型强转，强转为子类再进行更多的操作）。
6、initMessageSource()方法
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
}
else {
// Use empty MessageSource to be able to accept getMessage calls.
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
..........
}
}
可以看到这里就是设置ApplicationContext的MessageSource，同时这里的HierarchicalMessageSource与前面讲过的HierarchicalBeanFactory类似，就是用来表式一种级别关系，例如其还有嵌套的处理：
public interface HierarchicalMessageSource extends MessageSource {
void setParentMessageSource(@Nullable MessageSource parent);
@Nullable
MessageSource getParentMessageSource();
}
7、initApplicationEventMulticaster()
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);
...........
}
else {
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
...........
}
}
这里就是设置BeanFactory的事件发布器
8、registerListeners()方法(onRefresh()为空方法，SpringMVC没有进行处理，给子类用到)
protected void registerListeners() {
// Register statically specified listeners first.
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);
}
}
}
这里就是将ApplicationListener添加到BeanFactory的事件发布器中。getApplicationListeners就是前面通过ApplicationListenerDetector添加的。
public void addApplicationListener(ApplicationListener<?> listener) {
synchronized (this.retrievalMutex) {
// Explicitly remove target for a proxy, if registered already,
// in order to avoid double invocations of the same listener.
Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);
if (singletonTarget instanceof ApplicationListener) {
this.defaultRetriever.applicationListeners.remove(singletonTarget);
}
this.defaultRetriever.applicationListeners.add(listener);
this.retrieverCache.clear();
}
}
9、finishBeanFactoryInitialization(beanFactory)方法
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));
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 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.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
这里主要就是根据BeanDefinition描叙的Bean信息去创建对应的对象，实现是进行ConversionService的实例化，然后添加StringValueResolver。
@Override
public void addEmbeddedValueResolver(StringValueResolver valueResolver) {
Assert.notNull(valueResolver, "StringValueResolver must not be null");
this.embeddedValueResolvers.add(valueResolver);
}
public String resolveEmbeddedValue(@Nullable String value) {
if (value == null) {
return null;
}
String result = value;
for (StringValueResolver resolver : this.embeddedValueResolvers) {
result = resolver.resolveStringValue(result);
if (result == null) {
return null;
}
}
return result;
}
可以看到这个StringValueResolver也是一种类型转换的作用，只是这里是获取ApplicationContext的getEnvironment().resolvePlaceholders(strVal))，然后将其赋值给BeanFactrory。
10、LoadTimeWeaverAware的实例化，通过
// 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);
}
11、beanFactory.freezeConfiguration()
@Override public void freezeConfiguration() { this.configurationFrozen = true; this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames); }/** Whether bean definition metadata may be cached for all beans */ private volatile boolean configurationFrozen = false;
其作用就是表示当前所有的BeaDefintion都注册完成，能从其对应的缓存中获取到，例如源码对其的的应用：
public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
if (!isConfigurationFrozen() || type == null || !allowEagerInit) {
return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
}
Map<Class<?>, String[]> cache =
(includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);
String[] resolvedBeanNames = cache.get(type);
if (resolvedBeanNames != null) {
return resolvedBeanNames;
}
resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) {
cache.put(type, resolvedBeanNames);
}
return resolvedBeanNames;
}
这里可以看到根据类型去获取对应描叙的beanName。configurationFrozen设置为true后跳过doGetBeanNamesForType，然后直接从allBeanNamesByType中获取。
12、beanFactory.preInstantiateSingletons()方法
public void preInstantiateSingletons() throws BeansException {
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
............
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
..........
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
这里就是将注册到BeanFactory的BeanDefintion都初始为对象，主要分为三部分，一个就是如果不是abstract、为单例、不需要延迟加载，如果为FactoryBean用一个分支处理，不是用另一个去处理。这里如果为FactoryBean其实也就是多了一个判断其有没有继承SmartFactoryBean接口。
public interface SmartFactoryBean<T> extends FactoryBean<T> {
default boolean isPrototype() {
return false;
}
default boolean isEagerInit() {
return false;
}
}
isEagerInit为true，就进行getBean，如果false就不getBean，感觉这里有点类似延迟加载。下面这里又引入一个SmartInitializingSingleton接口
public interface SmartInitializingSingleton {
void afterSingletonsInstantiated();
}
如果Bean实现整个接口运行其afterSingletonsInstantiated方法。通过代码逻辑可以知道这是一个Bean级别的接口，而时机就是现在已经完成了这个Bean的整个初始化逻辑，看你怎样去处理了。
13、finishRefresh()
现在这个BeanFactory的BeanDefintion(单例)都已经完成对象创建了，容器的初始化也完成了，现在就通过finishRefresh来进行对应的善后工作。
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// Initialize lifecycle processor for this context.
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();
// Publish the final event.
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
首先清理ResourceCaches缓存，然后initLifecycleProcessor()：
protected void initLifecycleProcessor() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
}
else {
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
}
}
这里主要是引入了LifecycleProcessor接口(DefaultLifecycleProcessor)，将其创建，并添加到beanFactory中，通过其方法其应该是进行与生命周期相关的操作：
接下来就调用getLifecycleProcessor().onRefresh()，这里获取到的就是刚才设置的DefaultLifecycleProcessor：
@Override
public void onRefresh() {
startBeans(true);
this.running = true;
}
private void startBeans(boolean autoStartupOnly) {
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
Map<Integer, LifecycleGroup> phases = new HashMap<>();
lifecycleBeans.forEach((beanName, bean) -> {
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(beanName, bean);
}
});
if (!phases.isEmpty()) {
List<Integer> keys = new ArrayList<>(phases.keySet());
Collections.sort(keys);
for (Integer key : keys) {
phases.get(key).start();
}
}
}
protected Map<String, Lifecycle> getLifecycleBeans() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
Map<String, Lifecycle> beans = new LinkedHashMap<>();
String[] beanNames = beanFactory.getBeanNamesForType(Lifecycle.class, false, false);
for (String beanName : beanNames) {
..............
beans.put(beanNameToRegister, (Lifecycle) bean);
}
}
}
return beans;
}
可以看到这里首先是从BeanFactory中获取实现Lifecycle接口的Bean，然后根据autoStartupOnly或者实现的是SmartLifecycle接口的Bean，然后将其添加到phases中，再调用其start()方法。
可以看到onRefresh时传的autoStartupOnly为true，start方法传的是false。
14、publishEvent(new ContextRefreshedEvent(this))
这里就是发布ContextRefreshedEvent事件，其对应的是Listener是ContextRefreshListener(其定义在DispatcherServlet中)。
private class ContextRefreshListener implements ApplicationListener<ContextRefreshedEvent> {
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
FrameworkServlet.this.onApplicationEvent(event);
}
}
public void onApplicationEvent(ContextRefreshedEvent event) {
this.refreshEventReceived = true;
onRefresh(event.getApplicationContext());
}
@Override
protected void onRefresh(ApplicationContext context) {
initStrategies(context);
}
protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
这个initStrategies方法前面提过，现在来填这个坑。
private void initMultipartResolver(ApplicationContext context) {
try {
this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
}
...........
}
可以看到这里就是从BeanFactory中获取MultipartResolver，再设置到DispatcherServlet中。下面的init方法与这个类似，其是将ApplicationContext(BeanFactory)中获取的LocaleResolver.calss、ThemeResolver.class、HandlerMapping.class、HandlerAdapter.class、HandlerExceptionResolver.class、RequestToViewNameTranslator、ViewResolver、FlashMapManager，再设置到DispatcherServlet中。
这里的HandlerAdapter是在前面章节讲的NameSpaceHandler，根据对应的标签属性，添加对应的HandlerAdapter通过对应(
spring.handler)添加对应的NamespaceHandler(前面是通过一个例子来说明了其对应的流程)。
http\://www.springframework.org/schema/mvc=org.springframework.web.servlet.config.MvcNamespaceHandler
这里可以知道你在<Beans>添加了这个"http://www.springframework.org/schema/mvc"，就会加入MvcNamespaceHandler到BeanFactory
例如：
public class MvcNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init() {
registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
registerBeanDefinitionParser("default-servlet-handler", new DefaultServletHandlerBeanDefinitionParser());
........
}
}
AnnotationDrivenBeanDefinitionParser的parse方法：
public BeanDefinition parse(Element element, ParserContext parserContext) {
Object source = parserContext.extractSource(element);
XmlReaderContext readerContext = parserContext.getReaderContext();
..............
RootBeanDefinition handlerAdapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
............
readerContext.getRegistry().registerBeanDefinition(HANDLER_ADAPTER_BEAN_NAME , handlerAdapterDef);
............
return null;
}
这里的流程就是<beans>标签中有"http://www.springframework.org/schema/mvc" -> MvcNamespaceHandler -> RequestMappingHandlerAdapter(其他的adapter也是通过这种方式注册到BeanFactory中的)。
至此这个createWebApplicationContext的大体流程梳理完毕,现在已经创建了XmlWebApplicationContext对象，
我们再回到最前面的FrameworkServlet类的initServletBean方法：
protected final void initServletBean() throws ServletException {
...............
try {
this.webApplicationContext = this.initWebApplicationContext();
this.initFrameworkServlet();
}
............
}
initFrameworkServlet方法为空方法，现在整个DispatcherServlet的init()方法已经处理完成，这个DispatcherServlet的WebApplicationContext容器已经完成了初始化了。
之后我们再来梳理DispatcherServlet的service方法，看其是怎样处理一个请求的。