Spring全家桶 - SpringMVC - 《Java 学习笔记》

1 SpringMVC 的请求响应流程
2 SpringMVC中的一些组件
3 注解
4 Restful风格
5 响应数据和结果视图
6 异常处理器和拦截器
- 6.1 自定义拦截器
- 6.3 拦截器的用户登录案例

SpringMVC的优势（model view controller）

1、清晰的角色划分：前端控制器（DispatcherServlet）请求到处理器映射（HandlerMapping）处理器适配器（HandlerAdapter）视图解析器（ViewResolver）处理器或页面控制器（Controller）验证器（ Validator）命令对象（Command 请求参数绑定到的对象就叫命令对象）表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象） 2、分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要 3、由于命令对象就是一个 POJO，无需继承框架特定 API，可以使用命令对象直接作为业务对象 4、和 Spring 其他框架无缝集成，是其它 Web 框架所不具备的 5、可适配，通过 HandlerAdapter 可以支持任意的类作为处理器 6、可定制性，HandlerMapping、ViewResolver 等能够非常简单的定制 7、功能强大的数据验证、格式化、绑定机制 8、利用 Spring 提供的 Mock 对象能够非常简单的进行 Web 层单元测试 9、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换 10、强大的 JSP 标签库，使 JSP 编写更容易 ………………还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配置支持等等

执行流程

服务器启动，应用被加载。读取到 web.xml 中的配置创建 spring 容器并且初始化容器中的对象
浏览器发送请求，被 DispatherServlet 捕获，该 Servlet 并不处理请求，而是把请求转发出去。转发的路径是根据请求 URL，匹配@RequestMapping 中的内容
匹配到了后，执行对应方法。该方法有一个返回值
根据方法的返回值，借助 InternalResourceViewResolver 找到对应的结果视图
渲染结果视图，响应浏览器

1 SpringMVC 的请求响应流程

2 SpringMVC中的一些组件

DispatcherServlet：前端控制器

用户请求到达前端控制器，它就相当于 mvc 模式中的 c，dispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet 的存在降低了组件之间的耦合性

HandlerMapping：处理器映射器

HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等

Handler：处理器

它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由 Handler 对具体的用户请求进行处理

HandlAdapter：处理器适配器

通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行

View Resolver：视图解析器

View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户

View：视图

SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView 等。我们最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面

说明

在 SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。
使 用 <mvc:annotation-driven> 自动加载 RequestMappingHandlerMapping （处理映射器） 和
RequestMappingHandlerAdapter（处理适配器），可 用 在 SpringMVC.xml 配 置 文 件 中 使 用
<mvc:annotation-driven>替代注解处理器和适配器的配置。

3 注解

3.1 RequestMapping

作用：用于建立请求URL和处理请求方法之间的对应关系

源码：

@Target({ElementType.METHOD, ElementType.TYPE})        // 说明该注解应该加在方法上或者是类上
@Retention(RetentionPolicy.RUNTIME)                    // 写在.class文件中，jvm加载时依然在
@Documented
@Mapping

属性：

public @interface RequestMapping {
    String name() default "";                    // 路径名
    @AliasFor("path")
    String[] value() default {};
    @AliasFor("value")
    String[] path() default {};
    RequestMethod[] method() default {};        // 指定请求的方式：GET/POST/PUT/DELETE
    String[] params() default {};                // 用于指定限制请求参数的条件
                                                // 例如：
                                                // params = {"accountName"}，表示请求参数必须有 accountName
                                                // params = {"moeny!100"}，表示请求参数中 money 不能是 100
    String[] headers() default {};                // 用于指定限制请求消息头的条件
    String[] consumes() default {};
    String[] produces() default {};
}

请求参数的绑定

**
支持的数据类型：

基本类型参数：包括基本类型和 String 类型
- 要求：我们的参数名称必须和控制器中方法的形参名称保持一致。(严格区分大小写)
POJO 类型参数：包括实体类，以及关联的实体类
- 要求：表单中参数名称和 POJO 类的属性名称保持一致。并且控制器方法的参数类型是 POJO 类型。
数组和集合类型参数：包括 List 结构和 Map 结构的集合（包括数组）
- 第一种：要求集合类型的请求参数必须在 POJO 中。在表单中请求参数名称要和 POJO 中集合属性名称相同。给 List 集合中的元素赋值，使用下标。给 Map 集合中的元素赋值，使用键值对。
- 第二种：接收的请求参数是 json 格式数据。需要借助一个注解实现。

3.2 RequestParam

作用： 把请求中指定名称的参数给控制器中的形参赋值 属性： value：请求参数中的名称。 required：请求参数中是否必须提供此参数。默认值：true。表示必须提供，如果不提供将报错

@RequestMapping("/useRequestParam")        // 改为GetMapping
public String useRequestParam(@RequestParam("name")String username,
                              @RequestParam(value="age",required=false)Integer age) {
    System.out.println(username+","+age);
    return "success";
}

3.3 RequestBody

作用： 用于获取请求体内容。直接使用得到是 key=value&key=value…结构的数据 .get 请求方式不适用。 属性： required：是否必须有请求体。默认值是:true。当取值为 true 时,get 请求方式会报错。如果取值为 false，get 请求得到是 null

@RequestMapping("/useRequestBody")
public String useRequestBody(@RequestBody(required=false) String body){
    System.out.println(body);
    return "success";
}

3.4 PathVariable

作用： 用于绑定 url 中的占位符。例如：请求 url 中 /delete/{id}，这个{id}就是 url 占位符。 url 支持占位符是 spring3.0 之后加入的。是 springmvc 支持 rest 风格 URL 的一个重要标志 属性： value：用于指定 url 中占位符名称。 required：是否必须提供占位符

@RequestMapping("/usePathVariable/{id}")
public String usePathVariable(@PathVariable("id") Integer id){
    System.out.println(id);
    return "success";
}

3.5 CookieValue

作用：用于把指定的cookie名称的值传入控制器方法参数属性：value：指定cookie的名称 required：是否必须有此cookie

@RequestMapping("/useCookieValue")
public String useCookieValue(@CookieValue(value="JSESSIONID",required=false) String cookieValue){
        System.out.println(cookieValue);
        return "success";
}

3.6 RequestHeader（了解）

作用：用于获取请求消息头属性：value：提供消息头名称， required：是否必须有此消息头

3.7 ModelAttribute

作用： 该注解是 SpringMVC4.3 版本以后新加入的。它可以用于修饰方法和参数。出现在方法上，表示当前方法会在控制器的方法执行之前，先执行。它可以修饰没有返回值的方法，也可以修饰有具体返回值的方法。出现在参数上，获取指定的数据给参数赋值。

属性： value：用于获取数据的 key。key 可以是 POJO 的属性名称，也可以是 map 结构的 key。

应用场景： 当表单提交数据不是完整的实体类数据时，保证没有提交数据的字段使用数据库对象原来的数据。例如：我们在编辑一个用户时，用户有一个创建信息字段，该字段的值是不允许被修改的。在提交表单数据是肯定没有此字段的内容，一旦更新会把该字段内容置为 null，此时就可以使用此注解解决问题。

@ModelAttribute
public void showModel(User user) {
    System.out.println("执行了 showModel 方法"+user.getUsername());
}
/**
* 接收请求的方法
* @param user
* @return
*/
@RequestMapping("/testModelAttribute")
public String testModelAttribute(User user) {
    System.out.println("执行了控制器的方法"+user.getUsername());
    return "success";
}

基于 Map 的应用场景示例 1：ModelAttribute 修饰方法带返回值

<!-- 修改用户信息 -->
<form action="springmvc/updateUser" method="post">
    用户名称：<input type="text" name="username" ><br/>    
  用户年龄：<input type="text" name="age" ><br/>
  <input type="submit" value="保存">
</form>

@ModelAttribute
public User showModel(String username) {
    //模拟去数据库查询
    User abc = findUserByName(username);
    System.out.println("执行了 showModel 方法"+abc);
    return abc;
}
/**
* 模拟修改用户方法
* @param user
* @return
*/
@RequestMapping("/updateUser")
public String testModelAttribute(User user) {
    System.out.println("控制器中处理请求的方法：修改用户："+user);
    return "success";
}
/**
* 模拟去数据库查询
* @param username
* @return
*/
private User findUserByName(String username) {
    User user = new User();
    user.setUsername(username);
    user.setAge(19);
    user.setPassword("123456");
    return user;
}

基于 Map 的应用场景示例 1：ModelAttribute 修饰方法不带返回值

@ModelAttribute
public void showModel(String username,Map<String,User> map) {
    //模拟去数据库查询
    User user = findUserByName(username);
    System.out.println("执行了 showModel 方法"+user);
    map.put("abc",user);
}
/**
* 模拟修改用户方法
* @param user
* @return
*/
@RequestMapping("/updateUser")
public String testModelAttribute(@ModelAttribute("abc")User user) {
    System.out.println("控制器中处理请求的方法：修改用户："+user);
    return "success";
}
/**
* 模拟去数据库查询
* @param username
* @return
*/
private User findUserByName(String username) {
    User user = new User();
    user.setUsername(username);
    user.setAge(19);
    user.setPassword("123456");
    return user;
}

3.8 SessionAttribute

作用： 用于多次执行控制器方法间的参数共享。 属性： value：用于指定存入的属性名称 type：用于指定存入的数据类型

jsp 中的代码：
<!-- SessionAttribute 注解的使用 -->
<a href="springmvc/testPut">存入 SessionAttribute</a>
<hr/>
<a href="springmvc/testGet">取出 SessionAttribute</a>
<hr/>
<a href="springmvc/testClean">清除 SessionAttribute</a>

@Controller("sessionAttributeController")
@RequestMapping("/springmvc")
@SessionAttributes(value ={"username","password"},types={Integer.class})
public class SessionAttributeController {
/**
* 把数据存入 SessionAttribute
* @param model
* @return
* Model 是 spring 提供的一个接口，该接口有一个实现类 ExtendedModelMap
* 该类继承了 ModelMap，而 ModelMap 就是 LinkedHashMap 子类
*/
@RequestMapping("/testPut")
public String testPut(Model model){
     model.addAttribute("username", "泰斯特");
     model.addAttribute("password","123456");
     model.addAttribute("age", 31);
     //跳转之前将数据保存到 username、password 和 age 中，因为注解@SessionAttribute 中有这几个参数
     return "success";
 }
@RequestMapping("/testGet")
public String testGet(ModelMap model){
     System.out.println(model.get("username")+";"+model.get("password")+";"+model.get("age"));
     return "success";
 }
@RequestMapping("/testClean")
public String complete(SessionStatus sessionStatus){
    sessionStatus.setComplete();
    return "success";
    }
}

4 Restful风格

HTTP 协议里面，四个表示操作方式的动词：GET 、POST 、PUT、 DELETE，它们分别对应四种基本操作

GET用来获取资源
POST用来新建资源
PUT用来更新资源
DELETE用来删除资源

示例：

/account/1	HTTP GET	得到id=1的account
/account/1	HTTP DELETE	删除id=1的account
/account/1	HTTP PUT	更新id=1的account
/account/1	HTTP POST	新增account

5 响应数据和结果视图

5.1 ModelAndView

ModelAndView 是 SpringMVC 为我们提供的一个对象，该对象也可以用作控制器方法的返回值。

@RequestMapping("/testReturnModelAndView")
public ModelAndView testReturnModelAndView() {
    ModelAndView mv = new ModelAndView();
    mv.addObject("username", "张三");
    mv.setViewName("success");
    return mv;
}

响应的 jsp 代码：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>执行成功</title>
</head>
  <body>
    执行成功！
    ${requestScope.username}
  </body>
</html>

注意：
我们在页面上上获取使用的是 requestScope.username 取的，所以返回 ModelAndView 类型时，浏览器跳转只能是请求转发。

5.2 转发和重定向

forward转发： controller 方法在提供了 String 类型的返回值之后，默认就是请求转发

@RequestMapping("/testForward")
public String testForward() {
    System.out.println("AccountController 的 testForward 方法执行了。。。。");
    return "forward:/WEB-INF/pages/success.jsp";
}

需要注意的是，如果用了 forward：则路径必须写成实际视图 url，不能写逻辑视图。
它相当于 request.getRequestDispatcher("url").forward(request,response) 。使用请求转发，既可以转发到 jsp，也可以转发到其他的控制器方法。

Redirect 重定向：controller方法提供了一个 String 类型返回值之后，它需要在返回值里使用:redirect:

@RequestMapping("/testRedirect")
public String testRedirect() {
    System.out.println("AccountController 的 testRedirect 方法执行了。。。。");
    return "redirect:testReturnModelAndView";
}

它相当于 response.sendRedirect(url) 。需要注意的是，如果是重定向到 jsp 页面，则 jsp 页面不能写在 WEB-INF 目录中，否则无法找到。

5.3 ResponseBody响应json数据

作用： 该注解用于将 Controller 方法返回的对象，通过 HttpMessageConverter 接口转换为指定格式的数据如：json,xml 等，通过 Response 响应给客户端 需求： 使用@ResponseBody 注解实现将 controller 方法返回对象转换为 json 响应给客户端。 Springmvc 默认用 MappingJacksonHttpMessageConverter 对 json 数据进行转换，需要加入 jackson 的包。

@Controller("jsonController")
public class JsonController {
    /**
    * 测试响应 json 数据
    */
    @RequestMapping("/testResponseJson")
    public @ResponseBody Account testResponseJson(@RequestBody Account account) {
        System.out.println("异步请求："+account);
        return account;
      }
}

6 异常处理器和拦截器

异常处理器： HandlerExceptionResolver

public class CustomExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request,
        HttpServletResponse response, Object handler, Exception ex) {
        ex.printStackTrace();
        CustomException customException = null;
        //如果抛出的是系统自定义异常则直接转换
        if(ex instanceof CustomException){
        customException = (CustomException)ex;
        }else{
        //如果抛出的不是系统自定义异常则重新构造一个系统错误异常。
        customException = new CustomException("系统错误，请与系统管理 员联系！");
        }
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("message", customException.getMessage());
        modelAndView.setViewName("error");
        return modelAndView;
    }
}

拦截器： Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。用户可以自己定义一些拦截器来实现特定的功能。谈到拦截器，还要向大家提一个词——拦截器链（Interceptor Chain）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。说到这里，可能大家脑海中有了一个疑问，这不是我们之前学的过滤器吗？是的它和过滤器是有几分相似，但是也有区别，接下来我们就来说说他们的区别： 过滤器是 servlet 规范中的一部分，任何 java web 工程都可以使用。 拦截器是 SpringMVC 框架自己的，只有使用了 SpringMVC 框架的工程才能用。 过滤器在 url-pattern 中配置了/之后，可以对所有要访问的资源拦截。 拦截器它是只会拦截访问的控制器（ controller ）方法，如果访问的是 jsp，html,css,image 或者 js 是不会进行拦截的。它也是 AOP 思想的具体应用。我们要想自定义拦截器，要求必须实现：*HandlerInterceptor 接口。

6.1 自定义拦截器

编写一个普通类实现 HandlerInterceptor 接口

public class HandlerInterceptorDemo1 implements HandlerInterceptor {
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponseresponse, Object handler)
      throws Exception {
      System.out.println("preHandle 拦截器拦截了");
      return true;
  }
  @Override
  public void postHandle(HttpServletRequest request, HttpServletResponse response,Object handler,
                     ModelAndView modelAndView) throws Exception {
      System.out.println("postHandle 方法执行了");
  }
  @Override
  public void afterCompletion(HttpServletRequest request, HttpServletResponse
      response, Object handler, Exception ex)
      throws Exception {
      System.out.println("afterCompletion 方法执行了");
  }
}

配置拦截器 ```xml


- 结果
![image.png](https://cdn.nlark.com/yuque/0/2020/png/2482342/1608729661159-df957fab-fa54-430c-8310-21b2c7aaf354.png#align=left&display=inline&height=219&margin=%5Bobject%20Object%5D&name=image.png&originHeight=438&originWidth=722&size=106735&status=done&style=none&width=361)
<a name="xNtPy"></a>
#### 6.2    拦截器的细节
> **拦截器的放行：**
> 放行的含义是指，如果有下一个拦截器就执行下一个，如果该拦截器处于拦截器链的最后一个，则执行控制器 中的方法。
![image.png](https://cdn.nlark.com/yuque/0/2020/png/2482342/1608790744162-23fe8db7-4b1d-40d3-a460-ec64c2e7d01d.png#align=left&display=inline&height=340&margin=%5Bobject%20Object%5D&name=image.png&originHeight=340&originWidth=615&size=100933&status=done&style=none&width=615)
> 拦截器中的方法说明
```java
public interface HandlerInterceptor {
    /**
    * 如何调用：
    *     按拦截器定义顺序调用
    * 何时调用：
    *     只要配置了都会调用
    * 有什么用：
    *     如果程序员决定该拦截器对请求进行拦截处理后还要调用其他的拦截器，或者是业务处理器去进行处理，
    *    则返回 true。
    * 如果程序员决定不需要再调用其他的组件去处理请求，则返回 false。
    */
    default boolean preHandle(HttpServletRequest request, HttpServletResponse
    response, Object handler)throws Exception {
        return true;
    }
    /**
    * 如何调用：
    * 按拦截器定义逆序调用(栈的结构)
    * 何时调用：
    * 在拦截器链内所有拦截器返成功调用
    * 有什么用：
    * 在业务处理器处理完请求后，但是 DispatcherServlet 向客户端返回响应前被调用，
    * 在该方法中对用户请求 request 进行处理。
    */
    default void postHandle(HttpServletRequest request, HttpServletResponse
    response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }
    /**
    * 如何调用：
    * 按拦截器定义逆序调用
    * 何时调用：
    * 只有 preHandle 返回 true 才调用
    * 有什么用：
    * 在 DispatcherServlet 完全处理完请求后被调用，
    * 可以在该方法中进行一些资源清理的操作。
    */
    default void afterCompletion(HttpServletRequest request, HttpServletResponse
    response, Object handler,  @Nullable Exception ex) throws Exception {
    }
}

拦截器的作用路径

作用路径可以通过在配置文件中配置。
<!-- 配置拦截器的作用范围 -->
<mvc:interceptors>
  <mvc:interceptor>
    <mvc:mapping path="/**" /><!-- 用于指定对拦截的 url -->
    <mvc:exclude-mapping path=""/><!-- 用于指定排除的 url-->
    <bean id="handlerInterceptorDemo1"
    class="com.itheima.web.interceptor.HandlerInterceptorDemo1"></bean>
  </mvc:interceptor>
</mvc:interceptors>

配置文件

<!-- 配置拦截器的作用范围 -->
<mvc:interceptors>
  <mvc:interceptor>
    <!-- 用于指定对拦截的 url -->
    <mvc:mapping path="/**" />
    <bean id="handlerInterceptorDemo1" class="com.itheima.web.interceptor.HandlerInterceptorDemo1"></bean>
  </mvc:interceptor>
  <mvc:interceptor>
    <mvc:mapping path="/**" />
    <bean id="handlerInterceptorDemo2" class="com.itheima.web.interceptor.HandlerInterceptorDemo2"></bean>
  </mvc:interceptor>
</mvc:interceptors>

6.3 拦截器的用户登录案例

业务需求： 1、有一个登录页面，需要写一个 controller 访问页面 2、登录页面有一提交表单的动作。需要在 controller 中处理。 2.1、判断用户名密码是否正确 2.2、如果正确向 session 中写入用户信息 2.3、返回登录成功。 3、拦截用户请求，判断用户是否登录 3.1、如果用户已经登录。放行 3.2、如果用户未登录，跳转到登录页面

控制器代码：

//登陆页面
@RequestMapping("/login")
public String login(Model model)throws Exception{
    return "login";
}
//登陆提交
//userid：用户账号，pwd：密码
@RequestMapping("/loginsubmit")
public String loginsubmit(HttpSession session,String userid,String pwd)throws Exception{
    //向 session 记录用户身份信息
    session.setAttribute("activeUser", userid);
    return "redirect:/main.jsp";
}
//退出
@RequestMapping("/logout")
public String logout(HttpSession session)throws Exception{
    //session 过期
    session.invalidate();
    return "redirect:index.jsp";
}

拦截器代码：

public class LoginInterceptor implements HandlerInterceptor{
    @Override
    Public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            //如果是登录页面则放行
            if(request.getRequestURI().indexOf("login.action")>=0)
            {
                  return true;
            }
        HttpSession session = request.getSession();
        //如果用户已登录也放行
        if(session.getAttribute("user")!=null){
        return true;
        }
        //用户没有登录挑战到登录页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,
        response);
        return false;
      }
}