spring配置拦截器

一.拦截器（interceptor）的作用

SpringMVC的拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。
将拦截器按一定的顺序联结成一条链，这条链称为拦截器链，在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体体现。
拦截器的方法：
preHandle():方法在处理请求之前调用，该方法的返回值是boolean类型的，当返回false时，表示请求结束，后续的Interceptor和Controller都不会再执行；当返回true时，就会继续调用下一个Interceptor的preHandle方法。
postHandle():该方法是在当前请求进行处理之后被调用，前提是preHandle方法的返回值是true时才能调用，且它会在DispatcherServlet进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller处理之后的ModelAndView对象进行操作。
afterCompletion():该方法将在整个请求结束后，也就是在DispatcherServlet渲染了对应的视图之后执行，前提是preHandle方法的返回值是true时才能调用。

二.自定义拦截器的步骤

1.创建拦截器类实现HandlerInterceptor接口
2.配置拦截器
3.测试拦截器的拦截效果
例子：创建拦截器MyInterceptor1

@Controller
public class TargetController {

    @RequestMapping("/target")
    public ModelAndView show(){
        System.out.println("目标资源执行......");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("name","itcast");
        modelAndView.setViewName("index");
        return modelAndView;
    }
}

public class MyInterceptor1 implements HandlerInterceptor {
    //在目标方法之前执行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        //返回true代表放行，后续的操作可以进行，返回false代表不放行，后续的操作都不能执行
        return true;
    }

    //在目标方法执行之后，视图对象返回之前执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }

    //在整个流程都执行完毕后执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

spring-mvc.xml配置拦截器：

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--对哪些资源执行拦截操作-->
        <mvc:mapping path="/**"/>
        <bean class="com.itheima.interceptor.MyInterceptor1"></bean>
    </mvc:interceptor>
</mvc:interceptors>

测试效果TargetController:

@Controller
public class TargetController {

    @RequestMapping("/target")
    public ModelAndView show(){
        System.out.println("目标资源执行......");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("name","itcast");
        modelAndView.setViewName("index");
        return modelAndView;
    }
}

浏览器输入：http://localhost:8080/target
控制台输出：preHandle…
目标资源执行…
postHandle…
afterCompletion…

三.配置两个拦截器的前后运行顺序

拦截器1，MyInterceptor1:

public class MyInterceptor1 implements HandlerInterceptor {
    //在目标方法之前执行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        //得到浏览器中的param属性，判断如果属性是yes,则正常，否则就跳转到error.jsp界面
        String param = request.getParameter("param");
        if ("yes".equals(param)){
            return true;
        }else{
            request.getRequestDispatcher("/error.jsp").forward(request,response);
            return false;
        }

    }

    //在目标方法执行之后，视图对象返回之前执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
       //把name修改为itheima
         modelAndView.addObject("name","itheima");
        System.out.println("postHandle...");
    }

    //在整个流程都执行完毕后执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

拦截器2，MyInterceptor2:

public class MyInterceptor2 implements HandlerInterceptor {
    //在目标方法之前执行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle222222...");
        return true;

    }

    //在目标方法执行之后，视图对象返回之前执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

        System.out.println("postHandle222222222...");
    }

    //在整个流程都执行完毕后执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion2222222...");
    }
}

spring-mvc.xml，配置两个拦截器：

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--对哪些资源执行拦截操作-->
        <mvc:mapping path="/**"/>
        <bean class="com.itheima.interceptor.MyInterceptor1"></bean>
    </mvc:interceptor>
    <mvc:interceptor>
        <!--对哪些资源执行拦截操作-->
        <mvc:mapping path="/**"/>
        <bean class="com.itheima.interceptor.MyInterceptor2"></bean>
    </mvc:interceptor>
</mvc:interceptors>

浏览器输入：http://localhost:8080/target?param=yes
浏览器得到：Hello World!itheima
控制台输出：preHandle…
preHandle222222…
目标资源执行…
postHandle222222222…
postHandle…
afterCompletion2222222…
afterCompletion…

观察这个顺序，先执行拦截器1的preHandle,再执行2的preHandle，然后执行target
而postHandle和afterCompletion则是先执行2再执行1，这个顺序可以理解为栈的操作，谁先执行则看配置文件中拦截器的配置谁在前谁先执行。

4.springboot配置拦截器

自定义的拦截器

package com.urovo.interceptor;

/**
 * api 拦截器
 */
@Slf4j
public class LoginInterceptor  implements HandlerInterceptor {

  

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {


        return true;
    }
}

在config包下面建立 WebMvcConfig .java

@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor())
                // 拦截规则 ，拦截那些路径
                .addPathPatterns("/**")
                // 那些路径不拦截
                .excludePathPatterns("/user/login","/error");
}

    @Bean
    public LoginInterceptor loginInterceptor(){
        return new LoginInterceptor();
    }
}