概念

  • spring实现web模块，简化web开发
  • SpringMVC == spring模块划分中的Web模块
  • SpringMVC思想是有一个前端控制器能拦截所有请求，并智能派发；
    • 这个前端控制器是一个servlet，应该在web.xml中配置；

运行流程

  1. 客户端点击链接会发送 http://localhost:8080/index.jsp
  2. 来到tomcat服务器
  3. SpringMVC的前端控制器收到请求
  4. 看请求地址和哪个@RequestMapping注解匹配，来找到哪个Controller的哪个方法
  5. 前端控制器找到目标Controller和目标方法，直接利用反射执行目标方法
  6. 返回值就是要去的页面
  7. 拿到返回值后，使用视图解析器拼串得到完整的页面地址
  8. 前端控制器转发到页面

web.xml

DispatcherServlet

  1. <servlet>
  2.     <servlet-name>springDispatcherServlet</servlet-name>
  3.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>    
  4.     <init-param>
  5.         <!--contextConfigLocation：指定SpringMVC配置文件位置-->
  6.           <param-name>contextConfigLocation</param-name>
  7.           <param-value>classpath:springmvc.xml</param-value>
  8.     </init-param>
  9.     <!--
  10.     servlet启动加载，servlet原本是第一次访问创建对象；
  11.     load-on-startup：服务器启动的时候创建对象，值越小以优先级越高，越先创建对象；
  12.     -->
  13.     <load-on-startup>1</load-on-startup>
  14. </servlet>
  16. <servlet-mapping>
  17.     <servlet-name>springDispatcherServlet</servlet-name>
  18.     <!--
  19.     /* 和 / 都是拦截所有请求
  20.     /* 的范围更大，会拦截到jsp页面：*.jsp；而 / 不会
  21.     -->
  22.     <url-pattern>/</url-pattern>
  23. </servlet-mapping>

若在web.xml中不指定spring的配置文件的位置

  1. <init-param>
  2.       <!--contextConfigLocation：指定SpringMVC配置文件位置-->
  3.       <param-name>contextConfigLocation</param-name>
  4.       <param-value>classpath:springmvc.xml</param-value>
  5. </init-param>

默认去找

  1. /WEB-INF/springDispatcherServlet-servlet.xml

即

  1. <servlet-name>springDispatcherServlet</servlet-name>
  1. /WEB-INF/<servlet-name>-servlet.xml

服务器的大web.xml中有一个DefaultServlet是url-pattern = /

我们的配置中前端控制器url-pattern = /

  1. <servlet-mapping>
  2.     <servlet-name>springDispatcherServlet</servlet-name>
  3.     <!--
  4.     /* 和 / 都是拦截所有请求
  5.     /* 的范围更大，会拦截到jsp页面：*.jsp；而 / 不会
  6.     -->
  7.     <url-pattern>/</url-pattern>
  8. </servlet-mapping>

处理 *.jsp 是tomcat做的事；所有项目的小web.xml都是继承于大web.xml

Defaultservlet是Tomcat中处理静态资源的

  • 除过jsp，和servlet外剩下的都是静态资源
  • index.html：静态资源，tomcat就会在服务器下找到这个资源并返回;·
  • 我们前端控制器的/禁用了tomcat服务器中的Defaultservlet
    • 所以静态资源会来到DispathcerServlet，找哪个方法的@ReuqestMapping是index.html
    • 必然没有，所以无法访问
  • jsp能访问的原因是，tomcat中的JspServlet的url-pattern是 .jsp .jspx，而DispatcherServlet没有覆盖这个配置

若DispatcherServlet配置 /*，则拦截所有请求

所以应当写 / ，也可以迎合REST风格

@RequestMapping

基本属性

method：限定请求方式

  • method= RequestMethod.POST：只接受这种类型的请求；默认是什么都可以
  • 不是规定的方式报错：4xx，客户端错误

params：支持简单的表达式

  • param1：表示请求必须包含名为param1的请求参数
    • params={“username”}
    • 发送请求必须包含名为username的请求参数
    • 没带404
  • !param1：表示请求必须不包含名为param1的请求参数
  • param1 = xxx：表示请求必须包含名为param1的请求参数且值为xxx
  • param1 != xxx：表示请求必须包含名为param1的请求参数且值不为xxx
  • 复杂表达式：params={“username=123”, “pwd”, “!age”}
    • 请求的参数必须包含username且值为123，必须包含pwd，不许不包含age

headers：支持简单的表达式；规定请求头

User-Agent：浏览器信息

谷歌User-Agent：
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36

火狐User-Agent：
Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:75.0) Gecko/20100101 Firefox/75.0

只允许火狐访问的配置

  1. headers = {"User-Agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:75.0) Gecko/20100101 Firefox/75.0"}

consumes：

只接收内容类型为xxx的请求，即规定请求头中的Content-Type

produces：

告诉浏览器返回的内容类型是xxx，即给响应头中加入Content-Type:text/html;charset=utf-8

Ant风格的URL

  1. RequestMapping的模糊匹配功能
  3. URL地址可以写模糊的通配符：
  4.  ? : 能替代任意一个字符
  5.  * : 能替代任意多个字符，和一层路径
  6.  ** : 能替代多层路径

@PathVariable

路径上的占位符

语法：{变量名}

只能占一层路径

  1. /**
  2.   * /user/{dynamicParam}
  3.   */
  4. @RequestMapping("/user/{name}")
  5. public String pathVariableTest(@PathVariable("name") String name){
  6.     System.out.println("路径上的占位符为：" + name);
  7.     System.out.println("pathVariableTest...");
  8.     return "success";
  9. }

REST

REST：即Representational State Transfer（资源/表现层状态转化)

  • 是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便所以正得到越来越多网站的采用。
  • 资源(Resources)：网络上的一个实体，或者说是网络上的一个具体信息。它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的存在。可以用一个URI(统一资源定位符)指向它，每种资源对应一个特定的URI。要获取这个资源，访问它的URI就可以，因此URI即为每一个资源的独一无二的识别符。
  • 表现层(Representation)：把资源具体呈现出来的形式，叫做它的表现层
    • 比如，文本可以用txt格式表现，也可以用HTML格式、XML格式、JSON格式表现，甚至可以采用二进制格式。
  • 状态转化(State Transfer)：每发出一个请求，就代表了客户端和服务器的一次交互过程。HTTP协议，是一个无状态协议，即所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生“状态转化”(State Transfer)。而这种转化是建立在表现层之上的，所以就是“表现层状态转化”。
    • 具体说，就是HTTP协议里面，四个表示操作方式的动词：GET、POST、PUT、 DELETE
    • 它们分别对应四种基本操作：
      GET用来获取资源，POST用来新建资源，PUT用来更新资源， DELETE用来删除资源。

REST推荐url写法：/资源名/资源标识符

例：user/1

然后根据HTTP协议中的操作区分请求的CRUD

SpringMVC中的Filter，可以把普通的请求转化为规定形式的请求

  1. <filter>
  2.     <filter-name>HiddenHttpMethodFilter</filter-name>
  3.     <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  4. </filter>
  5. <filter-mapping>
  6.     <filter-name>HiddenHttpMethodFilter</filter-name>
  7.     <url-pattern>/*</url-pattern>
  8. </filter-mapping>
  1. 创建一个post类型的表单
  2. 表单项中携带一个_method的参数，此值即为DELETE、PUT

HiddenHttpMethodFilter

  1. public static final String DEFAULT_METHOD_PARAM = "_method";
  3. private String methodParam = DEFAULT_METHOD_PARAM;
  5. @Override
  6. protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
  7.       throws ServletException, IOException {
  9.    HttpServletRequest requestToUse = request;
  10.    //若表单是POST
  11.    if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {
  12.       //获取表单上_method带来的值
  13.       String paramValue = request.getParameter(this.methodParam);
  14.       //_method有值
  15.       if (StringUtils.hasLength(paramValue)) {
  16.          //将_method转换为大写
  17.          String method = paramValue.toUpperCase(Locale.ENGLISH);
  18.          if (ALLOWED_METHODS.contains(method)) {
  19.             //重写request.getMethod();
  20.             requestToUse = new HttpMethodRequestWrapper(request, method);
  21.          }
  22.       }
  23.    }
  25.    filterChain.doFilter(requestToUse, response);
  26. }

SpringMVC获取请求带来的信息

原生携带请求参数：<a href=”handler01?name=jjj>handler01
给方法的形参列表中写上和请求参数名相同的变量，此变量即可接收请求参数

  • @RequestParam：获取请求参数；参数默认必须携带
    • 例： ```java @RequestParam(“username”) String name //即： name = request.getParameter(“username);

value()：指定要获取的参数的key required()：参数是否必须携带 defaultValue()：若没携带的默认值

  2. - @RequestHeader：获取请求头中的某个key值
  3.    - 原生：
  4. ```java
  5. request.getHeader("User-Agent")
  • 例：
    1. @RequestHeader("User-Agent") String userAgent
    2. //即：
    3. userAgent = request.getHeader("User-Agent")

  • @CookieValue：获取某个cookie的值

    • 原生：

      1. Cookie[] cookies = request.getCookies();
      2. for(Cookie c : cookies){
      3. if("JSESSIONID".equals(c.getName())){
      4.    String cv = c.getValue();
      5. }
      6. }

    • 例：

      1. @CookieValue("JSESSIONID") String jsessionid

SpringMVC可以直接在参数上写原生API

  1. HttpServletRequest
  2. HttpServletResponse
  3. HttpSession
  5. java.security.Principal
  7. Locale：国际化有关的区域信息对象
  9. InputStream
  10.      ServletInputStream inputStream = request.getInputStream();
  12. OutputStream
  13.      ServletOutputStream outputStream = response.getOutputStream();
  15. Reader
  16.      BufferedReader reader = request.getReader();
  18. Writer
  19.      PrintWriter writer = response.getWriter();
  1. @RequestMapping(value = "/nativeAPI")
  2. public String nativeAPI(HttpSession httpSession, 
  3.                         HttpServletRequest request, 
  4.                         HttpServletResponse response){
  5.         httpSession.setAttribute("session", "session域");
  6.         request.setAttribute("request", "请求域");
  7.         return "success";
  8.     }

提交的数据可能有乱码

  • 请求乱码：

    • GET：修改server.xml，添加URIEncoding=”UTF-8”

      1. <Connector port="8080" protocol="HTTP/1.1"
      2.       URIEncoding="UTF-8"
      3.       connectionTimeout="20000"
      4.       redirectPort="8443" useBodyEncodingForURI="true"/>

    • POST：在第一次获取请求之前设置

      1. request.setCharacterEncoding("UTF-8");

  • 响应乱码：

    1. response.setContentType("text/html;charset=utf-8);
    • 写一个filter；SpringMVC中有这个filter
      • CharacterEncodingFilter
        1. <filter>
        2. <filter-name>CharacterEncodingFilter</filter-name>
        3. <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        4. <init-param>
        5. <param-name>encoding</param-name>
        6. <param-value>UTF-8</param-value>
        7. </init-param>
        8. <init-param>
        9. <param-name>forceEncoding</param-name>
        10. <param-value>true</param-value>
        11. </init-param>
        12. </filter>
        13. <filter-mapping>
        14. <filter-name>CharacterEncodingFilter</filter-name>
        15. <url-pattern>/*</url-pattern>
        16. </filter-mapping>

数据输出

BindingAwareModelMap(隐含模型)

SpringMVC除过使用原生的request和session，还能将数据带给页面的办法

  1. 在方法形参表中传入Map、Model或ModelMap：
    • 这些参数里保存的数据都会放在请求域中，可以再页面获取
    • org.springframework.validation.support.BindingAwareModelMap
    • BindingAwareModelMap中保存的数据都会放在请求域中
      1. Map(interface(jdk))     Model(interface(spring))
      2.     ↓                 |
      3. ModelMap(class)         |
      4.         ↓            ↓
      5.         ExtendedModelMap
      6.                 ↓
      7.         BindingAwareModelMap
      ```java @RequestMapping(“/handle01”) public String handle01(Map map){ map.put(“key”, “value1”); System.out.println(map.getClass()); System.out.println(“handle01…”); return “output”; }

@RequestMapping(“/handle02”) public String handle02(Model model){ model.addAttribute(“key”, “value2”); System.out.println(model.getClass()); System.out.println(“handle02…”); return “output”; }

@RequestMapping(“/handle03”) public String handle03(ModelMap modelMap){ modelMap.addAttribute(“key”, “value3”); System.out.println(modelMap.getClass()); System.out.println(“handle03…”); return “output”; }

  2. 2. 方法的返回值可以变为ModelAndView
  3.    - 既包含视图信息(页面地址)，也包含模型数据(给页面带的数据)，数据放在请求域中
  5. ```java
  6. @RequestMapping("/handle04")
  7. public ModelAndView handle04(){
  8.     ModelAndView mv = new ModelAndView("output");
  9.     mv.addObject("key", "value4");
  10.     System.out.println("handle04...");
  11.     return mv;
  12. }

ModelAttribute

执行全更新的sql时会有风险：

  • 例：修改user
  • 问题描述：若表单中未填入money，则SpringMVC自动创建的User对象的money将为null，此时会覆盖掉数据库中原先的money字段，本意是不修改money，但执行全更新sql后会覆盖掉原字段
  • 解决方法：执行更新sql时，SpringMVC不创建User对象，而是从数据库中取出相应id的一个User对象，且携带数据库中的值；然后根据表单中携带的数据决定是否进行数据更新：携带了就覆盖，没携带就保持原值

源码

SpringMVC - 图1

doDispatch()细节

  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  2.    HttpServletRequest processedRequest = request;
  3.    HandlerExecutionChain mappedHandler = null;
  4.    boolean multipartRequestParsed = false;
  6.    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  8.    try {
  9.       ModelAndView mv = null;
  10.       Exception dispatchException = null;
  12.       try {
  13.          //1.检查是否是文件上传请求
  14.          processedRequest = checkMultipart(request);
  15.          multipartRequestParsed = (processedRequest != request);
  17.          // Determine handler for the current request.
  18.          //2.根据当前其请求找到能处理的Controller类；拿到执行链
  19.          mappedHandler = getHandler(processedRequest);
  20.          //3.若没有找到可以处理的Controller类，则抛异常/404
  21.          if (mappedHandler == null) {
  22.             noHandlerFound(processedRequest, response);
  23.             return;
  24.          }
  26.          // Determine handler adapter for the current request.
  27.          //4.拿到能执行这个Controller的所有方法的适配器
  28.          //(反射工具RequestMappingHandlerAdapter)
  29.          HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  31.          // Process last-modified header, if supported by the handler.
  32.          //5.获取请求方式
  33.          String method = request.getMethod();
  34.          boolean isGet = "GET".equals(method);
  35.          if (isGet || "HEAD".equals(method)) {
  36.             long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
  37.             if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
  38.                return;
  39.             }
  40.          }
  41.         //执行所有拦截器的preHandle
  42.          if (!mappedHandler.applyPreHandle(processedRequest, response)) {
  43.             return;
  44.          }
  46.          // Actually invoke the handler.
  47.          //*6.使用适配器执行处理(handler)/控制(controller)器中的方法，方法返回值作为视图名，放入一个ModelAndView中
  48.          mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  50.          if (asyncManager.isConcurrentHandlingStarted()) {
  51.             return;
  52.          }
  54.          //7.若返回的ModelAndView没有视图名，则使用默认视图名
  55.          applyDefaultViewName(processedRequest, mv);
  56.          mappedHandler.applyPostHandle(processedRequest, response, mv);
  57.       }
  58.       catch (Exception ex) {
  59.          dispatchException = ex;
  60.       }
  61.       catch (Throwable err) {
  62.          // As of 4.3, we're processing Errors thrown from handler methods as well,
  63.          // making them available for @ExceptionHandler methods and other scenarios.
  64.          dispatchException = new NestedServletException("Handler dispatch failed", err);
  65.       }
  66.       //*8.将mv转发到目标页面
  67.       processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
  68.    }
  69.    catch (Exception ex) {
  70.       triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
  71.    }
  72.    catch (Throwable err) {
  73.       triggerAfterCompletion(processedRequest, response, mappedHandler,
  74.             new NestedServletException("Handler processing failed", err));
  75.    }
  76.    finally {
  77.       if (asyncManager.isConcurrentHandlingStarted()) {
  78.          // Instead of postHandle and afterCompletion
  79.          if (mappedHandler != null) {
  80.             mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
  81.          }
  82.       }
  83.       else {
  84.          // Clean up any resources used by a multipart request.
  85.          if (multipartRequestParsed) {
  86.             cleanupMultipart(processedRequest);
  87.          }
  88.       }
  89.    }
  90. }

步骤：

  1. DispatcherServlet收到请求
  2. 调用doDispatch()方法
    1. getHandler()：根据当前请求地址找到能处理的Controller
    2. getHandlerAdapter()：根据当前Controller类获取能执行Controller类中方法的适配器
    3. 使用适配器(RequestMappingHandlerAdapter)执行目标方法
    4. 目标方法执行后返回一个ModelAndView对象mv
    5. 根据mv信息转发到具体的页面，且可以再请求域中取出mv中的数据

getHandler()细节：

getHandler()方法会返回目标Controller类的执行器链(HandlerExecutionChain)

  1. mappedHandler = getHandler(processedRequest);

SpringMVC - 图2

getHandler()内部：

  1. protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
  2.    if (this.handlerMappings != null) {
  3.       for (HandlerMapping mapping : this.handlerMappings) {
  4.          HandlerExecutionChain handler = mapping.getHandler(request);
  5.          if (handler != null) {
  6.             return handler;
  7.          }
  8.       }
  9.    }
  10.    return null;
  11. }

handlerMappings(处理器映射)：保存了每一个Controller能处理哪些请求的方法的映射信息

SpringMVC - 图3

getHandlerAdapter()细节：

通过目标Controller类的执行器链(HandlerExecutionChain)mappedHandler获得适配器ha

  1. HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  1. protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
  2.    if (this.handlerAdapters != null) {
  3.       for (HandlerAdapter adapter : this.handlerAdapters) {
  4.          if (adapter.supports(handler)) {
  5.             return adapter;
  6.          }
  7.       }
  8.    }
  9.    throw new ServletException("No adapter for handler [" + handler +
  10.          "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
  11. }

DispatcherServlet有几个引用类型的属性：SpringMVC九大组件

SpringMVC在工作的时候，关键位置都是由这些组建完成

共同点：全部都是接口；接口就是规范；提供了强大的扩展性

  1. /** MultipartResolver used by this servlet. */
  2. //文件上传解析器
  3. @Nullable
  4. private MultipartResolver multipartResolver;
  6. /** LocaleResolver used by this servlet. */
  7. //区域信息解析器，和国际化有关
  8. @Nullable
  9. private LocaleResolver localeResolver;
  11. /** ThemeResolver used by this servlet. */
  12. //主题解析器，强大的主体效果更换(一般不用)
  13. @Nullable
  14. private ThemeResolver themeResolver;
  16. /** List of HandlerMappings used by this servlet. */
  17. //handler映射信息
  18. @Nullable
  19. private List<HandlerMapping> handlerMappings;
  21. /** List of HandlerAdapters used by this servlet. */
  22. //handler适配器
  23. @Nullable
  24. private List<HandlerAdapter> handlerAdapters;
  26. /** List of HandlerExceptionResolvers used by this servlet. */
  27. //handler异常解析器
  28. @Nullable
  29. private List<HandlerExceptionResolver> handlerExceptionResolvers;
  31. /** RequestToViewNameTranslator used by this servlet. */
  32. //请求-视图名转换器
  33. @Nullable
  34. private RequestToViewNameTranslator viewNameTranslator;
  36. /** FlashMapManager used by this servlet. */
  37. //SprngMVC中允许重定向携带数据的功能
  38. @Nullable
  39. private FlashMapManager flashMapManager;
  41. /** List of ViewResolvers used by this servlet. */
  42. //视图解析器
  43. @Nullable
  44. private List<ViewResolver> viewResolvers;

九大组件的初始化

  1. /**
  2.   * This implementation calls {@link #initStrategies}.
  3.   */
  4. @Override
  5. protected void onRefresh(ApplicationContext context) {
  6.     initStrategies(context);
  7. }
  9. /**
  10.   * Initialize the strategy objects that this servlet uses.
  11.   * <p>May be overridden in subclasses in order to initialize further strategy objects.
  12.   */
  13. protected void initStrategies(ApplicationContext context) {
  14.     initMultipartResolver(context);
  15.     initLocaleResolver(context);
  16.     initThemeResolver(context);
  17.     initHandlerMappings(context);
  18.     initHandlerAdapters(context);
  19.     initHandlerExceptionResolvers(context);
  20.     initRequestToViewNameTranslator(context);
  21.     initViewResolvers(context);
  22.     initFlashMapManager(context);
  23. }

可以在web.xml中修改DispatcherServlet中的某些属性

  1. <init-param>
  2.     <param-name>detectAllHandlerMappings</param-name>
  3.     <param-value>false</param-value>
  4. </init-param>

初始化HandlerMapping

  1. /**
  2.   * Initialize the HandlerMappings used by this class.
  3.   * <p>If no HandlerMapping beans are defined in the BeanFactory for this namespace,
  4.   * we default to BeanNameUrlHandlerMapping.
  5.   */
  6. private void initHandlerMappings(ApplicationContext context) {
  7.     this.handlerMappings = null;
  9.     if (this.detectAllHandlerMappings) {
  10.         // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
  11.         Map<String, HandlerMapping> matchingBeans =
  12.             BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
  13.         if (!matchingBeans.isEmpty()) {
  14.             this.handlerMappings = new ArrayList<>(matchingBeans.values());
  15.             // We keep HandlerMappings in sorted order.
  16.             AnnotationAwareOrderComparator.sort(this.handlerMappings);
  17.         }
  18.     }
  19.     else {
  20.         try {
  21.             HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
  22.             this.handlerMappings = Collections.singletonList(hm);
  23.         }
  24.         catch (NoSuchBeanDefinitionException ex) {
  25.             // Ignore, we'll add a default HandlerMapping later.
  26.         }
  27.     }
  29.     // Ensure we have at least one HandlerMapping, by registering
  30.     // a default HandlerMapping if no other mappings are found.
  31.     if (this.handlerMappings == null) {
  32.         this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
  33.         if (logger.isTraceEnabled()) {
  34.             logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
  35.                          "': using default strategies from DispatcherServlet.properties");
  36.         }
  37.     }
  38. }

组件的初始化：

  • 有些组件在容器中使用类型找，有些使用id找
  • 在容器中找这个组件，若没有找到就使用默认配置

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());细节

mav = invokeHandlerMethod(request, response, handlerMethod);

转发forward

  1. @RequestMapping("/hello1")
  2. public String hello1() {
  3.     System.out.println("hello1");
  4.     return "../../hello";
  5. }
  7. /**
  8.   * forward：转发到一个页面
  9.   *      forward:/hello.jsp：转发到当前项目下的hello.jsp
  10.   *      不会使用视图解析器进行拼串
  11.   */
  12. @RequestMapping("/hello2")
  13. public String hello2() {
  14.     System.out.println("hello2");
  15.     return "forward:/hello.jsp";
  16. }
  18. /**
  19.   * forward：多次转发
  20.   */
  21. @RequestMapping("/hello3")
  22. public String hello3() {
  23.     System.out.println("hello3");
  24.     return "forward:hello2";
  25. }

重定向redirect

  1. /**
  2.   * redirect：重定向
  3.   *      原生的Servlet重定向/路径需要加上项目名
  4.   *          response.sendRedirect("/hello.jsp")
  5.   *      SpringMVC会自动为路径拼接项目名
  6.   */
  7. @RequestMapping("/hello4")
  8. public String hello4() {
  9.     System.out.println("hello4");
  10.     return "redirect:/hello.jsp";
  11. }
  13. /**
  14.   * redirect：多次重定向
  15.   */
  16. @RequestMapping("/hello5")
  17. public String hello5() {
  18.     System.out.println("hello5");
  19.     return "redirect:hello4";
  20. }

forward和redirect前缀都不会使用视图解析器拼串

SpringMVC视图解析原理

方法执行后的返回值会作为页面地址参考，转发或重定向到页面

视图解析器可能会进行页面地址的拼串

  1. 去页面的方法

    1. processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

  2. 试图渲染流程：将请求域中的数据在页面展示，页面就是用来渲染模型数据的

  3. 渲染页面

    1. render(mv, request, response);

  4. View与ViewResolver
    ViewResolver的作用：根据视图名(方法的返回值)得到View对象

  5. 如何根据视图名(方法的返回值)得到View对象？

    1. @Nullable
    2. protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
    3.    Locale locale, HttpServletRequest request) throws Exception {
    5. if (this.viewResolvers != null) {
    6.    //遍历所有的ViewResolver
    7.    for (ViewResolver viewResolver : this.viewResolvers) {
    8.       //根据视图名(方法的返回值)得到View对象
    9.       View view = viewResolver.resolveViewName(viewName, locale);
    10.       if (view != null) {
    11.          return view;
    12.       }
    13.    }
    14. }
    15. return null;
    16. }

  6. resolveViewName(viewName, locale);细节：

    1. @Override
    2. @Nullable
    3. public View resolveViewName(String viewName, Locale locale) throws Exception {
    4. if (!isCache()) {
    5.    return createView(viewName, locale);
    6. }
    7. else {
    8.    Object cacheKey = getCacheKey(viewName, locale);
    9.    View view = this.viewAccessCache.get(cacheKey);
    10.    if (view == null) {
    11.       synchronized (this.viewCreationCache) {
    12.          view = this.viewCreationCache.get(cacheKey);
    13.          if (view == null) {
    14.             // Ask the subclass to create the View object.
    15.             //*根据方法的返回值创建View对象
    16.             view = createView(viewName, locale);
    17.             if (view == null && this.cacheUnresolved) {
    18.                view = UNRESOLVED_VIEW;
    19.             }
    20.             if (view != null && this.cacheFilter.filter(view, viewName, locale)) {
    21.                this.viewAccessCache.put(cacheKey, view);
    22.                this.viewCreationCache.put(cacheKey, view);
    23.             }
    24.          }
    25.       }
    26.    }
    27.    else {
    28.       if (logger.isTraceEnabled()) {
    29.          logger.trace(formatKey(cacheKey) + "served from cache");
    30.       }
    31.    }
    32.    return (view != UNRESOLVED_VIEW ? view : null);
    33. }
    34. }

  7. createView(viewName, locale);细节

    1. @Override
    2. protected View createView(String viewName, Locale locale) throws Exception {
    3. // If this resolver is not supposed to handle the given view,
    4. // return null to pass on to the next resolver in the chain.
    5. if (!canHandle(viewName, locale)) {
    6.    return null;
    7. }
    9. // Check for special "redirect:" prefix.
    10. //redirect前缀：创建RedirectView对象
    11. if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
    12.    String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length());
    13.    RedirectView view = new RedirectView(redirectUrl,
    14.          isRedirectContextRelative(), isRedirectHttp10Compatible());
    15.    String[] hosts = getRedirectHosts();
    16.    if (hosts != null) {
    17.       view.setHosts(hosts);
    18.    }
    19.    return applyLifecycleMethods(REDIRECT_URL_PREFIX, view);
    20. }
    22. // Check for special "forward:" prefix.
    23. //forward前缀：InternalResourceView
    24. if (viewName.startsWith(FORWARD_URL_PREFIX)) {
    25.    String forwardUrl = viewName.substring(FORWARD_URL_PREFIX.length());
    26.    InternalResourceView view = new InternalResourceView(forwardUrl);
    27.    return applyLifecycleMethods(FORWARD_URL_PREFIX, view);
    28. }
    30. // Else fall back to superclass implementation: calling loadView.
    31. //两个前缀都不是：创建父类默认的view对象
    32. return super.createView(viewName, locale);
    33. }

  8. 得到view对象(InternalResourceView)
    SpringMVC - 图4
    视图解析器得到View对象的流程：
    所有配置好的视图解析器都会尝试根据视图名(返回值)得到View对象，能得到就return，得不到就找下一个
    调用View对象的render方法(DispatcherServlet)

    1. view.render(mv.getModelInternal(), request, response);
    1. /**
    2. * Prepares the view given the specified model, merging it with static
    3. * attributes and a RequestContext attribute, if necessary.
    4. * Delegates to renderMergedOutputModel for the actual rendering.
    5. * @see #renderMergedOutputModel
    6. */
    7. @Override
    8. public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
    9.    HttpServletResponse response) throws Exception {
    11. if (logger.isDebugEnabled()) {
    12.    logger.debug("View " + formatViewName() +
    13.          ", model " + (model != null ? model : Collections.emptyMap()) +
    14.          (this.staticAttributes.isEmpty() ? "" : ", static attributes " + this.staticAttributes));
    15. }
    17. Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
    18. prepareResponse(request, response);
    19. //*渲染要给页面输出的数据
    20. renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
    21. }

  9. InternalResourceView的方法renderMergedOutputModel：

    1. /**
    2. * Render the internal resource given the specified model.
    3. * This includes setting the model as request attributes.
    4. */
    5. @Override
    6. protected void renderMergedOutputModel(
    7.  Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
    9.  // Expose the model object as request attributes.
    10.     //*将模型中的数据放到请求域中
    11.  exposeModelAsRequestAttributes(model, request);
    13.  // Expose helpers as request attributes, if any.
    14.  exposeHelpers(request);
    16.  // Determine the path for the request dispatcher.
    17.  String dispatcherPath = prepareForRendering(request, response);
    19.  // Obtain a RequestDispatcher for the target resource (typically a JSP).
    20.  RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
    21.  if (rd == null) {
    22.      throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
    23.                                 "]: Check that the corresponding file exists within your web application archive!");
    24.  }
    26.  // If already included or response already committed, perform include, else forward.
    27.  if (useInclude(request, response)) {
    28.      response.setContentType(getContentType());
    29.      if (logger.isDebugEnabled()) {
    30.          logger.debug("Including [" + getUrl() + "]");
    31.      }
    32.      rd.include(request, response);
    33.  }
    35.  else {
    36.      // Note: The forwarded resource is supposed to determine the content type itself.
    37.      if (logger.isDebugEnabled()) {
    38.          logger.debug("Forwarding to [" + getUrl() + "]");
    39.      }
    40.      rd.forward(request, response);
    41.  }
    42. }

  10. 将模型中的所有数据取出放在请求域中

    1. /**
    2. * Expose the model objects in the given map as request attributes.
    3. * Names will be taken from the model Map.
    4. * This method is suitable for all resources reachable by {@link javax.servlet.RequestDispatcher}.
    5. * @param model a Map of model objects to expose
    6. * @param request current HTTP request
    7. */
    8. protected void exposeModelAsRequestAttributes(Map<String, Object> model,
    9.    HttpServletRequest request) throws Exception {
    11. model.forEach((name, value) -> {
    12.    if (value != null) {
    13.       request.setAttribute(name, value);
    14.    }
    15.    else {
    16.       request.removeAttribute(name);
    17.    }
    18. });
    19. }

  11. 总结：视图解析器为了得到View对象，View对象可以渲染视图：转发(将模型数据放在请求域中)或重定向到页面

JstlView

  1. <!--配置视图解析器-->
  2. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
  3.       p:prefix="/WEB-INF/jsp/"
  4.       p:suffix=".jsp"
  5.       p:viewClass="org.springframework.web.servlet.view.JstlView"
  6. />
  1. 导包jstl时会自动创建一个JstlView，JstlView可以快速方便的支持国际化功能

  2. 国际化：

    • JavaWeb国际化步骤：

      • 得得到一个Locale对象
      • 使用ResourceBundle绑定国际化资源文件
      • 使用ResourceBundle.getString(“key”)获取到国际化配置文件中的值
      • web页面的国际化，fmt标签库来做
        1. <fmt:setlocale>
        2. <fmt:setBundle>
        3. <fmt:message>

    • Jstl

      • 让Spring管理国际化资源就行

        1. <!--让SpringMVC管理国际化资源文件：配置一个资源文件管理器
        2. 注意：id必须为：messageSource
        3. -->
        4. <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource"
        5. p:basename="i18n"
        6. />

      • 直接去页面使用

        1. <fmt:message>

注意：

  1. 一定要过SpringMVC的视图解析流程，否则：
    • SpringMVC - 图5
  2. 不能写前缀：forward、redirect
    • forward：new InternalResourceView();
    • redirect：new RedirectView();
    • 且创建这两个对象的构造参数中都没有locale，所以必须使用默认的View
  3. 因为需要过SpringMVC的视图解析流程，所以得在Controller类中写方法，这样代码会很冗余
    • 解决方法：
      1. <!--发送一个请求 login 直接来到WEB-INF/jsp/login.jsp页面
      2. mvc名称空间下有一个请求映射标签
      3. path：指定哪个请求
      4. -->
      5. <mvc:view-controller path="/hello/login" view-name="login"/>
      6. <!--开启mvc注解驱动模式后，mvc:view-controller不会使其他方法失效-->
      7. <mvc:annotation-driven/>

扩展:加深视图解析器和视图对象

  • 视图解析器根据方法的返回值得到视图对象;
  • 多个视图解析器都会尝试能否得到视图对象
  • 视图对象不同就可以具有不同功能;

自定义视图解析器和视图对象

  1. package com.jjj.view;
  3. import org.springframework.core.Ordered;
  4. import org.springframework.core.annotation.Order;
  5. import org.springframework.web.servlet.View;
  6. import org.springframework.web.servlet.ViewResolver;
  8. import java.util.Locale;
  10. /**
  11.  * @author <a href="jinyu52370@163.com">JJJ</a>
  12.  * @date 2020/5/17 23:00
  13.  */
  14. public class MySeTuViewResolver implements ViewResolver, Ordered {
  15.     private Integer order = 0;
  17.     public void setOrder(Integer order) {
  18.         this.order = order;
  19.     }
  21.     @Override
  22.     public View resolveViewName(String viewName, Locale locale) throws Exception {
  23.         if (viewName.startsWith("hso:")){
  24.             return new MySeTuView();
  25.         }
  26.         return null;
  27.     }
  29.     @Override
  30.     public int getOrder() {
  31.         return order;
  32.     }
  33. }
  1. package com.jjj.view;
  3. import org.springframework.web.servlet.View;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  7. import java.util.Map;
  9. /**
  10.  * @author <a href="jinyu52370@163.com">JJJ</a>
  11.  * @date 2020/5/17 23:02
  12.  */
  13. public class MySeTuView implements View {
  14.     @Override
  15.     public String getContentType() {
  16.         return "text/html";
  17.     }
  19.     @Override
  20.     public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
  21.         System.out.println("之前保存的数据:" + model);
  22.         response.getWriter().write("<h1>即将展示涩图</h1>");
  23.     }
  24. }
  1. <!--自定义视图解析器
  2.     order：默认的视图解析器的优先级最低：Integer.MAX_VALUE
  3. -->
  4. <bean id="mySeTuViewResolver" class="com.jjj.view.MySeTuViewResolver"
  5.     p:order="1"
  6. />

流程：

  1. 让自定义的视图解析器工作(视图解析器必须放在ioc容器中)
  2. 得到自定义视图对象
  3. 自定义视图对象自定义渲染逻辑
    1. response.getWriter().write("<h1>即将展示涩图</h1>");

CRUD

create; retrieve; update; delete

通过 SpringMVC的表单标签可以实现将模型数据中的属性和HTML表单元素相绑定，以实现表单数据更便捷编辑和表单值的回显

用了表单标签的页面可能会报这个错误：请求域中没有一个command类型的对象

  1. java.lang.IllegalStateException: 
  2. Neither BindingResult nor plain target object for bean name 'command' available as request attribute

数据转换&数据格式化&数据校验

SpringMVC封装自定义类型对象时，javaBean要和页面提交的数据进行一一绑定

  • 页面提交的所有数据都是字符串： Integer age，Date birth；

牵扯到以下操作：

  1. 数据绑定期间的数据类型转换：String -> Integet;
  2. 数据绑定期间的数据格式化问题：birth=1999-05-07 -> Date=1999/05/07 1999.05.07
  3. 数据校验：提交的数据必须是合法的
    • 前端校验：js+正则表达式
    • 后端校验：重要数据必须

自定义类型转换器

  1. 步骤
    1. 实现接口ConversionService：其中有很多Converter工作
    2. Converter是ConversionService中的组件，需要将WebDataBinder中的ConversionService设置成加了自定义类型转换器的ConversionService ```java package com.jjj.component;

import com.jjj.entity.User; import org.springframework.core.convert.converter.Converter;

/**

  • @author JJJ

  • @date 2020/5/19 21:30 */ public class MyStringToUser implements Converter { @Override public User convert(String s) {

    1.  User user = new User();
    2.  System.out.println("页面提交的将要转换的字符串:" + s);
    3.  if (s.contains("/")){
    4.      String[] split = s.split("/");
    5.      user.setName(split[0]);
    6.      user.setAge(Integer.parseInt(split[1]));
    7.      user.setBirthday(split[2]);
    8.      user.setPassword(split[3]);
    9.      user.setMoney(Double.valueOf(split[4]));
    10.      user.setAddress(split[5]);
    11.      return user;
    12.  }
    13.  return null;

    } } ```

    1. 配置出ConversionService ```java 

  2. ---
  4. <a name="24c6c82b"></a>
  5. ## 关于<mvc:annotation- driven/>
  7. ```xml
  8. <mvc:annotation-driven/>

会自动注册：

  • RequestMapping Mapping
  • RequestMapping Adapter
  • ExceptionHandlerException Resolve

还捋提供以下支持：

  • 支持使用 ConversionService实例对表单参数进行类型转换
  • 支持使用@NumberFormat annotation、@ DateTimeFormat注解完成数据类型的格式化
  • 支持使用@vaid注解对 JavaBean实例进行JSR 303验证
  • 支持使用@RequestBody和@ResponseBody注解
  1. <mvc:default-servlet-handler/>
  2. <mvc:annotation-driven/>

现象：

  1. 都没配？动态资源@RequestMapping映射的资源能访问，静态资源(.html.js，. img)不能访问
  2. 加上mvc: default-serv1et-hand1er/，不加mvc: annotation- driven/，静态资源ok，动态资源完蛋
  3. 都加上，静态动态都能访问
  1. <!--使用FormattingConversionServiceFactoryBean，既具有自定义的类型转换，也可以格式化-->
  2. <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
  3.     <property name="converters">
  4.         <bean class="com.jjj.component.MyStringToUser"/>
  5.     </property>
  6. </bean>

数据校验

前端校验不安全，重要数据一定要后端校验

SpringMVC可以使用JSR 303做数据校验

JSR303

  • JSR303是Java为Bean数据合法性校验提供的标准框架，它已经包含在JavaEE6.0中

  • JSR303通过在Bean属性上标注类似于@NotNull、@Max等标准的注解指定校验规则，并通过标准的验证接口Bean进行验证 | 注解 | 功能说明 | | —- | —- | | @Null | 被注释的元素必须为nuIl | | @NotNull | 被注释的元素必须不为null | | @AssertTrue | 被注释的元素必须为true | | @AssertFalse | 被注释的元素必须为 false | | @Min(value) | 被注释的元素必须是一个数字，基值必须大于等于指定的最小值 | | @Max(value) | 被注释的元素必须是一个数字，其值必须小于等于指定的最大值 | | @DecimalMin(value) | 被注释的元素必须是一个数字，其值必须大于等于指定的最小值 | | @DecimalMax(value) | 被注释的元素必须是一个数字，其值必须小于等于指定的最大值 | | @Size(max, min) | 被注释的元素的大小必须在指定的范围内 | | @Digits(integer, fraction) | 被注释的元素必须是一个数字，其值必须在可接受的范围内 | | @Past | 被注释的元素必须是一个过去的日期 | | @Future | 被注释的元素必须是一个未来的日期 | | @Pattern(value) | 被注释的元素必须符合指定的正则表达式 |

  • JSR303规范：Hibernate validator扩展注解(第三方校验框架)

    • Hibernate validator是JSR303的一个参考实现，除支持所有标准的校验注解外，它还支持以下的扩展注解注解 | 注解 | 功能说明 | | —- | —- | | @Email | 被注解的元素必须是电子邮箱地址 | | @Length | 被注解的字符串的大小必须在指定的范围内 | | @NotEmpty | 被注解的字符串必须非空 | | @Range | 被注解的元素必须在合适的范围内 |

快速开始后端校验

  1. 导包

  2. 给bean上加校验注解

    1. public class User {
    2.  private Integer id;
    3.  @NotEmpty
    4.  @Length(min = 6, max = 18)
    5.  private String name;
    6.  private Integer age;
    7.  @DateTimeFormat(pattern = "yyyy-MM-dd")
    8.  @Past
    9.  private Date birthday;
    10.  @NotEmpty
    11.  private String password;
    12.  @NumberFormat(pattern = "#,###,###.##")
    13.  private Double money;
    14.  private String address;
    15. }

  3. 在SpringMVC封装对象的时候，告诉springMVC这个bean需要校验

    1. @RequestMapping(value = "/user", method = RequestMethod.POST)
    2. public String addUser(@Valid User user, BindingResult bindingResult){
    3.  System.out.println(user);
    4.  if (bindingResult.hasErrors()){
    5.      System.out.println("有校验错误");
    6.      return "add";
    7.  }
    8.  System.out.println("添加了" + userService.addUser(user) + "条数据");
    9.  return "redirect:/users";
    10. }

  4. 校验结果
    给需要校验的bean后加BindingResult，这个BindingResult就是封装前一个bean的校验结果

    1. public String addUser(@Valid User user, BindingResult bindingResult)

  5. 根据不同的校验结果做不同的业务

    1. if (bindingResult.hasErrors()){
    2.  System.out.println("有校验错误");
    3.  return "add";
    4. }
    5. System.out.println("添加了" + userService.addUser(user) + "条数据");
    6. return "redirect:/users";

AJAX

  1. SpringMVC快速完成ajax功能
    • 返回数据是json就行
    • 页面发送ajax

  2. 步骤

    1. 导包

      1. <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
      2.   <dependency>
      3.       <groupId>com.fasterxml.jackson.core</groupId>
      4.       <artifactId>jackson-databind</artifactId>
      5.   </dependency>
      6.   <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
      7.   <dependency>
      8.       <groupId>com.fasterxml.jackson.core</groupId>
      9.       <artifactId>jackson-core</artifactId>
      10.   </dependency>
      11.   <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
      12.   <dependency>
      13.       <groupId>com.fasterxml.jackson.core</groupId>
      14.       <artifactId>jackson-annotations</artifactId>
      15.   </dependency>


拦截器HandlerInterceptor

允许运行目标方法之前进行一些拦截工作，或目标方法执行之后进行一些其他处理

preHandle：在目标方法之前调用；返回boolean：true(chain.doFilter())放行；false不放行

postHandle：在目标方法之后调用：目标方法调用之后

afterCompletion：在请求整个完成之后：来到目标页面(chain.doFilter())；资源响应之后

使用步骤：

  1. 实现HandlerInterceptor接口

  2. 在SpringMVC中注册

    1. <!--拦截器-->
    2. <mvc:interceptors>
    3.  <!--配置某个拦截器；默认拦截所有请求-->
    4.  <bean class="com.jjj.component.MyFirstInterceptor"/>
    6.  <!--配置某个拦截器；可以有更详细的信息-->
    7.  <!--<mvc:interceptor>-->
    8.      <!--只拦截test01请求-->
    9.      <!--<mvc:mapping path="/interceptor/test01"/>-->
    10.      <!--<bean class="com.jjj.component.MyFirstInterceptor"/>-->
    11.  <!--</mvc:interceptor>-->
    12. </mvc:interceptors>

执行流程：跟filter一样

正常流程：拦截器.preHandle -> 目标方法 -> 拦截器.postHandle -> 页面 -> 拦截器.afterCompletion

  1. preHandle...
  2. test01...
  3. postHandle...
  4. success.jsp
  5. afterCompletion...

异常流程：

  1. preHandle不放行(return false)就没有以后的流程
  2. 只要放行了，afterCompletion都会执行

多拦截器：

正常流程：

  1. MyFirstInterceptor...preHandle...
  2. MySecondInterceptor...preHandle...
  3. test01...
  4. MySecondInterceptor...postHandle...
  5. MyFirstInterceptor...postHandle...
  6. success.jsp
  7. MySecondInterceptor...afterCompletion...
  8. MyFirstInterceptor...afterCompletion...

异常流程：

  1. 不放行：
    1. 都不放行：之后都没有
    2. first放行，second不放行：放行的拦截器的afterCompletion总会执行
      1. MyFirstInterceptor...preHandle...
      2. MySecondInterceptor...preHandle...
      3. MyFirstInterceptor...afterCompletion...

拦截器的preHandle：按照xml中的配置顺序执行

拦截器的postHandle：逆序

拦截器的afterCompletion：逆序

放行的拦截器的afterCompletion总会执行

源码

  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  2.    HttpServletRequest processedRequest = request;
  3.    HandlerExecutionChain mappedHandler = null;
  4.    boolean multipartRequestParsed = false;
  6.    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  8.    try {
  9.       ModelAndView mv = null;
  10.       Exception dispatchException = null;
  12.       try {
  13.          processedRequest = checkMultipart(request);
  14.          multipartRequestParsed = (processedRequest != request);
  16.          // Determine handler for the current request.
  17.          //拿到方法的执行链，包含拦截器
  18.          mappedHandler = getHandler(processedRequest);
  19.          if (mappedHandler == null) {
  20.             noHandlerFound(processedRequest, response);
  21.             return;
  22.          }
  24.          // Determine handler adapter for the current request.
  25.          HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  27.          // Process last-modified header, if supported by the handler.
  28.          String method = request.getMethod();
  29.          boolean isGet = "GET".equals(method);
  30.          if (isGet || "HEAD".equals(method)) {
  31.             long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
  32.             if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
  33.                return;
  34.             }
  35.          }
  36.         //拦截器的preHandle执行；只要有一个拦截器返回false，目标方法之后都不会执行，直接跳到afterCompletion
  37.          if (!mappedHandler.applyPreHandle(processedRequest, response)) {
  38.             return;
  39.          }
  41.          // Actually invoke the handler.
  42.          //目标方法执行
  43.          mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  45.          if (asyncManager.isConcurrentHandlingStarted()) {
  46.             return;
  47.          }
  49.          applyDefaultViewName(processedRequest, mv);
  50.          //拦截器的postHandle；目标方法正常执行才会走到这步
  51.          mappedHandler.applyPostHandle(processedRequest, response, mv);
  52.       }
  53.       catch (Exception ex) {
  54.          dispatchException = ex;
  55.       }
  56.       catch (Throwable err) {
  57.          // As of 4.3, we're processing Errors thrown from handler methods as well,
  58.          // making them available for @ExceptionHandler methods and other scenarios.
  59.          dispatchException = new NestedServletException("Handler dispatch failed", err);
  60.       }
  61.       //页面渲染；出现异常跳到afterCompletion
  62.       processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
  63.    }
  64.    //任何期间有异常；执行afterCompletion
  65.    catch (Exception ex) {
  66.       triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
  67.    }
  68.    catch (Throwable err) {
  69.       triggerAfterCompletion(processedRequest, response, mappedHandler,
  70.             new NestedServletException("Handler processing failed", err));
  71.    }
  72.    finally {
  73.       if (asyncManager.isConcurrentHandlingStarted()) {
  74.          // Instead of postHandle and afterCompletion
  75.          if (mappedHandler != null) {
  76.             mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
  77.          }
  78.       }
  79.       else {
  80.          // Clean up any resources used by a multipart request.
  81.          if (multipartRequestParsed) {
  82.             cleanupMultipart(processedRequest);
  83.          }
  84.       }
  85.    }
  86. }

↓

applyPreHandle

  1. boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
  2.     HandlerInterceptor[] interceptors = getInterceptors();
  3.     if (!ObjectUtils.isEmpty(interceptors)) {
  4.         for (int i = 0; i < interceptors.length; i++) {
  5.             HandlerInterceptor interceptor = interceptors[i];
  6.                //若拦截器preHandle返回false，即不放行
  7.             if (!interceptor.preHandle(request, response, this.handler)) {
  8.                 //不执行后续，调用afterCompletion
  9.                 triggerAfterCompletion(request, response, null);
  10.                 return false;
  11.             }
  12.             //放行，记录索引
  13.             this.interceptorIndex = i;
  14.         }
  15.     }
  16.     return true;
  17. }

preHandle细节：first放行，second不放行

次数 interceptor 操作
第一次 ConversionServiceExposingInterceptor interceptorIndex = 0
第二次 MyFirstInterceptor interceptorIndex = 1
第三次 MySecondInterceptor 不放行 -> 执行triggerAfterCompletion() -> 倒序遍历 -> i == 1

已经放行了的拦截器的afterCompletion总会执行

↓

applyPostHandle

  1. void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
  2.       throws Exception {
  4.    HandlerInterceptor[] interceptors = getInterceptors();
  5.    if (!ObjectUtils.isEmpty(interceptors)) {
  6.       //倒序遍历
  7.       for (int i = interceptors.length - 1; i >= 0; i--) {
  8.          HandlerInterceptor interceptor = interceptors[i];
  9.          interceptor.postHandle(request, response, this.handler, mv);
  10.       }
  11.    }
  12. }

↓

页面渲染

  1. private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
  2.       @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
  3.       @Nullable Exception exception) throws Exception {
  5.    boolean errorView = false;
  7.    if (exception != null) {
  8.       if (exception instanceof ModelAndViewDefiningException) {
  9.          logger.debug("ModelAndViewDefiningException encountered", exception);
  10.          mv = ((ModelAndViewDefiningException) exception).getModelAndView();
  11.       }
  12.       else {
  13.          Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
  14.          mv = processHandlerException(request, response, handler, exception);
  15.          errorView = (mv != null);
  16.       }
  17.    }
  19.    // Did the handler return a view to render?
  20.    if (mv != null && !mv.wasCleared()) {
  21.       //页面渲染
  22.       render(mv, request, response);
  23.       if (errorView) {
  24.          WebUtils.clearErrorRequestAttributes(request);
  25.       }
  26.    }
  27.    else {
  28.       if (logger.isTraceEnabled()) {
  29.          logger.trace("No view rendering, null ModelAndView returned.");
  30.       }
  31.    }
  33.    if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
  34.       // Concurrent handling started during a forward
  35.       return;
  36.    }
  38.    if (mappedHandler != null) {
  39.       // Exception (if any) is already handled..
  40.       //正常执行：拦截器的afterCompletion；
  41.       //异常执行：外部方法catch中依旧执行afterCompletion
  42.       mappedHandler.triggerAfterCompletion(request, response, null);
  43.    }
  44. }

afterCompletion

  1. void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex)
  2.       throws Exception {
  4.    HandlerInterceptor[] interceptors = getInterceptors();
  5.    if (!ObjectUtils.isEmpty(interceptors)) {
  6.       //倒序遍历
  7.       for (int i = this.interceptorIndex; i >= 0; i--) {
  8.          HandlerInterceptor interceptor = interceptors[i];
  9.          try {
  10.             interceptor.afterCompletion(request, response, this.handler, ex);
  11.          }
  12.          catch (Throwable ex2) {
  13.             logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
  14.          }
  15.       }
  16.    }
  17. }

多拦截器执行流程

SpringMVC - 图6

国际化

  1. 写国际化资源文件
  2. 让SpringMVC的ResourceBundleMessageSource管理国际化资源
  3. 去页面取值

SpringMVC中，区域信息是由区域信息解析器LocaleResolver得到的，默认会用AcceptHeaderLocaleResolver

  1. @Override
  2. public Locale resolveLocale(HttpServletRequest request) {
  3.    Locale defaultLocale = getDefaultLocale();
  4.    if (defaultLocale != null && request.getHeader("Accept-Language") == null) {
  5.       return defaultLocale;
  6.    }
  7.    //得到区域信息
  8.    Locale requestLocale = request.getLocale();
  9.    List<Locale> supportedLocales = getSupportedLocales();
  10.    if (supportedLocales.isEmpty() || supportedLocales.contains(requestLocale)) {
  11.       return requestLocale;
  12.    }
  13.    Locale supportedLocale = findSupportedLocale(request, supportedLocales);
  14.    if (supportedLocale != null) {
  15.       return supportedLocale;
  16.    }
  17.    return (defaultLocale != null ? defaultLocale : requestLocale);
  18. }

点击链接切换国际化

实现LocaleResolver接口

  1. package com.jjj.component;
  3. import org.springframework.web.servlet.LocaleResolver;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  7. import java.util.Locale;
  9. /**
  10.  * @author <a href="jinyu52370@163.com">JJJ</a>
  11.  * @date 2020/5/24 18:01
  12.  *
  13.  * 自定义区域信息解析器
  14.  */
  15. public class MyLocaleResolver implements LocaleResolver {
  16.     /**
  17.      * 解析返回locale
  18.      */
  19.     @Override
  20.     public Locale resolveLocale(HttpServletRequest request) {
  21.         String localeStr = request.getParameter("locale");
  22.         //若携带了locale参数，就使用参数指定的区域信息
  23.         if (localeStr != null && !"".equals(localeStr)){
  24.             return new Locale(localeStr.split("_")[0], localeStr.split("_")[1]);
  25.         }
  26.         //否则，使用请求头的locale
  27.         return request.getLocale();
  28.     }
  30.     /**
  31.      * 修改locale
  32.      */
  33.     @Override
  34.     public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {
  35.         throw new UnsupportedOperationException(
  36.                 "Cannot change HTTP accept header - use a different locale resolution strategy");
  37.     }
  38. }

jsp页面

  1. <a href="/i18n/toLoginPage?locale=zh_CN">中文</a>|<a href="/i18n/toLoginPage?locale=en_US">English</a>

springMVC配置文件

  1. <!--自定义区域信息解析器-->
  2. <bean id="localeResolver" class="com.jjj.component.MyLocaleResolver"/>

AcceptHeaderLocaleResolver：使用请求头的区域信息

  1. public class AcceptHeaderLocaleResolver implements LocaleResolver {
  2.    @Override
  3.    public Locale resolveLocale(HttpServletRequest request) {
  4.       Locale defaultLocale = getDefaultLocale();
  5.       if (defaultLocale != null && request.getHeader("Accept-Language") == null) {
  6.          return defaultLocale;
  7.       }
  8.       Locale requestLocale = request.getLocale();
  9.       List<Locale> supportedLocales = getSupportedLocales();
  10.       if (supportedLocales.isEmpty() || supportedLocales.contains(requestLocale)) {
  11.          return requestLocale;
  12.       }
  13.       Locale supportedLocale = findSupportedLocale(request, supportedLocales);
  14.       if (supportedLocale != null) {
  15.          return supportedLocale;
  16.       }
  17.       return (defaultLocale != null ? defaultLocale : requestLocale);
  18.    }
  20.    @Override
  21.    public void setLocale(HttpServletRequest request, @Nullable HttpServletResponse response, @Nullable Locale locale) {
  22.       throw new UnsupportedOperationException(
  23.             "Cannot change HTTP accept header - use a different locale resolution strategy");
  24.    }
  26. }

FixedLocaleContextResolver：使用系统默认的区域信息

  1. public class FixedLocaleContextResolver implements LocaleContextResolver {
  2.    @Override
  3.    public LocaleContext resolveLocaleContext(ServerWebExchange exchange) {
  4.       return new TimeZoneAwareLocaleContext() {
  5.          @Override
  6.          public Locale getLocale() {
  7.             return locale;
  8.          }
  9.          @Override
  10.          @Nullable
  11.          public TimeZone getTimeZone() {
  12.             return timeZone;
  13.          }
  14.       };
  15.    }
  17.    @Override
  18.    public void setLocaleContext(ServerWebExchange exchange, @Nullable LocaleContext localeContext) {
  19.       throw new UnsupportedOperationException(
  20.             "Cannot change fixed locale - use a different locale context resolution strategy");
  21.    }
  23. }

SessionLocaleResolver

CookieLocaleResolver

SpringMVC - 图7

filter和interceptor的使用时机

如果某些功能，需要其他组件配合完成，就使用拦截器(可以Autowried组件)

异常处理

默认是此HandlerExcptionResolver

ExceptionHandlerExceptionResolver：@ExceptionHandler
ResponseStatusExceptionResolver：@ResponseStatus
DefaultHandlerExceptionResolver：判断是否是SpringMVC自带的异常

普通bean中的处理异常方法

  1. /**
  2.  * 告诉SpringMVC，这个方法专门处理这个类的异常
  3.  * 1.在参数表中写上Exception变量，可以接收发生的异常
  4.  * 2.参数表中不能写Model
  5.  * 3.可以返回ModelAndView
  6.  * 4.精确优先
  7.  */
  8. @ExceptionHandler(ArithmeticException.class)
  9. public ModelAndView arithmeticException(ArithmeticException e) {
  10.     System.out.println("handleException01..." + e);
  12.     ModelAndView modelAndView = new ModelAndView();
  13.     modelAndView.addObject("e", e);
  14.     modelAndView.setViewName("error");
  15.     return modelAndView;
  16. }

全局处理异常的类

  1. /**
  2.  * @author <a href="jinyu52370@163.com">JJJ</a>
  3.  * @date 2020/5/24 21:48
  4.  *
  5.  * 1.集中处理所有异常的类
  6.  * 2.加入到ioc中：@ControllerAdvice
  7.  * 3.全局处理异常类和某个bean的处理异常方法同时存在，bean的优先
  8.  */
  9. @ControllerAdvice
  10. public class MyCentralizedException {
  11.     /**
  12.      * 告诉SpringMVC，这个方法专门处理这个类的异常
  13.      * 1.在参数表中写上Exception变量，可以接收发生的异常
  14.      * 2.参数表中不能写Model
  15.      * 3.可以返回ModelAndView
  16.      * 4.精确优先
  17.      */
  18.     @ExceptionHandler(Exception.class)
  19.     public ModelAndView handleException(Exception e) {
  20.         System.out.println("全局handleException..." + e);
  22.         ModelAndView modelAndView = new ModelAndView();
  23.         modelAndView.addObject("e", e);
  24.         modelAndView.setViewName("error");
  25.         return modelAndView;
  26.     }
  27. }

SpringMVC自己的异常

  1. HttpRequestMethodNotSupportedException

由DefaultHandlerExceptionResolver处理

  1. @Override
  2. @Nullable
  3. protected ModelAndView doResolveException(
  4.       HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
  6.    try {
  7.       if (ex instanceof HttpRequestMethodNotSupportedException) {
  8.          return handleHttpRequestMethodNotSupported(
  9.                (HttpRequestMethodNotSupportedException) ex, request, response, handler);
  10.       }
  11.       else if (ex instanceof HttpMediaTypeNotSupportedException) {
  12.          return handleHttpMediaTypeNotSupported(
  13.                (HttpMediaTypeNotSupportedException) ex, request, response, handler);
  14.       }
  15.       else if (ex instanceof HttpMediaTypeNotAcceptableException) {
  16.          return handleHttpMediaTypeNotAcceptable(
  17.                (HttpMediaTypeNotAcceptableException) ex, request, response, handler);
  18.       }
  19.       else if (ex instanceof MissingPathVariableException) {
  20.          return handleMissingPathVariable(
  21.                (MissingPathVariableException) ex, request, response, handler);
  22.       }
  23.       else if (ex instanceof MissingServletRequestParameterException) {
  24.          return handleMissingServletRequestParameter(
  25.                (MissingServletRequestParameterException) ex, request, response, handler);
  26.       }
  27.       else if (ex instanceof ServletRequestBindingException) {
  28.          return handleServletRequestBindingException(
  29.                (ServletRequestBindingException) ex, request, response, handler);
  30.       }
  31.       else if (ex instanceof ConversionNotSupportedException) {
  32.          return handleConversionNotSupported(
  33.                (ConversionNotSupportedException) ex, request, response, handler);
  34.       }
  35.       else if (ex instanceof TypeMismatchException) {
  36.          return handleTypeMismatch(
  37.                (TypeMismatchException) ex, request, response, handler);
  38.       }
  39.       else if (ex instanceof HttpMessageNotReadableException) {
  40.          return handleHttpMessageNotReadable(
  41.                (HttpMessageNotReadableException) ex, request, response, handler);
  42.       }
  43.       else if (ex instanceof HttpMessageNotWritableException) {
  44.          return handleHttpMessageNotWritable(
  45.                (HttpMessageNotWritableException) ex, request, response, handler);
  46.       }
  47.       else if (ex instanceof MethodArgumentNotValidException) {
  48.          return handleMethodArgumentNotValidException(
  49.                (MethodArgumentNotValidException) ex, request, response, handler);
  50.       }
  51.       else if (ex instanceof MissingServletRequestPartException) {
  52.          return handleMissingServletRequestPartException(
  53.                (MissingServletRequestPartException) ex, request, response, handler);
  54.       }
  55.       else if (ex instanceof BindException) {
  56.          return handleBindException((BindException) ex, request, response, handler);
  57.       }
  58.       else if (ex instanceof NoHandlerFoundException) {
  59.          return handleNoHandlerFoundException(
  60.                (NoHandlerFoundException) ex, request, response, handler);
  61.       }
  62.       else if (ex instanceof AsyncRequestTimeoutException) {
  63.          return handleAsyncRequestTimeoutException(
  64.                (AsyncRequestTimeoutException) ex, request, response, handler);
  65.       }
  66.    }
  67.    catch (Exception handlerEx) {
  68.       if (logger.isWarnEnabled()) {
  69.          logger.warn("Failure while trying to resolve exception [" + ex.getClass().getName() + "]", handlerEx);
  70.       }
  71.    }
  72.    return null;
  73. }

SimpleMappingExceptionResourceBundle

通过配置的方式进行异常处理

优先级最低

SpringMVC和Spring整合

目的：分工明确

  • SpringMVC的配置文件就来配置和网站转发逻辑以及网站功能有关的
    • 视图解析器，文件上传解析器，支持ajax…
  • Spring的配置文件来配置和业务有关的
    • 事务控制，数据源…

解决方法：

  1. 合并配置文件：

    1. <import resource="spring.xml"/>

  2. 分容器：

    • Spring管理业务逻辑组件：扫描时排除控制器和异常管理类

      1. <context:component-scan base-package="com.jjj">
      2. <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
      3. <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
      4. </context:component-scan>

    • SpringMVC管理控制器组件：只扫描控制器和异常管理类

      1. <context:component-scan base-package="com.jjj" use-default-filters="false">
      2. <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
      3. <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
      4. </context:component-scan>

    • Spring作为父容器；SpringMVC作为子容器

      • 当从SpringMVC管理的Controller中装配Spring管理的Service组件时，可以装配；反之不可
      • 即：子容器可以装配父容器的组件