SpringMVC源码分析--DispatcherServlet初始化的九大组件的总体概述（三）

太过爱你忘了你带给我的痛 2022-05-16 03:07 164阅读 0赞

## 在DispatcherServlet同一个目录下的DispatchServlet.properties文件中默认的九大组件： ##

# 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.//这里是定制开发，不可对外更改的
     
    org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
     
    org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
    // 带"/"的是多个默认配置Handler类
    org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
    	org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
     
    org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
    	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
    	org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter
     
    org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\
    	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
    	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
     
    org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
    //这个也可以有多个，这里默认只配置了一个而已
    org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
     
    org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

## 一、HandlerMapping ##

他的作用是根据request找到相应的处理器Handler和Interceptors，并且这个HandlerMapping接口只有一个方法。

源码：

public interface HandlerMapping {
        String PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE = HandlerMapping.class.getName() + ".pathWithinHandlerMapping";
        String BEST_MATCHING_PATTERN_ATTRIBUTE = HandlerMapping.class.getName() + ".bestMatchingPattern";
        String INTROSPECT_TYPE_LEVEL_MAPPING = HandlerMapping.class.getName() + ".introspectTypeLevelMapping";
        String URI_TEMPLATE_VARIABLES_ATTRIBUTE = HandlerMapping.class.getName() + ".uriTemplateVariables";
        String MATRIX_VARIABLES_ATTRIBUTE = HandlerMapping.class.getName() + ".matrixVariables";
        String PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE = HandlerMapping.class.getName() + ".producibleMediaTypes";
    
        @Nullable
        HandlerExecutionChain getHandler(HttpServletRequest var1) throws Exception;
    }

这里通过request返回一个HandlerExecutionChain（包含handler和Interceptor）就可以了，另外HandlerMapping可以通过order属性来定义HandlerMapping的顺序，因为查找Handler是按照顺序遍历的HandlerMapping，当找到一个HandlerMapping后就立即停止查找并返回。

DispatcherServlet中方法调用的源码如下：

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
            if (this.handlerMappings != null) {
                Iterator var2 = this.handlerMappings.iterator();
    
                while(var2.hasNext()) {
                    HandlerMapping hm = (HandlerMapping)var2.next();
                    if (this.logger.isTraceEnabled()) {
                        this.logger.trace("Testing handler map [" + hm + "] in DispatcherServlet with name '" + this.getServletName() + "'");
                    }
    
                    HandlerExecutionChain handler = hm.getHandler(request);
                    if (handler != null) {
                        return handler;
                    }
                }
            }
    
            return null;
        }

## **二、HandlerAdapter适配器** ##

**     ** 这个就是使用Handler的，这个接口提供三个方法源码如下：

public interface HandlerAdapter {
        //判断是否可以使用某个Handler
        boolean supports(Object var1);
        //用来具体使用Handler干活的
        @Nullable
        ModelAndView handle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;
        //来获取资源的Last-Modified.LastModified是资源最后一次修改的时间
        long getLastModified(HttpServletRequest var1, Object var2);
    }

在DispatherServlet中调用的getHandlerAdapter源码如下，这里的Adapter也是采用遍历来获取的，一旦找到合适的就返回，所以Adapter也是可以通过Order属性来设置他们的排序的。同理HandlerAdapter需要注册到SpringMVC的容器中，注册方法和HandlerMapping相同，只需要配置第一个Bean就可以了。

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
            if (this.handlerAdapters != null) {
                Iterator var2 = this.handlerAdapters.iterator();
    
                while(var2.hasNext()) {
                    HandlerAdapter ha = (HandlerAdapter)var2.next();
                    if (this.logger.isTraceEnabled()) {
                        this.logger.trace("Testing handler adapter [" + ha + "]");
                    }
    
                    if (ha.supports(handler)) {
                        return ha;
                    }
                }
            }
    
            throw new ServletException("No adapter for handler [" + handler + "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
        }

## 三、HandlerExceptionResolver ##

当其他组件出现异常时，需要通过这个组件根据异常设置ModelAndView，之后再交给render方法进行渲染，在这里render方法只负责渲染页面，不需要管ModelAndView的由来，分工明确。通过DispatcherServlet中的doDispatch方法知道-----HandlerExceptionResolver只是用来解析对于请求做处理的过程中产生的异常，而渲染环节产生的异常就管不到了。这样在后续我们分析问题的时候就能够知道一些原因了。

接口定义源码如下：

public interface HandlerExceptionResolver {
        @Nullable
        ModelAndView resolveException(HttpServletRequest var1, HttpServletResponse var2, 
            @Nullable Object var3, Exception var4);
    }

它只需要一个方法那就是解析出ModelAndView就可以了，具体实现可以维护一个异常为key，View为value的Map，这样解析的时候就可以通过异常获取到View了，如果在Map中没有对应的异常就返回默认值就可以了。

## 四、ViewResolver ##

ViewResolver是用来将Stirng类型的视图名（也可以叫逻辑视图）和Locale解析为View类型的视图，ViewResolver的接口也比较简单，源码如下：

public interface ViewResolver {
        @Nullable
        View resolveViewName(String var1, Locale var2) throws Exception;
    }

这个方法只需要根据视图名和Locale解析出视图就可以了。但是一般我们不需要对不同区域使用不同的视图进行显示，如果需要国际化支持也只是将显示的内容或者主题使用国际化支持。不过SpringMVC确实有一个功能可以让不同的区域使用的视图进行显示。ResourceBundleViewResolver就需要同时使用视图名和对应的视图类型配置到相应的properties中个，使用classpath下的view为baseName的配置文件，例如：views.properties，views\_zh\_CN.properties等，baseName和文件位置都可以设置。

### View ###

他是用来渲染页面的，通俗来说就是程序将返回的参数填入模板里生产html（或者其他类型）文件。

问题所在：

使用什么模板？

用什么技术填入参数？

那么这里ViewResolver就是用来找到渲染需要的模板和所用的技术（也就是视图的类型）进行渲染，具体的渲染过程就交给不同的视图了。例如：

*        UrlBaseViewResolver系列的解析器都是针对单一视图类型进行解析的，只需要找到使用的模板就可以了。
 *        InternalResourceViewResolver只针对jsp类型的视图
 *        FreeMarkerViewResolver只针对FreeMarker类型的视图
 *        VelocityViewResolver只针对Velocity类型的视图
 *       ResourceBundleViewResolver、XMLViewResolver、BeanNameViewResolver等解析器都可以同时解析多种类型的视图

（ResourceBundleViewResolver通过配置文件properties配置文件来解析，XMLViewResolver通过XML文件进行解析，BeanNameViewResolver通过ViewName从ApplicationContext容器中查找相应的bean做View的）

BeanNameViewResolver源码如下：

public class BeanNameViewResolver extends WebApplicationObjectSupport implements ViewResolver, Ordered {
        private int order = 2147483647;
    
        public BeanNameViewResolver() {
        }
    
        public void setOrder(int order) {
            this.order = order;
        }
    
        public int getOrder() {
            return this.order;
        }
    
        @Nullable
        public View resolveViewName(String viewName, Locale locale) throws BeansException {
            ApplicationContext context = this.obtainApplicationContext();
            if (!context.containsBean(viewName)) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("No matching bean found for view name '" + viewName + "'");
                }
    
                return null;
            } else if (!context.isTypeMatch(viewName, View.class)) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Found matching bean for view name '" + viewName + "' - to be ignored since it does not implement View");
                }
    
                return null;
            } else {
                return (View)context.getBean(viewName, View.class);
            }
        }
    }

总结：ViewResolver使用需要注册到SpringMVC的容器里，默认是使用的org.springframerwork.web.servlet.view.InternalResourceViewResolver（解析jsp模板的）

## 五、RequestToViewNameTranslator ##

ViewResolver是根据ViewName查找的View，但是有的Handler处理完后并没有设置View也没有设置viewName，这时候就需要从Request中获取到viewName了，而如何获取就需要RequestToViewNameTranslator来实现了。

接口源码：

public interface RequestToViewNameTranslator {
        @Nullable
        String getViewName(HttpServletRequest var1) throws Exception;
    }

注意点：RequestToViewNameTranslator在SpringMVC中只能配置一个，所以所有request到ViewName的转换规则都是在一个Translator中全部实现的。

他有一个默认实现类DefaultRequestToViewNameTranslator源码如下:

public class DefaultRequestToViewNameTranslator implements RequestToViewNameTranslator {
        private static final String SLASH = "/";
        private String prefix = "";
        private String suffix = "";
        private String separator = "/";
        private boolean stripLeadingSlash = true;
        private boolean stripTrailingSlash = true;
        private boolean stripExtension = true;
        private UrlPathHelper urlPathHelper = new UrlPathHelper();
    
        public DefaultRequestToViewNameTranslator() {
        }
    
        public void setPrefix(@Nullable String prefix) {
            this.prefix = prefix != null ? prefix : "";
        }
    
        public void setSuffix(@Nullable String suffix) {
            this.suffix = suffix != null ? suffix : "";
        }
    
        public void setSeparator(String separator) {
            this.separator = separator;
        }
    
        public void setStripLeadingSlash(boolean stripLeadingSlash) {
            this.stripLeadingSlash = stripLeadingSlash;
        }
    
        public void setStripTrailingSlash(boolean stripTrailingSlash) {
            this.stripTrailingSlash = stripTrailingSlash;
        }
    
        public void setStripExtension(boolean stripExtension) {
            this.stripExtension = stripExtension;
        }
    
        public void setAlwaysUseFullPath(boolean alwaysUseFullPath) {
            this.urlPathHelper.setAlwaysUseFullPath(alwaysUseFullPath);
        }
    
        public void setUrlDecode(boolean urlDecode) {
            this.urlPathHelper.setUrlDecode(urlDecode);
        }
    
        public void setRemoveSemicolonContent(boolean removeSemicolonContent) {
            this.urlPathHelper.setRemoveSemicolonContent(removeSemicolonContent);
        }
    
        public void setUrlPathHelper(UrlPathHelper urlPathHelper) {
            Assert.notNull(urlPathHelper, "UrlPathHelper must not be null");
            this.urlPathHelper = urlPathHelper;
        }
    
        //重写的方法
        public String getViewName(HttpServletRequest request) {
            String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
            return this.prefix + this.transformPath(lookupPath) + this.suffix;
        }
    
        @Nullable
        protected String transformPath(String lookupPath) {
            String path = lookupPath;
            if (this.stripLeadingSlash && lookupPath.startsWith("/")) {
                path = lookupPath.substring(1);
            }
    
            if (this.stripTrailingSlash && path.endsWith("/")) {
                path = path.substring(0, path.length() - 1);
            }
    
            if (this.stripExtension) {
                path = StringUtils.stripFilenameExtension(path);
            }
    
            if (!"/".equals(this.separator)) {
                path = StringUtils.replace(path, "/", this.separator);
            }
    
            return path;
        }
    }

## 六、LocaleResolver ##

在解析视图的时候需要两个参数：一个是视图名，一个是Locale，视图名是处理器（Handler）返回的（或者使用RequestToViewNameTranslator解析出来的默认视图名），而Locale这就是需要LocaleResolver来解析了。

LocaleResolver用于从request解析出Locale，它接口定义如下：

public interface LocaleResolver {
        Locale resolveLocale(HttpServletRequest var1);
    
        void setLocale(HttpServletRequest var1, @Nullable HttpServletResponse var2, @Nullable Locale var3);
    }

SpringMVC中使用到Locale的地方只有两处：1）ViewResolver解析视图的时候；2）使用到国际化资源或者主题的时候。

那么在SpringMVC中如何提供人为修改Locale的机制呢，这个中间提供了一个Interceptor--org.springframework.web.servlet.i18n.LocaleChangeInterceptor,配置方法如下：

<mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/*" />
            <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

这样就可以通过locale参数来修改Locale了，比如

http://localhost:8080?locale=zh\_CN

http://localhost:8080?locale=en

当然这里url中的“locale”也可以通过paramName设置为别的名称，如下设置为lang

<mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/*" />
            <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"
                p:paramName="lang"/>
        </mvc:interceptor>
    </mvc:interceptors>

就可这样访问：    http://localhost:8080?lang=zh\_CN

## 七、ThemeResolver ##

这个主要是用来解主题的，源码如下：

public interface ThemeResolver {
     
    	String resolveThemeName(HttpServletRequest request);	
    	void setThemeName(HttpServletRequest request, HttpServletResponse response, String themeName);
     
    }

在SpringMVC中一套主题对应一个properties文件，里面存放着跟当前主题相关的所有资源，如图片、css样式表等

#theme.properties
    logo.pic=/images/default/logo.jpg
    logo.word=excelib
    style=/css/default/style.css

将上面的theme.properties文件放到classpath中，如果在jsp页面中就可以使用<spring:theme code ="logo.word"/>了，（需要引入标签库<%talibprefix="spring" uri="http://www.springframework.org/tags"%>）,另外这个SpringMVC也支持国际化，就是不同区域显示不同的冯科，可以定义这样的文件theme.properties；theme\_zh\_CN.properties,theme\_en\_US.properties.SpringMVC跟

主题的相关的类有：ThemeResolver、ThemeSource和Theme，ThemeResolver作用是从reques中解析出主题名，ThemeSource是根据主题名找到具体的主题，Theme是ThemeSource找到具体的主题，通过他获取到主题里面的资源。

**代码：**

//org.springframework.web.servlet.support.RequestContext;
        public String getThemeMessage(String code, Object[] args, String defaultMessage) {
            return getTheme().getMessageSource().getMessage(code, args, defaultMessage, this.locale);
        }
        public Theme getTheme() {
            if (this.theme == null) {
                // Lazily determine theme to use for this RequestContext.
                this.theme = RequestContextUtils.getTheme(this.request);
                if (this.theme == null) {
                    // No ThemeResolver and ThemeSource available -> try fallback.
                    this.theme = getFallbackTheme();
                }
            }
            return this.theme;
        }
        //org.springframework.web.servlet.support.RequestContextUtils
        public static Theme getTheme(HttpServletRequest request) {
            ThemeResolver themeResolver = getThemeResolver(request);
            ThemeSource themeSource = getThemeSource(request);
            if (themeResolver != null && themeSource != null) {
                String themeName = themeResolver.resolveThemeName(request);
                return themeSource.getTheme(themeName);
            }
            else {
                return null;
            }
        }

从RequestContextUtils的代码中就可以看到ThemeResolver和ThemeSource的作用。ThemeResolver的默认实现是org.springframework.web.servlet.theme**.FixedThemeResolver**   
在讲SpringMVC容器创建时介绍过WebApplicationContext是在FrameworkServlet中创建的，默认使用的是**XmlWebApplicationContext**，它的父类是AbstractRefreshableWebApplicationContext，这个类**实现了ThemeSource接口，实现方式是在内部封装了一个ThemeSource属性，然后将具体工作交给它**。   
这里可以把ThemeSource理解成一个配置文件，默认使用的是WebApplicationContext。ThemeResolver默认使用的是FixedThemeResolver。这些我们可以自己配置，例如：

这里不仅配置了themeResolverhe和themeSource，而且还配置了默认主题名“default”，以及配置文件的位置在com.excelib.themes包下（注意配置后面有“.”）。

怎么切换主题呢？同理和Locale相似，使用interceptor来实现，如下所示：

<mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/*"/>
            <bean class="org.springframework.web.servlet.theme.ThemeChangeInterceptor"
                p:paramName="theme"/>
        <mvc:interceptor/>
    <mvc:interceptors/>

可以通过paramName修改主题的参数名，默认使用“theme”，下面的请求就可以切换主题http://localhost:8080?theme=summer

## 八、MultipartResolver ##

用于处理上传请求，处理方法时将普通的request包装成MultipartHttpServletRequest，后者可以直接调用getFile方法获取File，如果上传多个文件，还可以调用getFileMap得到FileName->File结构的Map，这样就使得上传请求的处理变得非常简单。   
然后，其实不包装直接用request也可以，

因为并不是每一个请求都需要上传文件，所以SpringMVC中此组件没有提供默认值。MultipartResolver代码如下：

public interface MultipartResolver {
        boolean isMultipart(HttpServletRequest request);//判断是不是上传请求，判断是不是multipart/form-data类型
        //将request包装成MultipartHttpServletRequest
        MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException;
        void cleanupMultipart(MultipartHttpServletRequest request);//清除上传过程中产生的临时资源
    }

## 九、FlashMapManager ##

FlashMap主要用在redirect中传递参数。而FlashMapManager是用来管理FlashMap的，定义如下：

public interface FlashMapManager {
          //恢复参数，将恢复过的和超时的参数从保存介质中删除；
        FlashMap retrieveAndUpdate(HttpServletRequest request, HttpServletResponse response);
          //用于将参数保存起来。
        void saveOutputFlashMap(FlashMap flashMap, HttpServletRequest request, 
            HttpServletResponse response);
    }

默认实现是org.springframework.web.servlet.support.SessionFlashMapManager。它将参数保存在session中，实现原理就是利用session作为中转站保存request中的参数，达到redirect传递参数的。

整个redirect的参数通过FlashMap传递的过程分三步：

1）在处理器中将需要传递的参数设置到outputFlashMap中，设置办法有：

@RequestMapping(value = "/submit",method = RequestMethod.POST)
        public String submit(RedirectAttributes attributes){
            //方式一存值
            ((FlashMap)((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest().
                    getAttribute(DispatcherServlet.OUTPUT_FLASH_MAP_ATTRIBUTE)).put("name","vison");
            //方式二存值
            attributes.addFlashAttribute("ordersId","XXX");
    
            return "redirect:showorders";
        }

2）在RedirectView的renderMergedOutputModel方法中调用FlashMapManager的saveOutputFlashMap方法将outputFlashMap的参数设置到Session中

3）请求redirect后DispatcherServlet的doService会调用FlashMapManager的retrieveAndUpdate方法从Session中获取inputFlashMap并设置到Request的属性中备用，同时从Session中删除。