02_02_SpringMVC基于注解的应用

一、请求处理

1、常用注解

@RequestMapping
- 作用：用来匹配客户端发送的请求（用来处理URL映射，将请求映射到处理方法中），可以在类或者方法上使用。
  - 用在类上，可以将请求模块化，避免请求方法中的映射重复。表示为当前控制器类中的所有方法添加一个前置路径。
  - 用在方法上，表示用来匹配要处理的请求（注意：在整个项目的不同方法上不能出现URL重复的情况）。
- 相关属性：
  - value：要匹配的请求路径
  - method：显示发送请求的方式（GET、POST、PUT、DELETE）
  - params：表示请求要接收的参数，如果定义了该属性，那么发送请求时必须要携带该参数；
  - headers：填写请求头信息;
  - consumers：设置接收的请求的内容类型，相当于指定Content-type;
  - produces：设置返回的内容类型；
  java 复制代码
```
 @RequestMapping(value = "/test",method = RequestMethod.GET,params = "entname",headers = {"User‐Agent=Mozilla/5.0 (Windows NT 10.0;"})
    public String test(){
        return "/index.jsp";
    }
```
@RequestParam
- 作用：获取请求中的参数值
- 相关属性
  - value：表示要获取的参数值；
  - required：表示请求时此参数是否必须传递，默认是true，如果请求中不存在该参数就会报错，如果值为false，则不做强制要求，可有可无；
  - defaultValue：如果在使用的时没有传递该参数，那么就使用定义的默认值；
- 默认情况下，可以直接将方法中的参数名设置为跟请求中的参数名一样，此时会默认接收请求中该参数名的参数值；
  java 复制代码
```
@RequestMapping("/Hello")
public String helloWorld(@RequestParam(value = "username",defaultValue = "开发者",required = false) String name){
    System.out.println("hello springmvc："+ name);
}
```
@RequestHeader
- 作用：获取请求头的信息
- 相关属性：value、required、defaultValue
- 如果要获取请求头中没有的信息，此时会报错；
  java 复制代码
```
@RequestMapping("/header")
public String header(@RequestHeader("User‐Agent") String agent){ 
      System.out.println(agent);
	  return "success";
}
```
复制代码
@CookieValue
- 作用：获取cookie中的值
- 相关属性：value、required、defaultValue
- 如果要获取cookie中没有的信息，此时会报错；
- 等同于request.getCookies();
  java 复制代码
```
@RequestMapping("/cookie")
 public String cookie(@CookieValue("JSESSIONID") String id){
	 System.out.println(id);
	 return "success";
 }
```

@PathVariable

作用：获取请求路径中的参数
如果是单个参数接收，必须使用@PathVariable来声明获取对应的参数占位符的值；

如果是JavaBean，则可以省略@PathVariable，但要保证各个占位符的参数名与JavaBean中的属性名一致；

java 复制代码

@RequestMapping("/user/{id}/{username}")
public String path01(@PathVariable("id") Integerid,@PathVariable("username")String name){
	System.out.println(id);
	System.out.println(name);
	return "/index.jsp";
}

@RequestMapping("/user02/{id}/{name}")
public String path02(User user){
	System.out.println(user);
	return "/index.jsp";
}

2、REST风格

它是一种客户端映射到服务器资源的架构设计；
它是一种针对网络应用的设计和开发方式，可以降低开发的复杂性，提高系统的可伸缩性；
是一种更优雅的URL风格；

通过URL我们就可以知道这个请求是用来做什么的；

java 复制代码

 @GetMapping("/rest/getuser/{uid}")
 public String getUser(@PathVariable("uid") Integer id ){
       System.out.println("hello springmvc GET："+ id);
       return "/index.jsp";
  }

 @PostMapping("/rest/addUser")
 public String addUser(User user){
       System.out.println("hello springmvc POST："+ user);
       return "/index.jsp";
  }

 @PutMapping("/rest/updateUser")
 public String updateUser(User user){
       System.out.println("hello springmvc PUT："+ user);
       return "redirect:/index2.jsp";
  }

  @DeleteMapping("/rest/deleteUser/{uid}")
  public String deleteUser(@PathVariable("uid") Integer id ){
       System.out.println("hello springmvc DELETE："+ id);
       return "redirect:/index2.jsp";
 }

3、静态资源的访问

当页面中直接使用静态资源时，是没办法直接获取到的，是因为找不到对应的mapping映射，DispatcherServlet会拦截所有的请求，而此时我们没有对应图片的请求处理方法。此时只需要在springmvc.xml中添加如下配置即可：

xml 复制代码

	<!--配置访问静态资源-->
    <mvc:annotation-driven/>
    <!--设置资源的映射位置：将映射地址直接指向静态资源文件夹，springmvc不会将此映射作为handler-->
    <mvc:resources mapping="/images/**" location="/images/"/>
    <!--当springmvc没有映射到某一个请求时，就会调用默认的servlet来处理-->
    <mvc:default-servlet-handler/>

二、响应处理

1、视图解析器

默认的内置视图解析器

xml 复制代码

 <!--默认的视图解析器-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

2、视图控制器

xml 复制代码

<!--视图控制器：设置某个路径映射到指定的jsp页面-->
  <mvc:view-controller path="/" view-name="index"></mvc:view-controller>

3、使用Model，Map，ModelMap传输数据到页面

当使用以下三种方式设置之后，所有的参数值都设置到了request的作用域中；
${requestScope.type}

java 复制代码

  /**
     * 通过Servlet原生API将数据传输到视图中
     * @param request
     * @return
     */
    @RequestMapping("/servlet")
    public String servletApi(HttpServletRequest request){
        request.setAttribute("type","servletAPI");
        return "main";
    }

    /**
     * 通过Model将数据传输到视图中
     * @param model
     * @return
     */
    @RequestMapping("/model")
    public String modelAttribute(Model model){
        model.addAttribute("type","modelAttribute");
        return "main";
    }


    /**
     * 通过ModelMap将数据传输到视图中
     * @param modelMap
     * @return
     */
    @RequestMapping("/modelMap")
    public String modelMapAttribute(ModelMap modelMap){
        modelMap.addAttribute("type","modelMapAttribute");
        return "main";
    }

    /**
     * 通过Map将数据传输到视图中
     * @param map
     * @return
     */
    @RequestMapping("/map")
    public String map(Map map){
        map.put("type","map");
        return "main";
    }

4、使用ModelAndView对象传输数据到页面

使用ModelAndView对象时，返回值类型也是该对象，可以将要跳转的页面设置为view的名称，来完成跳转功能，同时，数据也是存放到了request作用域中；
springmvc还会隐式的将请求绑定的参数自动设置到request域中；

java 复制代码

  /**
     * 通过ModelAndView将数据传输到视图中
     * @return
     */
    @RequestMapping("/modelAndView")
    public ModelAndView modelAndView(){
        ModelAndView modelAndView = new ModelAndView("main");
        modelAndView.addObject("type", "modelAndView");
        return modelAndView;
    }

5、使用session传输数据到页面

方式一：通过Servlet API的方式读写session
- 通过参数绑定的方式去获取Servlet API
- 通过自动注入的方式去获取Servlet API(推荐使用这种方式）
- ${sessionScope.type}

java 复制代码

 /**
     * 通过HttpSession将数据传输到视图中
     * @param session
     * @return
     */
    @RequestMapping("/session")
    public String session(HttpSession session){
        session.setAttribute("type","servletApi-session");
        return "main";
    }

    //自动注入
    @Autowired
    private HttpSession session;

    @RequestMapping("/autoSession")
    public String autoSession() {
        session.setAttribute("type","auto-session");
        return "main";
    }

方式二：通过注解的方式读取session
- @SessionAttributes
  - 用在类上，表示当前控制器类下的所有方法，都会将model指定的属性写入session。
  - 它会从model中获取指定的属性写入session中。即：底层会从model中找一个叫type的属性写到session中，这种方式是依赖model的。
- @SessionAttribute
  - 用在参数上，读取session。
  - model和session是互通的：session可以通过model中去获取写入指定的属性， model也会从session中自动写入指定的属性。

java 复制代码

	@Controller
	@SessionAttributes("type")
	public class DTVController {
		@RequestMapping("/getSession")
		public String getSession(@SessionAttribute(value="type",required = false) String type){
		  System.out.println(type);
		   return "main";
		}
	}

6、转发和重定向

转发的特点 ：
- a、地址栏的url从始至终都不会变
- b、请求次数，仅只有一次
- c、请求域中的数据不会丢失
- d、根目录包含了项目的访问地址，所以，不用写完成的访问地址，只需要写明转发的视图即可：/index2.jsp
重定向的特点 ：
- a、地址栏的url会发生变化，第一次：初识地址（localhost:8080/springmvc/）；第二次：重定向地址（localhost:8080/springmvc/index2.jsp）
- b、请求次数，两次
- c、请求域中的数据会丢失,因为是不同的请求
- d、根目录不包含项目的访问地址

java 复制代码

 @RequestMapping("/Hello")
    public String helloWorld(@RequestParam(value = "name",defaultValue = "开发者",required = false) String name){
        System.out.println("hello springmvc："+ name);
        
//        return "index"; //默认是转发，会自动添加前缀，所以，不需要写前缀，直接写视图名即可

//        return "forward:/index.jsp";  // forward 则需要自己显示添加完整的视图名和路径，不会参与视图解析器的处理

        return "redirect:/index2.jsp"; //重定向的视图，必须存放在根目录下，不能放到WEB-INF目录下
    }

三、JSON处理

需要添加解析json的依赖

xml 复制代码

 		<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.8</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.8</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>

1、返回JSON数据

1、加入jackjson依赖
2、将jackjson的jar包加入WEB-INF的lib文件夹中
3、在对应处理方法上加上@ResponseBody注解，用于标记该处理方法返回json
4、或者将类上的@Controller改为@RestController注解，表示标记该类中所有的方法都返回json
5、@RestController相当于 @Controller + @ResponseBody

java 复制代码

@Controller
public class JsonController {

    @RequestMapping("/testJson01")
    @ResponseBody //如果返回值是字符串类型，则返回值以文本形式返回，而不是返回视图逻辑名称
    public String responseJson01(){
        System.out.println("testJson");
        return "json";
    }
    
    @RequestMapping("/testJson02")
    @ResponseBody
    public User responseJson02(){
        User user = new User();
        user.setId(1001);
        user.setName("张三");
        user.setAlias(new String[]{"张三丰","张无忌"});
        user.setBirthday(new Date());
        return user;
    }

2、获取JSON数据

使用@RequestBody来接收前端发送的json数据

java 复制代码

	@RequestMapping("/testJson03")
    @ResponseBody
    public User responseJson03(@RequestBody User user){
        User user2 = new User();
        user.setId(1002);
        user.setName("张三");
        user.setAlias(new String[]{"张三丰","张无忌"});
        user.setBirthday(new Date());
        System.out.println(user);
        return user2;
    }

四、文件上传和下载

1、文件下载

使用Servlet原生API实现文件下载

java 复制代码

 @RequestMapping("/download")
    public void downLoad(HttpServletRequest request, HttpServletResponse response) throws IOException {
        //获取要下载的文件的绝对路径
        String realPath = request.getServletContext().getRealPath("/images/123.png");
        //根据文件路径封装成文件对象
        File tmpFile=new File(realPath);
        //获取文件名称
        String fileName = tmpFile.getName();
        //设置响应头 content‐disposition，就是设置文件下载的打开方式，默认会在浏览器上打开，设置UTF-8,如果文件名称有中文，不会乱码
        response.setHeader("content-disposition", "attachment;filename="+ URLEncoder.encode(fileName, "UTF-8"));
        //获取文件输入流
        InputStream in = Files.newInputStream(Paths.get(realPath));
        int len = 0;
        //创建缓冲区
        byte[] buffer = new byte[1024];
        //获取输出流
        OutputStream out = response.getOutputStream();
        //循环读取文件，每次读1KB，防止内存溢出
        while ((len = in.read(buffer)) > 0) {
            //将缓冲区的数据输出到客户端浏览器
            out.write(buffer,0,len);
        }
        in.close();
    }

2、文件上传

Spring MVC 为文件上传提供了直接的支持，这种支持是通过 MultipartResolver 实现的。Spring 用 Jakarta Commons FileUpload 技术实现了一个 MultipartResolver 实现类：CommonsMultipartResovler。
Spring MVC 上下文中默认没有装配 MultipartResovler，因此默认情况下不能处理文件的上传工作，如果想使用 Spring 的文件上传功能，需现在上下文中配置 MultipartResolver。
添加Jakarta Commons FileUpload的依赖支持

xml 复制代码

	<dependency>
       <groupId>commons-fileupload</groupId>
       <artifactId>commons-fileupload</artifactId>
       <version>1.4</version>
    </dependency>

配置MultipartResolver文件上传解析器

xml 复制代码

	<bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver" id="multipartResolver">
		<!--设置编码，避免中文乱码-->
        <property name="defaultEncoding" value="UTF-8"/>
        <!--设置上传文件的大小-->
        <property name="maxUploadSize" value="#{1024*1024*10}"/>
   </bean>

代码实现

java 复制代码

 	@RequestMapping("/upload")
    public String upload(@RequestParam("desc") String desc,@RequestParam("uploadFile") MultipartFile multipartFile) throws IOException {
        System.out.println("des:" + desc);
        System.out.println("uploadFile:" + multipartFile.getOriginalFilename());
        if (!multipartFile.isEmpty()) {
            //获取文件上传的绝对路径
            String realPath = "C:\\Users\\TRS\\Desktop\\Out";
            //获取文件名称
            String fileName = multipartFile.getOriginalFilename();
            //创建文件对象
            File tmpFile;
            if (fileName != null) {
                tmpFile = new File(realPath, fileName);
                //将文件写入到指定目录
                multipartFile.transferTo(tmpFile);
            }
        }
        return "Success";
    }

五、拦截器

1、实现过程

SpringMVC拦截器采用AOP的设计思想，它跟过滤器类似，用来拦截处理方法在之前或者之后执行一些跟主业务没有关系的公共功能。比如：权限控制、日志记录、异常记录等
实现拦截器的步骤：
- 1、实现接口：HandlerInterceptor
- 2、重写三个方法：preHandle、postHandle、afterCompletion
- 3、在springmvc.xml的配置文件中装配拦截器

preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
- 预处理回调方法，实现处理器方法的预处理（如：登录检查）；
- 第三个参数为响应的处理器返回值；
- true 表示放行，继续向下执行（如调用下一个拦截器或处理器）；
- false 表示拦截（如登录检查失败），终止执行。此时我们需要通过response来产生响应；
postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
- 后处理回调方法，实现处理器的后处理（但在渲染视图之前）;
- 此时我们可以通过modelAndView（模型和视图对象）对模型数据进行处理或对
  视图进行处理，modelAndView也可能为null;
afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
- 请求处理完毕后回调方法，在视图渲染完后执行；
- 如性能监控中我们可以在此记录结束时间并输出消耗时间，还可以进行一些资源清
  理，类似于trycatchfinally中的finally，但仅当上面的preHandle方法返回true时才会执行。
自定义拦截器

java 复制代码

@Component
public class MyInterceptor implements HandlerInterceptor {

    /**
     * 执行1【Controller执行器中的处理方法执行之前执行】
     * @param request 可以在方法请求之前更改request中的属性值
     * @param response
     * @param handler 处理器对象，封装了当前这个处理方法的信息
     * @return
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        System.out.println("============>>>>preHandle()方法执行");
        //在请求映射到对应的处理方法映射时，实现类才是HandlerMethod，如果是视图控制器，则实现类是ParameterizableViewController
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        System.out.println("处理方法所在类："+handlerMethod.getBean().getClass().getName());
        System.out.println("处理方法的方法名："+handlerMethod.getMethod().getName());
        System.out.println("处理方法的参数：" + Arrays.toString(handlerMethod.getMethod().getParameters()));

        return true; //返回true表示放行，返回false表示拦截
    }

    /**
     * 执行2【Controller执行器中的处理方法执行之后，此时还没渲染视图】
     * 当处理方法出现异常时，则不会执行该方法
     * @param request
     * @param response 可以在方法执行之后去更改response中的信息
     * @param handler
     * @param modelAndView 封装了model和视图信息，当请求结束后可以去修改model中的数据或者视图信息
     * @throws Exception
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        System.out.println("=========>>>postHandle()方法执行");
    }

    /**
     * 执行3【DispacherServlet执行之后，渲染视图之后执行】
     * 如果preHandle返回false，则不会执行该方法
     * @param request
     * @param response
     * @param handler
     * @param ex 在该方法中做一些记录异常日志的功能
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        System.out.println("==========>>>afterCompletion()方法执行");
    }
}

装配拦截器

xml 复制代码

 <!--配置拦截器-->
    <mvc:interceptors>
        <!--它会拦截SpringMVC所有的请求-->
        <bean class="org.example.interceptor.MyInterceptor"></bean>
    </mvc:interceptors>

2、拦截器与过滤器的区别

过滤器是基于函数回调的，而拦截器是基于java反射的；
过滤器依赖于servlet容器，而拦截器不依赖与Servlet容器，依赖于SpringMVC；
过滤器几乎对所有的请求都可以起作用，而拦截器只能对SpringMVC请求起作用；
拦截器可以访问处理方法的上下文，而过滤器不可以；

3、使用拦截器实现登录权限拦截

自定义用户登录拦截器

java 复制代码

public class UserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        System.out.println("当前用户名："+ session.getAttribute("username"));
        if (!"张三".equals(session.getAttribute("username"))) {
            //重定向到登录页面
            response.sendRedirect(request.getContextPath() + "/login");
            return false;
        }else {
            return true;
        }
    }
 }

设置拦截请求映射

xml 复制代码

<!--配置拦截器-->
    <mvc:interceptors>
        <!--直接配置一个bean它会拦截SpringMVC所有的请求-->
        <bean class="org.example.interceptor.MyInterceptor"></bean>
        <!--如果不需要拦截所有的请求，可以单独配置-->
        <mvc:interceptor>
            <!--需要拦截的请求-->
            <mvc:mapping path="/**"/>
            <!--不需要拦截的请求-->
            <mvc:exclude-mapping path="/login"/>
            <!--拦截器-->
            <bean class="org.example.interceptor.UserInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

六、异常处理

1、内置异常处理解析器

在SpringMVC中拥有一套非常强大的异常处理机制，SpringMVC通过HandlerExceptionResolver处理程序的异常，包括请求映射、数据绑定以及目标方法执行时发生的异常。
通过@ExceptionHandler可以在方法中记录日志，并转发到一个友好的界面进行提示；

java 复制代码

@Controller
public class ExceptionController {

    @RequestMapping("/hello")
    public String testException(@RequestParam(value = "name") String name) {
        System.out.println("方法执行中...");
        return "index";
    }

    //只能处理当前处理器类的异常，但是优先级要比全局异常处理器高
    @ExceptionHandler(value = {Exception.class})
    public ModelAndView handleException(Exception e) {
        ModelAndView mv = new ModelAndView();
        mv.setViewName("exception");
        mv.addObject("ex", e);
        System.out.println(e.getMessage());
        return mv;
    }
}

2、全局统一异常处理

如果想要对所有的控制器类进行统一异常处理，可以通过@ControllerAdvice注解来实现。
@ControllerAdvice 是Spring3.2提供的新注解，它是对Controller的增强，可对Controller中被 @RequestMapping注解标识的方法加一些逻辑处理: 全局异常处理、全局数据绑定、全局数据预处理；
全局异常处理的实现步骤：
- 添加@ControllerAdvice注解
- 添加@ExceptionHandler注解
- 处理器中自己的异常处理器优先级高于全局异常处理
- 如果处理器类中存在异常处理方法，则优先使用处理器异常处理方法，否则，使用全局异常处理中的异常（精准异常 > 全局异常）
统一异常处理：同时处理普通请求和ajax请求
- 普通请求：返回ModelAndView对象，跳转到指定页面
- ajax请求：返回json数据

java 复制代码

	@ControllerAdvice
	public class GolablExceptionController {

       @ExceptionHandler(value = {Exception.class})
       public ModelAndView handleException(HttpServletRequest request, HttpServletResponse response, HandlerMethod handler, Exception e) {
           System.out.println("全局异常处理");
           ModelAndView mv = new ModelAndView();

           //1、根据用户请求的处理方法，判断是否是ajax请求
           RestController restAnnotation = handler.getClass().getAnnotation(RestController.class);//获取类上某个注解
           ResponseBody resAnnotation = handler.getMethod().getAnnotation(ResponseBody.class);//获取方法上某个注解
           //2、可以根据请求头中的类型，判断是否是ajax请求,即：Content-Type是否包含 application/json
           if (restAnnotation != null || resAnnotation != null) {
               //ModelAndView支持返回json
                mv = new ModelAndView(new MappingJackson2JsonView());
                mv.addObject("方法名", handler.getMethod().getName());
                mv.addObject("ex", e.getMessage());
                mv.addObject("code", HttpStatus.INTERNAL_SERVER_ERROR.value());
           }else {
               //返回视图
               mv.setViewName("exception");
               mv.addObject("ex", e);
               StringWriter stringWriter = new StringWriter();
               PrintWriter printWriter = new PrintWriter(stringWriter);
               e.printStackTrace(printWriter);
               System.out.println(stringWriter); //日志记录
           }

           return mv;
       }