拦截器

监听器、过滤器和拦截器对比

Servlet：处理Request请求和Response响应
过滤器（Filter）：对Request请求起到过滤的作⽤，作⽤在Servlet之前，如果配置为/*可以对所有的资源访问（servlet、js/css静态资源等）进⾏过滤处理
监听器（Listener）：实现了javax.servlet.ServletContextListener 接⼝的服务器端组件，它随Web应⽤的启动⽽启动，只初始化⼀次，然后会⼀直运⾏监视，随Web应⽤的停⽌⽽销毁
- 作⽤⼀：做⼀些初始化⼯作，web应⽤中spring容器启动ContextLoaderListener
- 作⽤⼆：监听web中的特定事件，⽐如HttpSession,ServletRequest的创建和销毁；变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监控，⽐如统计在线⼈数，利⽤HttpSessionLisener等。
拦截器（Interceptor）：是SpringMVC、Struts等表现层框架⾃⼰的，不会拦截jsp/html/css/image的访问等，只会拦截访问的控制器⽅法（Handler）。从配置的⻆度也能够总结发现：serlvet、fifilter、listener是配置在web.xml中的，⽽interceptor是配置在表现层框架⾃⼰的配置⽂件中的
- 在Handler业务逻辑执⾏之前拦截⼀次
- 在Handler逻辑执⾏完毕但未跳转⻚⾯之前拦截⼀次
- 在跳转⻚⾯之后拦截⼀次

拦截器的执⾏流程

在运⾏程序时，拦截器的执⾏是有⼀定顺序的，该顺序与配置⽂件中所定义的拦截器的顺序相关。 单个拦截器，在程序中的执⾏流程如下图所示：

1）程序先执⾏preHandle()⽅法，如果该⽅法的返回值为true，则程序会继续向下执⾏处理器中的⽅法，否则将不再向下执⾏。
2）在业务处理器（即控制器Controller类）处理完请求后，会执⾏postHandle()⽅法，然后会通过DispatcherServlet向客户端返回响应。
3）在DispatcherServlet处理完请求后，才会执⾏afterCompletion()⽅法。

⾃定义SpringMVC拦截器步骤如下：

1.编写HandlerInterceptor接口的实现类，如下：

/**
 * 自定义springmvc拦截器
 */
public class MyIntercepter01 implements HandlerInterceptor {


    /**
     * 会在handler方法业务逻辑执行之前执行
     * 往往在这里完成权限校验工作
     * @return  返回值boolean代表是否放行，true代表放行，false代表中止
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyIntercepter01 preHandle......");
        return true;
    }


    /**
     * 会在handler方法业务逻辑执行之后尚未跳转页面时执行
     * @param modelAndView  封装了视图和数据，此时尚未跳转页面呢，你可以在这里针对返回的数据和视图信息进行修改
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyIntercepter01 postHandle......");
    }

    /**
     * 页面已经跳转渲染完毕之后执行
     * @param ex  可以在这里捕获异常
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyIntercepter01 afterCompletion......");
    }
}

2.在springmvc.xml配置文件中配置拦截器，如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd
">
    
    <!--开启controller扫描-->
    <context:component-scan base-package="com.lagou.edu.controller"/>


    <!--配置springmvc的视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>


    <!--
        自动注册最合适的处理器映射器，处理器适配器(调用handler方法)
    -->
    <mvc:annotation-driven />

    <!--静态资源配置，方案二，SpringMVC框架自己处理静态资源
        mapping:约定的静态资源的url规则
        location：指定的静态资源的存放位置

    -->
    <mvc:resources location="classpath:/"  mapping="/resources/**"/>
    <mvc:resources location="/WEB-INF/js/" mapping="/js/**"/>

    <!-- 配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--配置当前拦截器的url拦截规则，**代表当前目录下及其子目录下的所有url-->
            <mvc:mapping path="/**"/>
            <!--exclude-mapping可以在mapping的基础上排除一些url拦截-->
            <!--<mvc:exclude-mapping path="/demo/**"/>-->
            <bean class="com.lagou.edu.interceptor.MyIntercepter01"/>
        </mvc:interceptor>

    </mvc:interceptors>
</beans>

多个拦截器的执⾏流程

配置两个自定义的拦截器如下：

MyIntercepter01类如下：

/**
 * 自定义springmvc拦截器
 */
public class MyIntercepter01 implements HandlerInterceptor {


    /**
     * 会在handler方法业务逻辑执行之前执行
     * 往往在这里完成权限校验工作
     * @return  返回值boolean代表是否放行，true代表放行，false代表中止
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyIntercepter01 preHandle......");
        return true;
    }


    /**
     * 会在handler方法业务逻辑执行之后尚未跳转页面时执行
     * @param modelAndView  封装了视图和数据，此时尚未跳转页面呢，你可以在这里针对返回的数据和视图信息进行修改
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyIntercepter01 postHandle......");
    }

    /**
     * 页面已经跳转渲染完毕之后执行
     * @param ex  可以在这里捕获异常
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyIntercepter01 afterCompletion......");
    }
}

MyIntercepter02类如下：

/**
 * 自定义springmvc拦截器
 */
public class MyIntercepter02 implements HandlerInterceptor {

    /**
     * 会在handler方法业务逻辑执行之前执行
     * 往往在这里完成权限校验工作
     * @return  返回值boolean代表是否放行，true代表放行，false代表中止
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyIntercepter02 preHandle......");
        return true;
    }


    /**
     * 会在handler方法业务逻辑执行之后尚未跳转页面时执行
     * @param modelAndView  封装了视图和数据，此时尚未跳转页面呢，你可以在这里针对返回的数据和视图信息进行修改
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyIntercepter02 postHandle......");
    }

    /**
     * 页面已经跳转渲染完毕之后执行
     * @param ex  可以在这里捕获异常
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyIntercepter02 afterCompletion......");
    }
}

两个拦截器在springmvc.xml配置文件的配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd
">  
    <!--开启controller扫描-->
    <context:component-scan base-package="com.lagou.edu.controller"/>

    <!--配置springmvc的视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--
        自动注册最合适的处理器映射器，处理器适配器(调用handler方法)
    -->
    <mvc:annotation-driven/>

    <!--静态资源配置，方案二，SpringMVC框架自己处理静态资源
        mapping:约定的静态资源的url规则
        location：指定的静态资源的存放位置

    -->
    <mvc:resources location="classpath:/"  mapping="/resources/**"/>
    <mvc:resources location="/WEB-INF/js/" mapping="/js/**"/>

    <mvc:interceptors>
        <mvc:interceptor>
            <!--配置当前拦截器的url拦截规则，**代表当前目录下及其子目录下的所有url-->
            <mvc:mapping path="/**"/>
            <!--exclude-mapping可以在mapping的基础上排除一些url拦截-->
            <!--<mvc:exclude-mapping path="/demo/**"/>-->
            <bean class="com.lagou.edu.interceptor.MyIntercepter01"/>
        </mvc:interceptor>

        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.lagou.edu.interceptor.MyIntercepter02"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

启动项目，在控制打印的日志如下：

从图可以看出，当有多个拦截器同时⼯作时，它们的preHandle()⽅法会按照配置⽂件中拦截器的配置顺序执⾏，⽽它们的postHandle()⽅法和afterCompletion()⽅法则会按照配置顺序的反序执⾏。

所以多个自定义拦截器的执行流程如下图所示

ControllerAdvice注解

该注解顾名思义是一个增强器，是对注解了@Controller注解的类进行增强。
该注解使用@Component注解，这样的话当我们使用<context:component-scan>扫描时也能扫描到。
该注解内部使用@ExceptionHandler、@InitBinder、@ModelAttribute注解的方法会应用到所有的Controller类中 @RequestMapping注解的方法。

简单代码演示如下：

/**
 * @ControllerAdvice用于增强controller
 */
@ControllerAdvice
public class MyControllerAdvice {

   // 应用到所有@RequestMapping注解方法，在其执行之前把返回值放入ModelMap中，即request域中
   @ModelAttribute
   public Map<String, Object> before() {
      Map<String, Object> map = new HashMap<>();
      map.put("name", "tom");
      return map;
   }
   
   // 应用到所有【带参数】的@RequestMapping注解方法，在其执行之前初始化数据绑定器
   @InitBinder
   public void initBinder(WebDataBinder dataBinder) {
      DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
      // 给数据绑定器注册一个新的属性编辑器(第一个参数是目标类型，第二个参数是自定义编辑器)
      dataBinder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
      System.out.println("...initBinder...");
   }

   // 应用到所有@RequestMapping注解的方法，在其抛出指定异常时执行
   @ExceptionHandler(value = IOException.class)
   @ResponseBody
   public String handleException(Exception ex) {
      // 异常处理思路
      // 自定义预期异常
      CustomException customException = null;
      // 如果抛出的是系统自定义的异常
      if (ex instanceof CustomException) {
         customException = (CustomException) ex;
      } else {
         customException = new CustomException("未知错误");
      }
      return customException.getMsg();
   }
}

@ModelAttribute

就是将数据放入Model中，即作用域中，然后可以在页面中展示该数据。

该注解特点： 主要作用于ModelMap这个模型对象的，将方法返回值数据存入到request作用域中，用于在视图中显示数据。
该注解注意事项： 和@ResponseBody注解的使用是互斥的。

作用于方法

（有没有@RequestMapping注解的方法都可以）

非@RequestMapping注解方法

执行时机：在本类内所有@RequestMapping注解方法之前执行，这样该注解方法的返回值存入到request作用域中，便于其他带有@RequestMapping注解方法进行使用。

作用：

如果方法有返回值，则直接将该返回值放入ModelMap中，key可以指定。

@ControllerAdvice
public class Hello2ModelController {
    
    /**
     * 直接将该返回值放入ModelMap中，key可以指定
     */
    @ModelAttribute 
    public User populateModel() {  
       User user=new User();
       user.setAccount("ray");
       return user;
    }  
    @RequestMapping(value = "/helloWorld2")  
    public String helloWorld() {  
       return "helloWorld.jsp";  
    }  
}

如果方法没有返回值，则可以利用它的执行时机这一特点，做一些预处理。

@ControllerAdvice
public class HelloModelController {
    
    /**
     * 如果方法没有返回值，则可以利用它的执行时机这一特点，做一些预处理。
     */
    @ModelAttribute 
    public void populateModel(@RequestParam String abc, Model model) {  
       model.addAttribute("attributeName", abc);  
    }  

    @RequestMapping(value = "/helloWorld")  
    public String helloWorld() {  
       return "helloWorld.jsp";  
    }  
}

有@RequestMapping注解方法

作用：
- 返回值会放入ModelMap中
- 逻辑视图名称根据请求URL生成，比如URL：item/findItem，那么这个URL就是逻辑视图名称

@ControllerAdvice
public class HelloModelController {
    
    /**
     * 即会去根路径下寻找/helloWorld/helloWorld.jsp
     */
    @RequestMapping(value = "/helloWorld") 
    @ModelAttribute
    public String helloWorld() {  
       return "helloWorld.jsp";  
    }  
}

作用于方法参数

（有@RequestMapping注解的方法）

STEP1：获取ModelMap中指定的数据（由@ModelAttribute注解的方法产生）
STEP2：将使用该注解的参数对象放到ModelMap中。
如果STEP1和STEP2中的对象在ModelMap中key相同，则合并这两部分对象的数据。

//对象合并使用方式，比如一个用户的大部分信息都是从数据库获取出来的，而表单过来的数据只有一个，此时使用对象合并就会方便很多
@Controller
public class Hello2ModelController {
    
    /**
     * 由于该方法没有@RequestMapping注解，所以该方法会在所有的@RequestMapping注解方法之前执行
     * 将返回值存入到request作用域当中,key为myUser，value为返回的对象值
     */
    @ModelAttribute("myUser")
    public User populatesModel() {  
       User user=new User();
       user.setAccount("ray");
       return user;
    }  
    
    /**
     * 可以获取到上面方法往request作用域当中存入的user对象值
     */
    @RequestMapping(value = "/helloWorld2")  
    public String helloWorld(@ModelAttribute("myUser") User user) {
        user.setName("老王");
       return "helloWorld.jsp";  
    }  
}

@InitBinder

介绍

由 @InitBinder 标识的方法，可以通过PropertyEditor解决数据类型转换问题，比如String-->Date类型。不过PropertyEditor只能完成String-->任意类型的转换，这一点不如Converter灵活，Converter可以完成任意类型-->任意类型的转换。

它可以对 WebDataBinder 对象进行初始化，WebDataBinder 是 DataBinder 的子类,用于完成由表单字段到 JavaBean 属性的绑定。

注意事项：

@InitBinder方法不能有返回值,它必须声明为void。
@InitBinder方法的参数通常是 WebDataBinder。

代码演示如下：

/**
 * @ControllerAdvice用于增强controller
 */
@ControllerAdvice
public class MyControllerAdvice {
    
   // 应用到所有【带参数】的@RequestMapping注解方法，在其执行之前初始化数据绑定器
   //将字符串转Date类型
   @InitBinder
   public void initBinder(WebDataBinder dataBinder) {
      DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
      // 给数据绑定器注册一个新的属性编辑器(第一个参数是目标类型，第二个参数是自定义编辑器)
      dataBinder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
      System.out.println("...initBinder...");
   }
}

@ExceptionHandler

介绍

这个注解表示Controller中任何一个@RequestMapping方法发生异常，则会被注解了@ExceptionHandler的方法拦截到。拦截到对应的异常类则执行对应的方法，如果都没有匹配到异常类，则采用近亲匹配的方式。

使用

/**
 * @ControllerAdvice用于增强controller
 */
@ControllerAdvice
public class MyControllerAdvice {

   // 应用到所有@RequestMapping注解的方法，在其抛出指定异常时执行
   @ExceptionHandler(value = IOException.class)
   @ResponseBody
   public String handleException(Exception ex) {
      // 异常处理思路
      // 自定义预期异常
      CustomException customException = null;
      // 如果抛出的是系统自定义的异常
      if (ex instanceof CustomException) {
         customException = (CustomException) ex;
      } else {
         customException = new CustomException("未知错误");
      }
      return customException.getMsg();
   }
}

HandlerExceptionResolver

异常理解

异常包含编译时异常和运行时异常，其中编译时异常也叫预期异常。

运行时异常只有在项目运行的情况下才会发现，编译的时候不需要关心。

运行时异常，比如：空指针异常、数组越界异常，对于这样的异常，只能通过程序员丰富的经验来解决和测试人员不断的严格测试来解决。
编译时异常，比如：数据库异常、文件读取异常、自定义异常等。对于这样的异常，必须使用try catch代码块或者throws关键字来处理异常。

异常处理思路

系统中异常包括两类：预期异常（编译时异常）和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。

系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理，如下图：

全局范围只有一个异常处理器。

自定义异常类

为了区别不同的异常通常根据异常类型自定义异常类，这里我们创建一个自定义系统异常，如果controller、service、dao抛出此类异常说明是系统预期处理的异常信息。

public class BusinessException extends Exception {
    
    private static final long serialVersionUID = 1L;
    //异常信息
    private String message;
    
    public BusinessException(String message) {
        super(message);
        this.message = message;
    }
    
    public String getMessage() {
        return message;
    }
    
    public void setMessage(String message) {
        this.message = message;
    }
}

自定义异常处理器

public class BusinessExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex) {
        
        //自定义预期异常
        BusinessException businessException = null; 
        //如果抛出的是系统自定义的异常
        if(ex instanceof BusinessException){
            businessException = (BusinessException) ex;
        }else{
            businessException = new BusinessException("未知错误");
        }
        
        ModelAndView modelAndView = new ModelAndView();
        //把错误信息传递到页面
        modelAndView.addObject("message", businessException.getMessage());
        //指向错误页面
        modelAndView.setViewName("error");
        return modelAndView;
    }
}

错误页面

<%@ 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>
        ${message }
    </body>
</html>

异常处理器配置

在springmvc.xml中加入以下代码：

<!-- 自定义异常处理器（全局） -->
<bean class="com.kkb.ssm.resolver.BusinessExceptionResolver"/>

异常测试

@RequestMapping(value = "/showItemEdit")
public String showItemEdit(Integer id,Model model) throws Exception{
    // 查询要显示的商品内容
    Item item = itemService.queryItemById(id);
    if(item == null) {
        throw new BusinessException("查询不到商品无法修改");
    }
    model.addAttribute("item", item);
    // 由于配置了ViewResolver，所以此处只写逻辑视图名称即可
    return "item/item-edit";
}

文件下载

正常访问资源时响应头如果没有设置 Content-Disposition,响应数据时浏览器默认按照 inline 值进行处理

inline表示浏览器能显示就显示,不能显示就下载.
attachment 表示下载,以附件形式下载.

如果想要下载文件，只需要修改响应头中设置Context-Disposition=”attachment;filename=文件名 filename=值就是下载时显示的下载文件名。

下载文件步骤如下：

1.首先引入引来如下：

<!--⽂件下载上传所需jar坐标-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency

2.编写前端代码如下：

<a href="/demo/download?fileName=a.txt">下载</a>

下载文件存放位置如下图所示

3.编写控制器处理方法，如下：

@Controller
@RequestMapping("/demo")
public class DemoController {
   @RequestMapping("download")
   public void download(String fileName,HttpServletResponse res,HttpServletRequest req) throws IOException{
      //设置响应流中文件进行下载
      res.setHeader("Content-Disposition", "attachment;filename="+fileName);
      //把二进制流放入到响应体中.
      ServletOutputStream os = res.getOutputStream();
      String path = req.getServletContext().getRealPath("files");
      System.out.println(path);
      File file = new File(path, fileName);
      byte[] bytes = FileUtils.readFileToByteArray(file);
      os.write(bytes);
      os.flush();
      os.close();
   }
}

测试结果如下图所示

文件上传

文件上传步骤如下：

1.首先引入依赖

<!--⽂件下载上传所需jar坐标-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency

2.编写前端代码，表单中的三个要求如下：

method="post"
enctype="multipart/form-data"，enctype设置请求媒体类型MIME
type="file"

<div>
    <h2>multipart 文件上传</h2>
    <fieldset>
        <%--
            1 method="post"
            2 enctype="multipart/form-data"
            3 type="file"
        --%>
        <form method="post" enctype="multipart/form-data" action="/demo/upload">
            <input type="file" name="uploadFile"/>
            <input type="submit" value="上传"/>
        </form>
    </fieldset>
</div>

3.编写文件上传Controller处理方法

/**
 * 文件上传
 * @return
 */
@RequestMapping(value = "/upload")
public String upload(MultipartFile uploadFile,HttpSession session) throws IOException {

    // 处理上传文件
    // 重命名，原名123.jpg ，获取后缀
    String originalFilename = uploadFile.getOriginalFilename();// 原始文件名称
    // 扩展名  jpg
    String ext = originalFilename.substring(originalFilename.lastIndexOf(".") + 1, originalFilename.length());
    String newName = UUID.randomUUID().toString() + "." + ext;

    // 存储,要存储到指定的文件夹，/uploads/yyyy-MM-dd，考虑文件过多的情况按照日期，生成一个子文件夹
    String realPath = session.getServletContext().getRealPath("/uploads");
    String datePath = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
    File folder = new File(realPath + "/" + datePath);

    if(!folder.exists()) {
        folder.mkdirs();
    }

    // 存储文件到目录
    uploadFile.transferTo(new File(folder,newName));
    return "文件上传成功！";
}

4.在springmvc.xml配置文件中配置文件解析器如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd
"> 
    <!--开启controller扫描-->
    <context:component-scan base-package="com.lagou.edu.controller"/>


    <!--配置springmvc的视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>


    <!--
        自动注册最合适的处理器映射器，处理器适配器(调用handler方法)
    -->
    <mvc:annotation-driven/>

    <!--静态资源配置，方案二，SpringMVC框架自己处理静态资源
        mapping:约定的静态资源的url规则
        location：指定的静态资源的存放位置

    -->
    <mvc:resources location="classpath:/"  mapping="/resources/**"/>
    <mvc:resources location="/WEB-INF/js/" mapping="/js/**"/>
 
    <!--多元素解析器
        id固定为multipartResolver
    -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--设置上传文件大小上限，单位是字节，-1代表没有限制也是默认的-->
        <property name="maxUploadSize" value="5000000"/>
    </bean>
</beans>

重定向参数传递

对于请求转发与重定向的区别如下：

重定向特点：

1.地址栏发生变化
2.重定向可以访问其他站点（服务器）的资源
3.重定向是两次请求，不能使用request对象来共享数据

转发特点：

1.转发地址栏路径不变
2.转发只能访问当前服务器下的资源
3.转发是一次请求，可以使用request对象来共享数据

简单例子：

转发：A 找 B 借钱400，B没有钱但是悄悄的找到C借了400块钱给A，url不会变,参数也不会丢失,一个请求
重定向：A 找 B 借钱400，B 说我没有钱，你找别人借去，那么A 又带着400块的借钱需求找到C，url会变,参数会丢失需要重新携带参数,两个请求。

由于重定向时请求参数会丢失，我们往往需要重新携带请求参数到新的请求【即第二次请求】中，我们可以进⾏⼿动参数拼接如下：

/**
 * @author huangshuai
 *
 */
@Controller
@RequestMapping("/demo")
public class DemoController  {

    /**
     * url: http://localhost:8080/demo/handle01
     * @ModelAttribute("name")表示获取作用域中的name变量的值
     */
    @RequestMapping("/handle01")
    public ModelAndView handle01(@ModelAttribute("name") String name) {
        Date date = new Date();// 服务器时间
        // 返回服务器时间到前端页面
        // 封装了数据和页面信息的 ModelAndView
        ModelAndView modelAndView = new ModelAndView();
        // addObject 其实是向请求域中request.setAttribute("date",date);
        modelAndView.addObject("date",date);
        // 视图信息(封装跳转的页面信息) 逻辑视图名
        modelAndView.setViewName("success");
        return modelAndView;
    }
 

    /**
     * SpringMVC 重定向时参数传递的问题
     * 转发：A 找 B 借钱400，B没有钱但是悄悄的找到C借了400块钱给A
     *      url不会变,参数也不会丢失,一个请求
     * 重定向：A 找 B 借钱400，B 说我没有钱，你找别人借去，那么A 又带着400块的借钱需求找到C
     *      url会变,参数会丢失需要重新携带参数,两个请求
     */
    @RequestMapping("/handleRedirect")
    public String handleRedirect(String name,RedirectAttributes redirectAttributes) {
        return "redirect:handle01?name=" + name;  // 拼接参数安全性、参数长度都有局限
    }
}

前端页面首先访问http://localhost:8080/demo/handleRedirect，访问到handleRedirect方法，并且携带请求参数name，该方法重定向到handle01，并且想要继续携带参数到handle01时，可以通过上述拼接的方式，即return "redirect:handle01?name=" + name;

但是上述拼接参数的⽅法属于get请求，携带参数⻓度有限制，参数安全性也不⾼，此时，我们可以使⽤SpringMVC提供的flash属性机制，向上下⽂中添加flash属性，框架会在session中记录该属性值，当跳转到⻚⾯之后框架会⾃动删除flash属性，不需要我们⼿动删除，通过这种⽅式进⾏重定向参数传递，

参数⻓度和安全性都得到了保障，如下：

/**
 * @author huangshuai
 *
 */
@Controller
@RequestMapping("/demo")
public class DemoController  {

    /**
     * url: http://localhost:8080/demo/handle01
     * @ModelAttribute("name")表示获取作用域中的name变量的值
     */
    @RequestMapping("/handle01")
    public ModelAndView handle01(@ModelAttribute("name") String name) {
        Date date = new Date();// 服务器时间
        // 返回服务器时间到前端页面
        // 封装了数据和页面信息的 ModelAndView
        ModelAndView modelAndView = new ModelAndView();
        // addObject 其实是向请求域中request.setAttribute("date",date);
        modelAndView.addObject("date",date);
        // 视图信息(封装跳转的页面信息) 逻辑视图名
        modelAndView.setViewName("success");
        return modelAndView;
    }
 

    /**
     * SpringMVC 重定向时参数传递的问题
     * 转发：A 找 B 借钱400，B没有钱但是悄悄的找到C借了400块钱给A
     *      url不会变,参数也不会丢失,一个请求
     * 重定向：A 找 B 借钱400，B 说我没有钱，你找别人借去，那么A 又带着400块的借钱需求找到C
     *      url会变,参数会丢失需要重新携带参数,两个请求
     */
    @RequestMapping("/handleRedirect")
    public String handleRedirect(String name,RedirectAttributes redirectAttributes) {
	//return "redirect:handle01?name=" + name;  // 拼接参数安全性、参数长度都有局限
	// addFlashAttribute方法设置了一个flash类型属性，该属性会被暂存到session中，在跳转到页面之后该属性销毁
	redirectAttributes.addFlashAttribute("name",name);
	return "redirect:handle01";
    }
}

Spring MVC基础（二）

拦截器