Spring MVC @EnableWebMvc 流程

接上篇：https://www.cnblogs.com/jhxxb/p/13598074.html

@EnableWebMvc

使用 @EnableWebMvc 和不使用它有一个非常非常重要的区别：

使用 @EnableWebMvc 原来是依托于这个 WebMvcConfigurationSupport 配置类向容器中注入了对应的 Bean，所以它们都是交给了 Spring 管理的（所以可以 @Autowired 它们）

但是，但是，但是（重说三），若是走了 Spring 它自己去读取配置文件走默认值，它的 Bean 是没有交给 Spring 管理的，没有交给 Spring 管理的

它是这样创建的：context.getAutowireCapableBeanFactory().createBean(clazz)，它创建出来的 Bean 都不会交给 Spring 管理

注意 CreateBean 和 CrateBean 的不同：https://blog.csdn.net/f641385712/article/details/88651128

源码

从 initStrategies 方法开始

public class DispatcherServlet extends FrameworkServlet {
    /**
     * HttpServletBean 直接继承自 java 的 HttpServlet，其作用是将 Servlet 中配置的参数设置到相应的 Bean 属性上
     * FrameworkServlet 直接继承自 HttpServletBean，初始化了 WebApplicationContext
     * DispatcherServlet 直接继承自 FrameworkServlet，初始化了自身的 9 个组件
     */
    @Override
    protected void onRefresh(ApplicationContext context) {
        initStrategies(context);
    }

    /**
     * 子类若有需要，可以复写此方法，去初始化自己的其余组件（比如要和它集成等等）
     */
    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);

        // 下面是复数，有 s
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }

九大组件初始化

文件上传

public class DispatcherServlet extends FrameworkServlet {
    private void initMultipartResolver(ApplicationContext context) {
        try {
            // 若我们向容器里配置了此 Bean 就有，否则默认是不支持文件上传的
            // 备注：注意配置这些配型 Bean 的名称，都是有固定值的，必须保证一样，否则配置将不生效。下同
            this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
            if (logger.isTraceEnabled()) {
                logger.trace("Detected " + this.multipartResolver);
            } else if (logger.isDebugEnabled()) {
                logger.debug("Detected " + this.multipartResolver.getClass().getSimpleName());
            }
        } catch (NoSuchBeanDefinitionException ex) {
            // Default is no multipart resolver.
            this.multipartResolver = null;
            if (logger.isTraceEnabled()) {
                logger.trace("No MultipartResolver '" + MULTIPART_RESOLVER_BEAN_NAME + "' declared");
            }
        }
    }

看 MultipartResolver 接口

public interface MultipartResolver {
    /**
     * 当收到请求时 DispatcherServlet#checkMultipart() 方法会调用 MultipartResolver#isMultipart() 方法判断请求中是否包含文件。
     * 如果请求数据中包含文件，则调用 MultipartResolver#resolveMultipart() 方法对请求的数据进行解析。
     * 然后将文件数据解析成 MultipartFile 并封装在 MultipartHttpServletRequest(继承了 HttpServletRequest) 对象中，最后传递给 Controller
     */
    boolean isMultipart(HttpServletRequest request);
    MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException;
    void cleanupMultipart(MultipartHttpServletRequest request);
}

CommonsMultipartResolver 使用 commons Fileupload 来处理 multipart 请求，所以在使用时，必须要引入相应的 jar 包

StandardServletMultipartResolver 是基于 Servlet 3.0来处理 multipart 请求的(基于request.getParts()方法)，使用支持 Servlet 3.0 的容器

不一样的是，配置 StandardServletMultipartResolver 这个 Bean 的时候，它的初始化参数都在 web.xml 的 <multipart-config> 里面配置

<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <multipart-config>
        <location>D:/</location>
        <!--上传文件最大 2M-->
        <max-file-size>2097152</max-file-size>
        <!--整个请求上传文件最大 4M-->
        <max-request-size>4194304</max-request-size>
    </multipart-config>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

LocaleResolver

public class DispatcherServlet extends FrameworkServlet {
    private void initLocaleResolver(ApplicationContext context) {
        try {
            // 若自己没有配置 LocaleResolver，会调用 getDefaultStrategy 去获取默认的处理器：
            // 默认处理器在 DispatcherServlet.properties 这个文件里配置了
            this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);
            if (logger.isTraceEnabled()) {
                logger.trace("Detected " + this.localeResolver);
            } else if (logger.isDebugEnabled()) {
                logger.debug("Detected " + this.localeResolver.getClass().getSimpleName());
            }
        } catch (NoSuchBeanDefinitionException ex) {
            // We need to use the default.
            this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No LocaleResolver '" + LOCALE_RESOLVER_BEAN_NAME + "': using default [" + this.localeResolver.getClass().getSimpleName() + "]");
            }
        }
    }

DispatcherServlet.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

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
	org.springframework.web.servlet.function.support.RouterFunctionMapping

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,\
	org.springframework.web.servlet.function.support.HandlerFunctionAdapter


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

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

看 LocaleResolver 接口

public interface LocaleResolver {
    /**
     * 根据 request 对象根据指定的方式获取一个 Locale，如果没有获取到，则使用用户指定的默认 Locale
     */
    Locale resolveLocale(HttpServletRequest request);

    /**
     * 用于实现 Locale 的切换。比如 SessionLocaleResolver 获取 Locale 的方式是从 session 中读取，但如果用
     * 户想要切换其展示的样式(由英文切换为中文)，那么这里的 setLocale() 方法就提供了这样一种可能
     */
    void setLocale(HttpServletRequest request, @Nullable HttpServletResponse response, @Nullable Locale locale);
}

对于 LocaleResolver，其主要作用在于根据不同的用户区域展示不同的视图，而用户的区域也称为 Locale，该信息是可以由前端直接获取的。通过这种方式，可以实现一种国际化的目的，比如中国一个视图，外国一个视图。

解析视图需要两个参数：一是视图名，另一个是 Locale。视图名是处理器返回的，Locale 是从哪里来的？这就是 LocaleResolver 要做的事

FixedLocaleResolver：在声明该 resolver 时，需要指定一个默认的 Locale，在进行 Locale 获取时，始终返回该 Locale，并且调用其 setLocale() 方法也无法改变其 Locale。
CookieLocaleResolver：读取 Locale 的方式是在 session 中通过 Cookie 来获取其指定的 Locale，如果修改了 Cookie 的值，页面视图也会同步切换。
SessionLocaleResolver：会将 Locale 信息存储在 session 中，如果用户想要修改 Locale 信息，只要修改 session 中对应属性的值即可。
AcceptHeaderLocaleResolver：其会通过用户请求中名称为 Accept-Language 的 header 来获取 Locale 信息，如果想要修改展示的视图，只需要修改该 header 信息即可。

对于 Locale 的切换，Spring 是通过拦截器来实现的，其提供了一个 LocaleChangeInterceptor，若要生效，这个 Bean 需要自己配置

ThemeResolver 主题

public class DispatcherServlet extends FrameworkServlet {
    private void initThemeResolver(ApplicationContext context) {
        try {
            this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class);
            if (logger.isTraceEnabled()) {
                logger.trace("Detected " + this.themeResolver);
            } else if (logger.isDebugEnabled()) {
                logger.debug("Detected " + this.themeResolver.getClass().getSimpleName());
            }
        } catch (NoSuchBeanDefinitionException ex) {
            // We need to use the default.
            this.themeResolver = getDefaultStrategy(context, ThemeResolver.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No ThemeResolver '" + THEME_RESOLVER_BEAN_NAME + "': using default [" + this.themeResolver.getClass().getSimpleName() + "]");
            }
        }
    }

ThemeResolver 接口

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

主题就是系统的整体样式或风格，可通过 Spring MVC 框架提供的主题（theme）设置应用的整体样式风格，提高用户体验。Spring MVC 的主题就是一些静态资源的集合，即包括样式及图片，用来控制应用的视觉风格。

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

主题使用得太少了，特别现在前后端分离了。

HandlerMapping

public class DispatcherServlet extends FrameworkServlet {
    // DispatcherServlet 初始化 HandlerMappings
    // Spring 中的 DispatcherServlet 允许有多个
    // 默认情况下 @RequestMapping 和 BeanNameUrl 的方式都是被支持的
    private void initHandlerMappings(ApplicationContext context) {
        this.handlerMappings = null;

        // detectAllHandlerMappings 该属性默认为 true，表示会去容器内找所有的 HandlerMapping 类型的定义信息
        // 若想改为 false，可以调用它的 setDetectAllHandlerMappings() 自行设置（绝大部分情况没必要）
        if (this.detectAllHandlerMappings) {
            // 这里注意：若你没有标注注解`@EnableWebMvc`，那么这里找的结果是空的
            // 若你标注了此注解，这个注解就会默认向容器内注入两个 HandlerMapping：RequestMappingHandlerMapping 和 BeanNameUrlHandlerMapping
            Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerMappings = new ArrayList<>(matchingBeans.values());
                // 多个的话还需要进行一次排序
                AnnotationAwareOrderComparator.sort(this.handlerMappings);
            }
        } else {
            // 不全部查找，那就只找一个名字为`handlerMapping`的 HandlerMapping 实现精准控制
            // 绝大多数情况下，我们并不需要这么做
            try {
                HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
                this.handlerMappings = Collections.singletonList(hm);
            } catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerMapping later.
            }
        }

        // 若一个都没找到自定义的，回滚到 Spring 的兜底策略，它会向容器注册两个：RequestMappingHandlerMapping 和 BeanNameUrlHandlerMapping
        if (this.handlerMappings == null) {
            this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerMappings declared for servlet '" + getServletName() + "': using default strategies from DispatcherServlet.properties");
            }
        }
    }

用来查找 Handler，在 SpringMVC 中会有很多请求，每个请求都需要一个 Handler 处理，具体接收到一个请求之后使用哪个 Handler 进行处理？这就是 HandlerMapping 需要做的事

作用是根据当前请求的找到对应的 Handler，并将 Handler（执行程序）与一堆 HandlerInterceptor（拦截器，也是它来处理的）封装到 HandlerExecutionChain 对象中。返回给中央调度器

HandlerMapping 可以有多个，开启了 @EnableMvc 注解后，就不读取 DispatcherServlet.properties 中的默认值了

HandlerAdapter

public interface HandlerAdapter {
    /**
     * 当前 HandlerAdapter 是否支持这个 Handler
     */
    boolean supports(Object handler);

    /**
     * 调用 handle 处理这个请求，然后返回 ModelAndView 对象
     */
    @Nullable
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
    long getLastModified(HttpServletRequest request, Object handler);
}

因为 SpringMVC 中的 Handler 可以是任意的形式，只要能处理请求就 ok，但是 Servlet 需要的处理方法的结构却是固定的，都是以 request 和 response 为参数的方法。如何让固定的 Servlet 处理方法调用灵活的 Handler 来进行处理？这就是 HandlerAdapter 要做的事情。

Handler 是用来干活的工具，HandlerMapping 用于根据需要干的活找到相应的工具，HandlerAdapter 是使用工具干活的人

HandlerAdapter 可以有多个

HandlerExceptionResolver

其它组件都是用来干活的。在干活的过程中难免会出现问题，出问题后怎么办呢？这就需要有一个专门的角色对异常情况进行处理，在 SpringMVC 中就是 HandlerExceptionResolver。具体来说，此组件的作用是根据异常设置 ModelAndView，之后再交给 render 方法进行渲染。

以前我们可以用 web.xml 的 <error-page> 标签来捕获状态码 500、400 的异常，但是这个已经 out 了，现在全局的异常都可以交给 HandlerExceptionResolver 去捕获处理

这个接口捕获的是所有异常，而 Spring 官方推荐的是使用 @ExceptionHandler 注解去捕获固定的异常

这个类建议交给 Spring 子容器管理（可以多实现），因为它就像一个特殊的 Controller

RequestToViewNameTranslator

Spring MVC 是通过 ViewName 来找到对应的视图的，而此接口的作用就是从 request 中获取 viewName。

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

只有一个默认实现

public class DefaultRequestToViewNameTranslator implements RequestToViewNameTranslator {
    private static final String SLASH = "/";

    private String prefix = "";

    private String suffix = "";

    private String separator = SLASH;

    private boolean stripLeadingSlash = true;

    private boolean stripTrailingSlash = true;

    private boolean stripExtension = true;

    private UrlPathHelper urlPathHelper = new UrlPathHelper();

    @Override
    public String getViewName(HttpServletRequest request) {
        // 调用 UrlPathHelper 的 getLookupPathForRequest 方法获取一个 looup 路径
        String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, HandlerMapping.LOOKUP_PATH);
        return (this.prefix + transformPath(lookupPath) + this.suffix);
    }

    @Nullable
    protected String transformPath(String lookupPath) { // 对获取的路径字符串再做个简单处理
        String path = lookupPath;
        if (this.stripLeadingSlash && path.startsWith(SLASH)) {
            path = path.substring(1);
        }
        if (this.stripTrailingSlash && path.endsWith(SLASH)) {
            path = path.substring(0, path.length() - 1);
        }
        if (this.stripExtension) {
            path = StringUtils.stripFilenameExtension(path);
        }
        if (!SLASH.equals(this.separator)) {
            path = StringUtils.replace(path, SLASH, this.separator);
        }
        return path;
    }

ViewResolver

public class DispatcherServlet extends FrameworkServlet {
    private void initViewResolvers(ApplicationContext context) {
        this.viewResolvers = null;

        // detectAllViewResolvers 默认为 true，会去容器里找到所有的视图解析器的 Bean。我们可以通过 init-param 配置为 false，来关闭这个（不建议）
        // 另外，需要注意的是，我们发现虽然我们没有自己注册 Bean 进去，但是在 matchingBeans 这一步时，已经有值了，怎么回事呢？
        // 继续扣源码发现：当有 @EnableWebMvc 这个注解时，会导入 DelegatingWebMvcConfiguration，而它是 WebMvcConfigurationSupport 的子类，
        // 而 WebMvcConfigurationSupport 它默认配置注册了很多东西到 MVC 的配置中，所以我们才会发现 matchingBeans 有值了。
        // 去掉 @EnableWebMvc 后，从容器里就拿不出 Bean 了，只能读取配置文件里的默认值了
        if (this.detectAllViewResolvers) {
            // 如果detectAllViewResolvers为true，那么就会去容器里找所有的（包含所有祖先上下文）容器里的所有的此接口下的此类的bean，最后都放进去（可以有多个嘛）
            Map<String, ViewResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.viewResolvers = new ArrayList<>(matchingBeans.values());
                // 保持排序性
                AnnotationAwareOrderComparator.sort(this.viewResolvers);
            }
        } else {
            try {
                ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
                this.viewResolvers = Collections.singletonList(vr); // 使用 singletonList 是为了性能考虑，节约内存
            } catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default ViewResolver later.
            }
        }

        // 若还为 null，就采用默认配置的视图解析器 InternalResourceViewResolver
        if (this.viewResolvers == null) {
            this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No ViewResolvers declared for servlet '" + getServletName() + "': using default strategies from DispatcherServlet.properties");
            }
        }
    }

用来将 String 类型的视图名和 Locale 解析为 View 类型的视图。View 是用来渲染页面的，也就是将程序返回的参数填入模板里，生成 html（也可能是其它类型）文件。这里就有两个关键问题：使用哪个模板？用什么技术（规则）填入参数？这其实是 ViewResolver 主要要做的工作，ViewResolver 需要找到渲染所用的模板和所用的技术（也就是视图的类型）进行渲染，具体的渲染过程则交由不同的视图自己完成。

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

AbstractCachingViewResolver：基于缓存的抽象视图解析器
UrlBasedViewResolver：实现了缓存提供了prefix、suffix 拼接的 url 视图解析器
InternalResourceViewResolver：基于url 的内部资源视图解析器
XmlViewResolver：基于 xml 的缓存视图解析器
BeanNameViewResolver：beanName 来自容器，并且不支持缓存
ResourceBundleViewResolver：这个有点复杂
FreeMarkerViewResolver：基于 url，但会解析成特定的 view，实现类也非常的多，在 Spring MVC 里是一个非常重要的概念（比如什么时候返回页面，什么时候返回 JSON）
ViewResolverComposite 简单来说就是使用简单的 List 来保存你配置使用的视图解析器

ViewResolvers 可以有多个

FlashMapManager

用来管理 FlashMap 的，FlashMap 主要用在 redirect 中传递参数。

抽象类采用模板模式定义整个流程，具体实现类用 SessionFlashMapManager 通过模板方法提供了具体操作 FlashMap 的功能。

功能说明：

实际的 Session 中保存的 FlashMap 是 List 类型，也就是说一个 Session 可以保存多个 FlashMap，一个 FlashMap 保存着一套 Redirect 转发所传递的参数
FlashMap 继承自 HashMap，除了用于 HashMap 的功能和设置有效期，还可以保存 Redirect 后的目标路径和通过 url 传递的参数，这两项内容主要用来从 Session 保存的多个 FlashMap 中查找当前的 FalshMap

https://blog.csdn.net/f641385712/article/details/87934909

https://www.bilibili.com/video/BV19K4y1L7MT

posted @ 2022-01-19 20:22 江湖小小白阅读(629) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

江湖小小白