SpringMVC(四) --------- SpringMVC 核心技术

---

一、请求转发与重定向

当处理器对请求处理完毕后，向其它资源进行跳转时，有两种跳转方式：请求转发与重定向。而根据所要跳转的资源类型，又可分为两类：跳转到页面与跳转到其它处理器。

注意，对于请求转发的页面，可以是WEB-INF中页面；而重定向的页面，是不能为 WEB-INF 中页的。因为重定向相当于用户再次发出一次请求，而用户是不能直接访问 WEB-INF 中资源的。

原理图

SpringMVC 框架把原来 Servlet 中的请求转发和重定向操作进行了封装。现在可以使用简单的方式实现转发和重定向。

forward：表示转发，实现 request.getRequestDispatcher("xx.jsp").forward()
redirect：表示重定向，实现 response.sendRedirect("xx.jsp")

请求转发

处理器方法返回 ModelAndView 时，需在 setViewName()指定的视图前添加 forward:，且此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图。视图页面必须写出相对于项目根的路径。forward 操作不需要视图解析器。处理器方法返回 String，在视图路径前面加入 forward: 视图完整路径。

/*
* 处理器方法返回 ModelAndView : 实现转发到其他的视图页面
* 语法 : setViewName("forward:视图的完整路径")
* forward 关键字特点: 不和视图解析器一同工作, 就当项目中没有视图解析器
*
*/
@RequestMapping(value = "/some.do", method = RequestMethod.GET)
public ModelAndView doSome(Integer age, String name) {
   System.out.println("=========doSome========== name : " + name + "| age : " + age);
   ModelAndView mv = new ModelAndView();
   mv.addObject("myname", name);
   mv.addObject("myage", age);
   //使用forward, 显示指定转发操作, forward:视图完整路径
   //mv.setViewName("forward:/WEB-INF/view/show.jsp");
   mv.setViewName("forward:/other.jsp");
   return mv;
}

请求重定向

在处理器方法返回的视图字符串的前面添加 redirect:，则可实现重定向跳转。

/*
* 处理器方法返回ModelAndView, 实现重定向到视图页面
* 语法: mv.setViewName("redirect:视图完整路径"), 不能使用逻辑视图名称
*
*/
@RequestMapping(value = "/doRedirect.do") 
public ModelAndView doRedirect(String name, Integer age) {
    System.out.println("执行redirect重定向" + name + " " + age);
    ModelAndView mv = new ModelAndView();
    //指定视图
    mv.setViewName("redirect:/other.jsp");
    //重定向不能访问受保护的WEB-INF下面的资源
    //mv.setViewName("redirect:/WEB-INF/view/show.jsp");
    return mv;
}

二、异常处理

SpringMVC 框架处理异常的常用方式：使用@ExceptionHandler 注解处理异常。

@ExceptionHandler 注解概述

使用注解@ExceptionHandler 可以将一个方法指定为异常处理方法。该注解只有一个可选属性value，为一个 Class数组，用于指定该注解的方法所要处理的异常类，即所要匹配的异常。

而被注解的方法，其返回值可以是 ModelAndView、String，或 void，方法名随意，方法参数可以是 Exception 及其子类对象、HttpServletRequest、HttpServletResponse 等。系统会自动为这些方法参数赋值。

对于异常处理注解的用法，也可以直接将异常处理方法注解于 Controller 之中。

自定义异常类

定义三个异常类：NameException、AgeException、MyUserException。其中 MyUserException是另外两个异常的父类。

MyUserException.java

public class MyUserException extends Exception{
    public MyUserException() {
        super();
    }

    public MyUserException(String message) {
        super(message);
    }
}

NameException.java

public class NameException extends MyUserException{
    public NameException() {
        super();
    }

    public NameException(String message) {
        super(message);
    }
}

AgeException.java

public class AgeException extends MyUserException{
    public AgeException() {
        super();
    }

    public AgeException(String message) {
        super(message);
    }
}

修改 Controller 类抛出异常

@Controller
public class MyController {
     @RequestMapping(value = "/some.do", method = RequestMethod.GET)
     public ModelAndView doSome(Integer age, String name) throws MyUserException {
        System.out.println("=========doSome========== name : " + name + "| age : " + age);
        ModelAndView mv = new ModelAndView();
        if(!"zs".equals(name)) {
            throw new NameException("姓名不正确");
        }
        mv.addObject("myname", name);
        mv.addObject("myage", age);
//      使用forward, 显示指定转发操作, forward:视图完整路径
//      mv.setViewName("forward:/WEB-INF/view/show.jsp");
        mv.setViewName("forward:/other.jsp");
        return mv;
    }
    @ExceptionHandler(value=NameException.class)
    public ModelAndView doNameException(Exception e) {
         ModelAndView mv = new ModelAndView();
         mv.addObject("tips", "处理NameException");
         mv.addObject("e", e);
         mv.setViewName("nameError");
         return mv;
    }
}

定义异常响应界面

一共需要定义三个异常响应界面

不过，一般不这样使用。而是将异常处理方法专门定义在一个类中，作为全局的异常处理类。
需要使用注解@ControllerAdvice，字面理解就是 “控制器增强”，是给控制器对象增强功能的。
使用@ControllerAdvice 修饰的类中可以使用@ExceptionHandler。
当使用@RequestMapping 注解修饰的方法抛出异常时，会执行@ControllerAdvice 修饰的类中的异常处理方法。
@ControllerAdvice 是使用@Component 注解修饰的，可以扫描到@ControllerAdvice 所在的类路径(包名)，创建对象。

定义全局异常处理类

/*
* @ControllerAdvice : 控制器增强
* 处理类发生异常可以到当前类找 @ExceptionHandler
* 位置: 类的上面
*
* */
@ControllerAdvice
public class GlobalExceptionResolver {
    @ExceptionHandler(value= NameException.class)
    public ModelAndView doNameException(Exception e) {
        ModelAndView mv = new ModelAndView();
        mv.addObject("tips", "@ControllerAdvice使用注解处理NameException");
        mv.addObject("e", e);
        mv.setViewName("nameError");
        return mv;
    }
    @ExceptionHandler(value = AgeException.class)
    public ModelAndView doAgeException(Exception e) {
        ModelAndView mv = new ModelAndView();
        mv.addObject("tips", "@ControllerAdvice使用注解处理AgeException");
        mv.addObject("e", e);
        mv.setViewName("ageError");
        return mv;
    }
    //处理其他异常, NameException, AgeException以外的异常
    @ExceptionHandler
    public ModelAndView doOtherException(Exception e) {
        ModelAndView mv = new ModelAndView();
        mv.addObject("tips", "@ControllerAdvice使用注解处理OtherException");
        mv.addObject("e", e);
        mv.setViewName("defaultError");
        return mv;
    }
}

定义 Spring 配置文件

<context:component-scan base-package="com.fancy.controller">context:component-scan>

<context:component-scan base-package="com.fancy.exception">context:component-scan>
<mvc:annotation-driven>mvc:annotation-driven>

三、拦截器

SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。其拦截的时间点在 “处理器映射器根据用户提交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央调度器。

public class MyInterceptor implements HandlerInterceptor {
    public MyInterceptor() {
        super();
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("执行MyInterceptor ------ preHandle() ---");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("执行MyInterceptor ------ postHandle() ---");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("执行MyInterceptor ------ afterCompletion() ---");
    }
}

自定义拦截器，需要实现 HandlerInterceptor 接口。而该接口中含有三个方法：

➢ preHandle(request,response, Object handler)：
该方法在处理器方法执行之前执行。其返回值为 boolean，若为 true，则紧接着会执行处理器方法，且会将 afterCompletion()方法放入到一个专门的方法栈中等待执行。

➢ postHandle(request,response, Object handler,modelAndView)：
该方法在处理器方法执行之后执行。处理器方法若最终未被执行，则该方法不会执行。
由于该方法是在处理器方法执行完后执行，且该方法参数中包含 ModelAndView，所以该方法可以修改处理器方法的处理结果数据，且可以修改跳转方向。

➢ afterCompletion(request,response, Object handler, Exception ex)：
当 preHandle()方法返回 true 时，会将该方法放到专门的方法栈中，等到对请求进行响应的所有工作完成之后才执行该方法。即该方法是在中央调度器渲染（数据填充）了响应页面之后执行的，此时对 ModelAndView 再操作也对响应无济于事。

注册拦截器

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="com.fancy.interceptor.MyInterceptor">bean>
    mvc:interceptor>
mvc:interceptors>

用于指定当前所注册的拦截器可以拦截的请求路径，而 /** 表示拦截所有请求。

修改处理器

@RequestMapping(value = "/some.do")
public ModelAndView doSome() {
    System.out.println("执行处理器方法");
    return new ModelAndView("show");
}

控制台输出结果

再次定义一个拦截器

public class MyInterceptor2 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("执行MyInterceptor2 ------ preHandle() ---");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("执行MyInterceptor2 ------ postHandle() ---");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("执行MyInterceptor2 ------ afterCompletion() ---");
    }
}

注册多个拦截器

<mvc:interceptors>
   <mvc:interceptor>
       <mvc:mapping path="/**"/>
       <bean class="com.fancy.interceptor.MyInterceptor">bean>
   mvc:interceptor>
mvc:interceptors>
<mvc:interceptors>
   <mvc:interceptor>
       <mvc:mapping path="/**"/>
       <bean class="com.fancy.interceptor.MyInterceptor2">bean>
   mvc:interceptor>
mvc:interceptors>

再次查看控制台输出结果

当有多个拦截器时，形成拦截器链。拦截器链的执行顺序，与其注册顺序一致。需要再次强调一点的是，当某一个拦截器的 preHandle()方法返回 true 并被执行到时，会向一个专门的方法栈中放入该拦截器的 afterCompletion()方法。

多个拦截器中方法与处理器方法的执行顺序如下图：

从图中可以看出，只要有一个 preHandle()方法返回 false，则上部的执行链将被断开，其后续的处理器方法与 postHandle()方法将无法执行。但，无论执行链执行情况怎样，只要方法栈中有方法，即执行链中只要有 preHandle()方法返回 true，就会执行方法栈中的afterCompletion()方法。最终都会给出响应。

权限拦截器

只有经过登录的用户方可访问处理器，否则，将返回 “无权访问” 提示。本例的登录，由一个 JSP 页面完成。即在该页面里将用户信息放入 session 中。也就是说，只要访问过该页面，就说明登录了。没访问过，则为未登录用户。

主要代码：

当 preHandle()方法返回 false 时，需要使用 request 或 response 对请求进行响应

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    System.out.println("执行MyInterceptor ------ preHandle() ---");
    String user = (String) request.getSession().getAttribute("user");
    if (!"beijing".equals(user)) {
        request.getRequestDispatcher("/fail.jsp").forward(request, response);
        return false;
    }
    return true;
}

模拟用户登录与登出

<body>
	<%
	   seession.setAttribute("user", "aszhuo")
	%>
	登录成功
body>

<body>
	<% 
	   seession.removeAttribute("user");
	%>
	已退出
body>