欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

菜鸟学SpringMVC之——Interceptor拦截器

程序员文章站 2022-11-30 15:24:23
Interceptor拦截器就是进来拦截一次,出去拦截一次。过滤器就是进来,通过了,出去就走另一条路了。拦截器一定在Controller之前执行,就像Filter一定在Servlet之前执行我们形象的比喻一下到达Controller和Servelt会发出咚的一声,然后这是有三个拦截器,有三个过滤器。过滤器的执行步骤是:过滤器1—>过滤器2—>过滤器3—>咚,而拦截器的执行步骤是:拦截器1—>拦截器2—>拦截器3—>咚—>拦截器3—>拦截器2—>拦截...

Interceptor

拦截器就是进来拦截一次,出去拦截一次。过滤器就是进来,通过了,出去就走另一条路了。

拦截器一定在Controller之前执行,就像Filter一定在Servlet之前执行

我们形象的比喻一下到达Controller和Servelt会发出咚的一声,然后这是有三个拦截器,有三个过滤器。过滤器的执行步骤是:过滤器1—>过滤器2—>过滤器3—>咚,而拦截器的执行步骤是:拦截器1—>拦截器2—>拦截器3—>咚—>拦截器3—>拦截器2—>拦截器1

拦截器属于DispatcherServlet之后的过程,

正常的一个请求发送到后端会先到达web.xml,然后发给了Filter,然后交给DispatcherServlet,接着到达Interceptor…(可能会有很多个拦截器),然后才到达Controller,处理完了以后在返回给DispatcherServlet,然后直接返回给Tomcat

菜鸟学SpringMVC之——Interceptor拦截器

SpringMVC执行原理中Handler是两种东西,有可能是Controller,也有可能是Interceptor。他们是一个响应链,请求先到Interceptor1–>Interceptor2–>Interceptor3–>Controller–>Interceptor3–>Interceptor2–>Interceptor1(1 2 3 咚 3 2 1)

拦截器可以将过滤器的活给做了

过滤器Filter依赖于Servlet容器,要在web.xml文件中配置,拦截器Interceptor依赖于web框架,他要在SpringMVC配置文件中配置,因此可以使用Spring的依赖注入(DI)进行一些业务操作,同时一个拦截器实例在一个controller生命周期之内可以多次调用。但是缺点是只能对controller请求进行拦截,对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理。

拦截器和过滤器的区别:

  • ①拦截器是基于java的反射机制的,而过滤器是基于函数回调。
  • ②拦截器不依赖与servlet容器,过滤器依赖与servlet容器。
  • ③拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用。
  • ④拦截器可以访问action上下文,而过滤器不能访问。
  • ⑤在action的生命周期中,拦截器可以多次被调用,而过滤器只能在容器初始化时被调用一次。
  • ⑥拦截器以获取IOC容器中的各个bean,而过滤器就不行,这点很重要,在拦截器里注入一个service,可以调用业务逻辑。

过滤器的触发时机是容器后,servlet之前,所以过滤器的doFilter(

ServletRequest request, ServletResponse response, FilterChain chain)的入参是ServletRequest ,而不是httpservletrequest。因为过滤器是在httpservlet之前。

实现一个拦截器

public class MyInterceptor implements HandlerInterceptor {

    @Override
    //前置判断,决定这个请求到达能不能执行。这就相当于Controller层的"AOP"过程
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("前置开始");
        return true;
    }

    @Override
    //因为是Controller返回的ModelAndView,也就意味着这个方法是在Controller执行完了以后,再回到这里,修改ModelAndView
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("处理完成 ");

    }

    @Override
    //最终完成后执行它
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("全部结束");
    }
}

要让这个Interceptor生效就要在容器中配置他,让他进入到SpingMVC体系下

    <mvc:interceptors>
<!--        <ref bean="myInterceptor"></ref>&lt;!&ndash;全连接的方式,即所有映射都加拦截器&ndash;&gt;-->
        <mvc:interceptor><!--映射链接,只拦截满足映射的链接(即,user路径下的请求)-->
            <mvc:mapping path="/user/**"/>
            <ref bean="myInterceptor"></ref>
        </mvc:interceptor>
    </mvc:interceptors>

    <bean id="myInterceptor" class="com.lanou.controller.MyInterceptor"></bean>

菜鸟学SpringMVC之——Interceptor拦截器

现在实现多个拦截器,这次我们自定义的拦截器继承HandlerInterceptorAdaptor(HandlerInterceptor接口的实现类)如果实现的是接口那接口中的方法都要重写(虽然有的方法是default的,但是最好还是都要实实现的),但如果继承实现类,就可以挑选方法重写了拦截器执行顺序即配置顺序

public class MySecondInterceptor extends HandlerInterceptorAdapter {

    public MySecondInterceptor() {
        super();
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("second 前置");
        return super.preHandle(request, response, handler);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("second 后置");
        super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("second 结束");
        super.afterCompletion(request, response, handler, ex);
    }

    @Override

    //在分布式中处理最终事务一致性可能会用到
    //没有并发处理请求就不会走这里
    public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("second concurrent");
        super.afterConcurrentHandlingStarted(request, response, handler);
    }
}
    <mvc:interceptors>
        <mvc:interceptor><!--只拦截user路径下的请求-->
            <mvc:mapping path="/user/**"/>
            <ref bean="myInterceptor"></ref>
        </mvc:interceptor>
        <bean id="secondInterceptor" class="com.lanou.controller.MySecondInterceptor"></bean>
    </mvc:interceptors>
    <bean id="myInterceptor" class="com.lanou.controller.MyInterceptor"></bean>

执行结果
菜鸟学SpringMVC之——Interceptor拦截器

发现其实拦截器真正执行的顺序是 1 2 3 咚 3 2 1 3 2 1(1 2 3表示拦截器1,2,3)

如果调换两个拦截器配置的位置,执行结果也就调换

    <mvc:interceptors>
        
         <bean id="secondInterceptor" class="com.lanou.controller.MySecondInterceptor"></bean>
        <mvc:interceptor><!--只拦截user路径下的请求-->
            <mvc:mapping path="/user/**"/>
            <ref bean="myInterceptor"></ref>
        </mvc:interceptor>
       
    </mvc:interceptors>
    <bean id="myInterceptor" class="com.lanou.controller.MyInterceptor"></bean>

菜鸟学SpringMVC之——Interceptor拦截器
有关Interceptor接口的preHandle方法的handler属性的操作

public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//这里的这个handler就是告诉我们这个请求将要找哪个方法
       HandlerMethod method = (HandlerMethod) handler;
        System.out.println(method.getMethod().getName());//访问login.do,即要执行login方法。结果打印出 login
        System.out.println(method.getBean().getClass().getName());//getBean():获得方法的所属对象
        //知道了方法所属对象,知道了参数,就能通过反射执行这个方法
        method.getMethod().invoke(method.getBean(),method.getMethodParameters());//这里就可以对这个方法来执行更多的操作
        //但是由于我们是非侵入编程,最终只要让preHandle得到两个结果,要么执行,要么不执行,这就行了。
        
        return true;
    }

}

一般用preHandle方法的前两个参数来判断传进来的参数的合法性的,用后面的那个参数来判断用户状态的。

postHandle方法里的ModelAndView参数,如果后端要向前端然后一个ModelAndView,那么这里可以截获他,然后修改他再返回给前端。

过滤器

 @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("before...");
        chain.doFilter(request, response);
        System.out.println("after...");
    }

拦截器

@Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 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");
    }
  • preHandle()这个方法是在过滤器的chain.doFilter(request, response)方法的前一步执行,也就是在 System.out.println("before...") chain.doFilter(request, response)之间执行。
  • afterCompletion()方法是在过滤器返回给前端前一步执行,也就是在chain.doFilter(request, response) System.out.println("after...")之间执行。
    菜鸟学SpringMVC之——Interceptor拦截器

学习参考:https://www.cnblogs.com/panxuejun/p/7715917.html

本文地址:https://blog.csdn.net/ysf15609260848/article/details/107269405