Spring Boot 过滤器、拦截器、监听器对比及使用场景

朱雀 2023-09-26 17:34 111阅读 0赞

### 一、关系图理解 ###

![b82a649ad8c06b01a4ff7dbf5f752788.png][]

### 二、区别 ###

#### 1.过滤器 ####

*  过滤器是在web应用启动的时候初始化一次, 在web应用停止的时候销毁
 *  可以对请求的URL进行过滤, 对敏感词过滤
 *  挡在拦截器的外层
 *  实现的是 `javax.servlet.Filter` 接口，是 Servlet 规范的一部分
 *  在请求进入容器后，但在进入servlet之前进行预处理，请求结束是在servlet处理完以后
 *  依赖Web容器
 *  会多次执行

1.1HttpServletRequestWrapper

在请求到达之前对 request 进行修改

package com.dingwen.lir.filter;
    
    import lombok.extern.slf4j.Slf4j;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletRequestWrapper;
    import java.util.Arrays;
    
    /**
     *  在请求到达之前对 request 进行修改
     *
     * @author dingwen
     */
    @Slf4j
    public class RequestWrapper extends HttpServletRequestWrapper {
        public RequestWrapper(HttpServletRequest request) {
            super(request);
            log.info("RequestWrapper");
        }
    
        @Override
        public String getParameter(String name) {
            // 可以对请求参数进行过滤
            return super.getParameter(name);
        }
    
        @Override
        public String[] getParameterValues(String name) {
            // 对请求参数值进行过滤
    //        String[] values =super.getRequest().getParameterValues(name);
    //        return super.getParameterValues(name);
            return "t e s t".split(" ");
        }
    
    }

1.2 OncePerRequestFilter

`OncePerRequestFilter`，顾名思义，它能够确保在一次请求中只通过一次filter

package com.dingwen.lir.filter;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.filter.OncePerRequestFilter;
    
    import javax.servlet.FilterChain;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.Arrays;
    
    /**
     * 请求过滤器
     * OncePerRequestFilter:
     * OncePerRequestFilter，顾名思义，它能够确保在一次请求中只通过一次filter.
     * 大家常识上都认为，一次请求本来就只filter一次，为什么还要由此特别限定呢，往往我们的常识和实际的实现并不真的一样，经过一番资料的查阅，此方法是为了兼容不同的web container，
     * 也就是说并不是所有的container都入我们期望的只过滤一次，servlet版本不同，执行过程也不同，
     * 因此，为了兼容各种不同运行环境和版本，默认filter继承OncePerRequestFilter是一个比较稳妥的选择。
     *
     * @author dingwen
     */
    @Slf4j
    public class RequestFilter extends OncePerRequestFilter {
    
    
        @Override
        public void destroy() {
            super.destroy();
            log.info("RequestFilter destroy");
        }
    
        /*
                OncePerRequestFilter.doFilter方法中通过request.getAttribute判断当前过滤器是否已执行
                若未执行过，则调用doFilterInternal方法，交由其子类实现
            */
        @Override
        protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
            try {
                RequestWrapper requestWrapper = new RequestWrapper(httpServletRequest);
                filterChain.doFilter(requestWrapper, httpServletResponse);
                log.info("RequestFilter");
                log.info(Arrays.toString(requestWrapper.getParameterValues("name")));
            } catch (Exception exception) {
                httpServletResponse.setCharacterEncoding("utf-8");
                httpServletResponse.setContentType("application/json; charset=utf-8");
                PrintWriter writer = httpServletResponse.getWriter();
                writer.write(exception.toString());
            }
        }
    }

1.3 配置

package com.dingwen.lir.configuration;
    
    import com.dingwen.lir.filter.RequestFilter;
    import com.dingwen.lir.filter.RequestWrapper;
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.servlet.Filter;
    
    /**
     * 过滤器配置类
     *
     * @author dingwen
     */
    @Configuration
    public class FilterConfig {
    
        @Bean
        public RequestFilter requestFilter(){
            return new RequestFilter();
        }
        @Bean
        public FilterRegistrationBean<RequestFilter> registrationBean() {
            FilterRegistrationBean<RequestFilter> registrationBean = new FilterRegistrationBean<>();
            registrationBean.setFilter(requestFilter());
            registrationBean.addUrlPatterns("/filter/*");
            registrationBean.setName("RequestFilter");
            //过滤器的级别，值越小级别越高越先执行
            registrationBean.setOrder(1);
            return registrationBean;
        }
    }

#### 2.拦截器 ####

*  实现 `org.springframework.web.servlet.HandlerInterceptor` 接口，动态代理
 *  拦截器应用场景, 性能分析, 权限检查, 日志记录
 *  是一个Spring组件，并由Spring容器管理，并不
 *  不依赖Tomcat等容器，是可以单独使用的。不仅能应用在web程序中，也可以用于Application、Swing等程序中
 *  是在请求进入servlet后，在进入Controller之前进行预处理的，Controller 中渲染了对应的视图之后请求结束

2.1登录拦截

package com.dingwen.lir.interceptor;
    
    import com.dingwen.lir.entity.User;
    import org.springframework.stereotype.Component;
    import org.springframework.util.ObjectUtils;
    import org.springframework.web.servlet.HandlerInterceptor;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    /**
     * 登录拦截
     *
     * @author dingwen
     */
    @Component
    public class PageInterceptor implements HandlerInterceptor {
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            User user = (User)request.getSession().getAttribute("user");
            if (!ObjectUtils.isEmpty(user)) {
                return true;
            } else {
                // 不管是转发还是重定向，必须返回false。否则出现多次提交响应的错误
                redirect(request, response);
                return false;
            }
        }
    
        /*
         * 对于请求是ajax请求重定向问题的处理方法
         * @param request
         * @param response
         *
         */
        public void redirect(HttpServletRequest request, HttpServletResponse response) throws IOException {
    
            if("XMLHttpRequest".equals(request.getHeader("X-Requested-With"))){// ajax
                //获取当前请求的路径
                response.setHeader("Access-Control-Expose-Headers", "REDIRECT,CONTENT_PATH");
                //告诉ajax我是重定向
                response.setHeader("REDIRECT", "REDIRECT");
                //告诉ajax我重定向的路径
                StringBuffer url = request.getRequestURL();
                String contextPath = request.getContextPath();
                response.setHeader("CONTENT_PATH", url.replace(url.indexOf(contextPath) + contextPath.length(), url.length(), "/").toString());
            }else{// http
                response.sendRedirect( "/page/login");
            }
    
            response.getWriter().write(403);
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        }
    }

2.2配置

package com.dingwen.lir.configuration;
    
    import com.dingwen.lir.interceptor.PageInterceptor;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
    import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    /**
     * mvc 控制器配置
     * MyWebMvcConfigurer: Springboot2.x以后版本使用
     *
     * @author dingwen
     */
    @Configuration
    public class MyWebMvcConfigurer implements WebMvcConfigurer {
    
        /*
         * 拦截器依赖于Spring容器，此处拦截了所有，需要对静态资源进行放行
         */
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            // 拦截器默认的执行顺序，就是它的注册顺序，也可以通过Order手动设置控制，值越小越先执行。
    //        registry.addInterceptor(new PageInterceptor()).addPathPatterns("/**").order()
            registry.addInterceptor(new PageInterceptor()).addPathPatterns("/**")
                    .excludePathPatterns("/page/login", "/user/login","/page/ajax","/static/**");
        }
    
    
        /*
         * 不要要写控制器即可完成页面跳转访问
         * @param registry
         */
        @Override
        public void addViewControllers(ViewControllerRegistry registry) {
            registry.addViewController("/page/ajax").setViewName("ajax");
        }
    
    
        /*
         * 自定义静态资源映射
            Spring Boot 默认为我们提供了静态资源映射：
                    classpath:/META-INF/resources
                    classpath:/resources
                    classpath:/static
                    classpath:/public
                  优先级：META-INF/resources > resources > static > public
         * @param registry
         *
         */
    //    @Override
    //    public void addResourceHandlers(ResourceHandlerRegistry registry) {
            registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
            registry.addResourceHandler("/static/**").addResourceLocations("file:E:/static/");
    //    }
    }

#### 3.监听器 ####

实现 `javax.servlet.ServletRequestListener`, `javax.servlet.http.HttpSessionListener`, `javax.servlet.ServletContextListener` 等等接口

主要用来监听对象的创建与销毁的发生, 比如 session 的创建销毁, request 的创建销毁, ServletContext 创建销毁

### 三、注意 ###

#### 1.静态资源问题 ####

SpringBoot2.x以后版本拦截器也会拦截静态资源，在配置拦截器是需要将姿态资源放行。

/*
     * 拦截器依赖于Spring容器，此处拦截了所有，需要对静态资源进行放行
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new PageInterceptor()).addPathPatterns("/**")
                .excludePathPatterns("/page/login", "/user/login","/page/ajax","/static/**");
    }

SpringBoot2.x 自定义静态资源映射

spring:
      mvc:
        static-path-pattern: /static/**

默认目录

classpath:/META-INF/resources
    classpath:/resources
    classpath:/static
    classpath:/public

> 优先级：META-INF/resources > resources > static > public

#### 2.登录拦截ajax重定向 ####

由于ajax是异步的，还在当前页面进行的局部请求。当拦截到登录请求时，即使重定向也无法生效。需采用服务端给地址由前端进行跳转。详细见登录拦截器代码。

// 前端处理
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>AJAX</title>
        <script src="https://code.jquery.com/jquery-3.0.0.min.js"></script>
    </head>
    <body>
        <button>USER</button>
    </body>
    </html>
    
    <script>
        $.ajaxSetup({
            complete:function(xhr,status){
                //拦截器实现超时跳转到登录页面
                let win = window;
                // 通过xhr取得响应头
                let REDIRECT = xhr.getResponseHeader("REDIRECT");
                //如果响应头中包含 REDIRECT 则说明是拦截器返回的需要重定向的请求
                if (REDIRECT === "REDIRECT")
                {
                    while (win !== win.top)
                    {
                        win = win.top;
                    }
                    win.location.href = xhr.getResponseHeader("CONTEXTPATH");
                }
            }
        });
        $("button").click(function(){
            $.get("/page/user", function(result){
                $("div").html(result);
            });
        });
    </script>

### 四、测试 ###

代码地址：

>  *  https://gitee.com/dingwen-gitee/filter-interceptor-study.git

#### 1.拦截器测试 ####

1.1启动项目访问首页

>  *  http://localhost:8080/page/index

由于没有登录，直接重定向到了登录页

![3a159c005513f310d46a9d28f6228c88.png][]

1.2输入用户名密码完成登录，调转到用户页

![eace2e2a014ecd079f9003b09252d720.png][]

![e8aec4eeb0edabd213decc231bdd2cb1.png][]

此时在访问首页

![8b1c102ea2551d918df155a27ab74c4a.png][]

1.2 退出登录

成功退出后，访问为授权的页面也相对会被重定向到登录页

![61a6df12c03889593dd8efd071b0c92c.png][]

1.3 ajax未授权访问测试

![ea9ba8dddcd6ed02393bd30544c9cfaa.png][]

点击访问user ，由于未登录，没有全权访问。在前端进行了页面跳转，转到了登录页。

![3a159c005513f310d46a9d28f6228c88.png][]

#### 2.过滤器测试 ####

![9de9fc4f4c6aa1a34fd21c748194ef9b.png][]

![e011abd0bf1e83a8143647196057bd83.png][]

可以看到过滤器进行了相对应的处理，重写的`getParameterValues()`也生效了。配合使用`HttpServletRequestWrapper & OncePerRequestFilter` 实现了对request的修改。

[b82a649ad8c06b01a4ff7dbf5f752788.png]: https://img-blog.csdnimg.cn/img_convert/b82a649ad8c06b01a4ff7dbf5f752788.png
[3a159c005513f310d46a9d28f6228c88.png]: https://img-blog.csdnimg.cn/img_convert/3a159c005513f310d46a9d28f6228c88.png
[eace2e2a014ecd079f9003b09252d720.png]: https://img-blog.csdnimg.cn/img_convert/eace2e2a014ecd079f9003b09252d720.png
[e8aec4eeb0edabd213decc231bdd2cb1.png]: https://img-blog.csdnimg.cn/img_convert/e8aec4eeb0edabd213decc231bdd2cb1.png
[8b1c102ea2551d918df155a27ab74c4a.png]: https://img-blog.csdnimg.cn/img_convert/8b1c102ea2551d918df155a27ab74c4a.png
[61a6df12c03889593dd8efd071b0c92c.png]: https://img-blog.csdnimg.cn/img_convert/61a6df12c03889593dd8efd071b0c92c.png
[ea9ba8dddcd6ed02393bd30544c9cfaa.png]: https://img-blog.csdnimg.cn/img_convert/ea9ba8dddcd6ed02393bd30544c9cfaa.png
[9de9fc4f4c6aa1a34fd21c748194ef9b.png]: https://img-blog.csdnimg.cn/img_convert/9de9fc4f4c6aa1a34fd21c748194ef9b.png
[e011abd0bf1e83a8143647196057bd83.png]: https://img-blog.csdnimg.cn/img_convert/e011abd0bf1e83a8143647196057bd83.png