01-DispatcherServlet初始化

最新推荐文章于 2024-02-28 07:30:00 发布

惑边

最新推荐文章于 2024-02-28 07:30:00 发布

阅读量366

点赞数

分类专栏： SpringMvc

本文链接：https://blog.csdn.net/my_momo_csdn/article/details/102935925

版权

SpringMvc 专栏收录该内容

7 篇文章 2 订阅

订阅专栏

文章目录

DispatcherServlet初始化

DispatcherServlet初始化

DispatcherServlet是SpringMvc中的核心控制器，负责接收请求，调用处理器，获取结果，处理结果等，本文主要涉及DispatcherServlet的核心初始化部分，下一篇文章了解其调度逻辑。
DispatcherServlet本质是一个Servlet，它的继承关系如下：

Servlet是sun公司提供的开发动态web资源的技术，可以处理Web 浏览器或其他 HTTP 客户端的请求。

在这里插入图片描述

对于DispatcherServlet内部的方法，大致分为两块，一块是初始化部分，一块是处理请求部分；
初始化部分主要是初始化内部的各种策略，SpringMvc这里采用策略模式，策略非常多，这些策略会在处理请求之前初始化，而且调试发现启动项目的时候并不会初始化策略，而是会在收到第一次请求的时候初始化，典型的懒加载思想，所有的策略都有默认策略；
处理请求部分则包括很多步骤，收到请求后寻找对应的处理器方法，包装成Adapter对象，执行拦截器链和目标方法，结果的处理，异常处理等；
本文主要是初始化部分，后一篇文章关于请求处理部分；

一、初始化

1.1 入口

断点打在DispatcherServlet#initStrategies方法的第一行，调试得到如下的方法调用栈：

在这里插入图片描述

下面是调用简图：

在这里插入图片描述

从图中调用栈看到，从tomcat的GenericServlet#init(javax.servlet.ServletConfig)开始，然后进入SpringMvc框架的初始化流程，核心代码如下：

    //GenericServlet#init(javax.servlet.ServletConfig) line 156
    @Override
    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }

init是空实现，预留给子类扩展，由此进入子类HttpServletBean的init方法，下面是HttpServletBean#init核心代码，(省去部分次要代码)

    //HttpServletBean#init
    @Override
	public final void init() throws ServletException {

		// Set bean properties from init parameters.
		PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
		if (!pvs.isEmpty()) {
			try {
				BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
				ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
				bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
				initBeanWrapper(bw);
				bw.setPropertyValues(pvs, true);
			}
			catch (BeansException ex) {
				throw ex;
			}
		}

		//调用子类的扩展方法 Let subclasses do whatever initialization they like.
		initServletBean();
	}

同样的initServletBean也是空方法，由子类FrameworkServlet实现，下面是FrameworkServlet#initServletBean

    //FrameworkServlet#initServletBean
    //Bean属性赋值完成之后调用，创建servlet的WebApplicationContext上下文
    @Override
	protected final void initServletBean() throws ServletException {
		 
		try {
			this.webApplicationContext = initWebApplicationContext();
			initFrameworkServlet();
		}
		catch (ServletException ex) {
			throw ex;
		}
	}

FrameworkServlet#initWebApplicationContext:

protected WebApplicationContext initWebApplicationContext() {

	    //省略代码....
		
		//刷新WebApplicationContext上下文
		onRefresh(wac);
	    
	    //省略代码....

		return wac;
	}

1.2 初始化策略

DispatcherServlet#onRefresh：

    
	//初始化servlet的策略
	protected void initStrategies(ApplicationContext context) {
	    
	    //1.初始化MultipartResolver (MultipartResolver 用于处理文件上传)
		initMultipartResolver(context);
		
		//2.初始化LocaleResolver (根据不同的用户区域展示不同的视图，而用户的区域也称为Locale,比如国际化)
		initLocaleResolver(context);
		
		//3.初始化ThemeResolver (处理主题相关，和LocaleResolver类似)
		initThemeResolver(context);
		
		//4.初始化HandlerMappings (处理器映射器)
		initHandlerMappings(context);
		
		//5.初始化HandlerAdapters (处理适配器)
		initHandlerAdapters(context);
		
		//6.初始化HandlerExceptionResolver (异常处理)
		initHandlerExceptionResolvers(context);
		
		//7.初始化RequestToViewNameTranslator (request到ViewName的转换) 
		initRequestToViewNameTranslator(context);
		
		//8.初始化ViewResolver (ViewResolver是根据ViewName查找VIew)
		initViewResolvers(context);
		
		//9.初始化FlashMapManager (从FlashMapManger获取FlashMap，FlashMap可以重定向时传数据)
		initFlashMapManager(context);
	}

1.3 策略组件

初始化策略的方法最终会将得到的策略对象赋值给对应的属性，如下：

/** MultipartResolver used by this servlet */
	@Nullable
	private MultipartResolver multipartResolver;

	/** LocaleResolver used by this servlet */
	@Nullable
	private LocaleResolver localeResolver;

	/** ThemeResolver used by this servlet */
	@Nullable
	private ThemeResolver themeResolver;

	/** List of HandlerMappings used by this servlet */
	@Nullable
	private List<HandlerMapping> handlerMappings;

	/** List of HandlerAdapters used by this servlet */
	@Nullable
	private List<HandlerAdapter> handlerAdapters;

	/** List of HandlerExceptionResolvers used by this servlet */
	@Nullable
	private List<HandlerExceptionResolver> handlerExceptionResolvers;

	/** RequestToViewNameTranslator used by this servlet */
	@Nullable
	private RequestToViewNameTranslator viewNameTranslator;

	/** FlashMapManager used by this servlet */
	@Nullable
	private FlashMapManager flashMapManager;

	/** List of ViewResolvers used by this servlet */
	@Nullable
	private List<ViewResolver> viewResolvers;

所有这些策略基本都有一个默认的实现，通常情况下我们不关心使用什么策略就是使用的默认策略，默认策略配置在DispatcherServlet.properties文件中。

二、默认策略

查看源码中的DispatcherServlet.properties文件，如下所示，按照注释的说明，这些是DispatcherServlet的策略接口的默认实现，如果在DispatcherServlet的上下文中没有找到匹配的Bean，就会使用这些作为回调，不需要应用程序开发人员定制。(下面中文注释是自己加的)

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.
# LocaleResolver策略(2)
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
# ThemeResolver策略(3)
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
# HandlerMappings策略(4)
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
# HandlerAdapters策略(5)
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter
# HandlerExceptionResolver策略(6)
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
# RequestToViewNameTranslator策略(7)
org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
# ViewResolver策略(8)
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
# FlashMapManager策略(9)
org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

从中文注释可以看到，对应前面初始化的策略，除了MultipartResolver，其余的都是策略实现，默认的策略实现类都在 DispatcherServlet.properties 中指定了。
那么这个文件是在哪里加载的呢？源码中不难找，DispatcherServlet是在静态代码块中读取该文件的。代码没有太多难的，就是将配置转换为一个Properties对象了。

public class DispatcherServlet extends FrameworkServlet {
    
    private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";
    private static final Properties defaultStrategies;
    //省略其他...    	
    
    static {
		// Load default strategy implementations from properties file.
		// This is currently strictly internal and not meant to be customized
		// by application developers.
		try {
		    //1.从属性配置文件加载默认的策略实现(这是内部的，不需要开发人员定义)
			ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
			//2.赋值给Properties对象
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		}
		catch (IOException ex) {
			throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
		}
	}
    //省略其他...
}

下图是调试的时候，对应的属性对象，就是将配置文件转换为Properties对象，内部就是键值对。

在这里插入图片描述

三、策略加载

这一步我们看看一些策略组件的初始化过程，先弄清楚一下整体的思想，在加载策略的是，会去IOC容器找策略Bean，比如initLocaleResolver就会去找BeanName是localeResolver的Bean，如果找到了就使用该策略Bean，如果没有找到，就使用默认的策略，也就是前面从默认策略配置文件加载到defaultStrategies属性的。

3.1 initMultipartResolver

initMultipartResolver方法初始化MultipartResolver策略，如果IOC容器找到了Bean就赋值，没找到就初始化为null (省略部分打印日志的代码)。

	private void initMultipartResolver(ApplicationContext context) {
		try {
			this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
		}
		catch (NoSuchBeanDefinitionException ex) {
			// Default is no multipart resolver.
			this.multipartResolver = null;
		}
	}

3.2 initLocaleResolver 和 initThemeResolver

很简单，这两个和initMultipartResolver差不多,没有找到就采用默认的AcceptHeaderLocaleResolver/ (默认策略组件)

private void initLocaleResolver(ApplicationContext context) {
		try {
			this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);
		}
		catch (NoSuchBeanDefinitionException ex) {
			// We need to use the default.
			this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);
		}
	}

没有找到就使用默认的 FixedThemeResolver

	private void initThemeResolver(ApplicationContext context) {
		try {
			this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class);
		}
		catch (NoSuchBeanDefinitionException ex) {
			// We need to use the default.
			this.themeResolver = getDefaultStrategy(context, ThemeResolver.class);
		}
	}

3.3 initHandlerMappings

initHandlerMappings完成HandlerMapping策略的初始化

private void initHandlerMappings(ApplicationContext context) {
		this.handlerMappings = null;
        //1.如果检测全部的HandlerMapping，就找出全部匹配的
		if (this.detectAllHandlerMappings) {
			// Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
			Map<String, HandlerMapping> matchingBeans =
					BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
			if (!matchingBeans.isEmpty()) {
				this.handlerMappings = new ArrayList<>(matchingBeans.values());
				// We keep HandlerMappings in sorted order.
				AnnotationAwareOrderComparator.sort(this.handlerMappings);
			}
		}
		else {
		    //2.如果不检测全部的HandlerMapping，就找出指定的
			try {
				HandlerMapping hm = context.getBean("handlerMapping", HandlerMapping.class);
				this.handlerMappings = Collections.singletonList(hm);
			}
			catch (NoSuchBeanDefinitionException ex) {
				// Ignore, we'll add a default HandlerMapping later.
			}
		}

		// Ensure we have at least one HandlerMapping, by registering
		// a default HandlerMapping if no other mappings are found.
		//3.如果么有找到，就加载默认的
		if (this.handlerMappings == null) {
			this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
		}
	}

注意detectAllHandlerMappings对应着一个配置，如果配置了则会扫描全部的HandlerMappings策略组件，没有配置则会寻找指定的，没有指定的就加载默认的；

默认情况下，SpringMVC会加载在IOC中所有实现了HandlerMapping接口的bean，再进行按优先级排序。（逻辑1）

如果期望SpringMVC只加载指定的HandlerMapping，可以修改web.xml中的DispatcherServlet的初始化
参数，将detectAllHandlerMappings的值设置为false。这样，SpringMVC就只会加载BeanName为“handlerMapping”的
bean，并作为当前系统的唯一的HandlerMapping策略。（逻辑2）

如果关闭了detectAllHandlerMappings且没有定义HandlerMapping的话，SpringMVC就会按
照DispatcherServlet.properties所定义的内容来加载默认的HandlerMapping。（逻辑3）

3.4 initHandlerAdapters

initHandlerAdapters加载HandlerAdapters，加载逻辑和initHandlerMappings很类似，

private void initHandlerAdapters(ApplicationContext context) {
		this.handlerAdapters = null;
        //1.如果检测全部的HandlerAdapters，就找出全部匹配的
		if (this.detectAllHandlerAdapters) {
			// Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
			Map<String, HandlerAdapter> matchingBeans =
					BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
			if (!matchingBeans.isEmpty()) {
				this.handlerAdapters = new ArrayList<>(matchingBeans.values());
				// We keep HandlerAdapters in sorted order.
				AnnotationAwareOrderComparator.sort(this.handlerAdapters);
			}
		}
		else {
		    //2.如果不检测全部的，就找出指定的
			try {
				HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
				this.handlerAdapters = Collections.singletonList(ha);
			}
			catch (NoSuchBeanDefinitionException ex) {
				// Ignore, we'll add a default HandlerAdapter later.
			}
		}

		//3.如果么有找到，就加载默认的
		if (this.handlerAdapters == null) {
			this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
		}
	}

3.5 其余策略

其余策略包括initHandlerExceptionResolvers、initRequestToViewNameTranslator、initViewResolvers和initFlashMapManager，基本上和前面几种差不多，代码结构都十分类似，找不到就会加载默认的，就不一一解析了。

3.6 默认策略

所有的加载默认策略都是使用getDefaultStrategy方法，我们看看

	protected <T> T getDefaultStrategy(ApplicationContext context, Class<T> strategyInterface) {
		//1.根据类型寻找策略Bean
		List<T> strategies = getDefaultStrategies(context, strategyInterface);
		//2.大于1个，抛出异常
		if (strategies.size() != 1) {
			throw new BeanInitializationException("DispatcherServlet needs exactly 1 strategy for interface [" + strategyInterface.getName() + "]");
		}
		//3.返回
		return strategies.get(0);
	}

主要逻辑在getDefaultStrategies方法

protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
		//1.策略接口的类名为key
		String key = strategyInterface.getName();
		//2.value就是默认策略实现类的全类名，这个在前面的截图中有
		String value = defaultStrategies.getProperty(key);
		if (value != null) {
		    //3.获取类名
			String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
			//4.一种策略可能有多个实现，比如HandlerMapping就要两个默认策略实现
			List<T> strategies = new ArrayList<>(classNames.length);
			//5.遍历创建对应的Bean
			for (String className : classNames) {
				try {
				    //6.加载类
					Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
					//7.创建Bean
					Object strategy = createDefaultStrategy(context, clazz);
					//8.添加到集合
					strategies.add((T) strategy);
				}
				catch (ClassNotFoundException ex) {
					throw new BeanInitializationException(
							"Could not find DispatcherServlet's default strategy class [" + className +
							"] for interface [" + key + "]", ex);
				}
				catch (LinkageError err) {
					throw new BeanInitializationException(
							"Unresolvable class definition for DispatcherServlet's default strategy class [" +
							className + "] for interface [" + key + "]", err);
				}
			}
			//9.返回
			return strategies;
		}
		else {
		    //没有就返回空集合
			return new LinkedList<>();
		}
	}

前面第七步创建Bean，最后就是通过IOC容器去创建Bena，调试发现就是和普通Bean创建流程相似，关键代码如下，如果对创建Bean的流程不熟悉需要自己跟一跟源码

    protected Object createDefaultStrategy(ApplicationContext context, Class<?> clazz) {
	    //获取Bean工厂，创建Bean
		return context.getAutowireCapableBeanFactory().createBean(clazz);
	}
	
	//根据类型创建Bean
	@Override
	@SuppressWarnings("unchecked")
	public <T> T createBean(Class<T> beanClass) throws BeansException {
		// Use prototype bean definition, to avoid registering bean as dependent bean.
		RootBeanDefinition bd = new RootBeanDefinition(beanClass);
		bd.setScope(SCOPE_PROTOTYPE);
		bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
		// For the nullability warning, see the elaboration in AbstractBeanFactory.doGetBean;
		// in short: This is never going to be null unless user-declared code enforces null.
		//到这一步后面就走到 AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])，进入典型的Bean创建流程
		return (T) createBean(beanClass.getName(), bd, null);
	}

四、小结

文章主要梳理了DispatcherServlet的初始化流程，关键是策略的初始化流程，DispatcherServlet中很多组件都采用策略模式，并且都配置了默认策略
在初始化的时候，DispatcherServlet会初始化相关的策略，在IOC中寻找以策略名称为BeanName对应的策略Bean，如果没有找到，则会按照默认策略去加载默认策略，加载的过程就是找到默认策略对应的类，然后使用Bean工厂去创建Bean。
在策略都初始化好了之后，DispatcherServlet就会处理应用请求，这部分后续分析，另外关于具体的策略细节，在后续文章分析。

惑边

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
01-DispatcherServlet初始化

文章目录DispatcherServlet初始化一、初始化1.1 入口1.2 初始化策略1.3 策略组件二、默认策略三、策略加载3.1 initMultipartResolver3.2 initLocaleResolver 和 initThemeResolver3.3 initHandlerMappings3.4 initHandlerAdapters3.5 其余策略3.6 默认策略四、小结Di...
复制链接

扫一扫