spring boot 之拦截器、过滤器

我叫晨曦啊

于 2024-05-20 15:41:52 发布

阅读量543

点赞数 3

分类专栏： spring boot 文章标签： spring boot 后端

本文链接：https://blog.csdn.net/yang2717/article/details/139067028

版权

spring boot 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

拦截器、过滤器区别

出身不同

拦截器实现的是HandlerInterceptor接口，拦截器是属于Spring技术，它是Spring的一个组件，并由Spring容器创建管理，并不依赖Tomcat服务器，是可以单独使用的，拦截器不仅能应用在web程序中，也可以用于Application、Swing等程序中；
过滤器实现是javax.servlet.Filter接口，而这个接口是在Servlet规范中定义的，也就是说过滤器Filter的使用要依赖于Tomcat服务器，Filter是在Tomcat服务器创建的对象，导致它只能在web程序中使用。

使用场景不同

拦截器侧重于验证请求、截断请求，对用户请求做预先的判断处理、可以修改ModelAndView对象中的数据和视图，影响控制器方法最终的执行结果的，拦截器主要应用于登陆校验、日志记录、权限验证、性能监控等功能：
过滤器侧重于对请求参数进行过滤的，比如敏感词过滤、字符集编码设置CharacterEncodingFilter、修改请求头和响应头的信息；

触发时机不同

拦截器Interceptor是在请求进入servlet后，进入Controller之前进行预处理的，Controller中渲染了对应的视图之后请求结束。
过滤器Filter是在请求进入容器后，但在进入servlet之前进行预处理，请求结束是在servlet处理完以后。
过滤器几乎可以对所有进入容器的请求起作用，而拦截器只会对Controller中请求或访问static目录下的资源请求起作用。

实现不同

拦截器是基于动态代理（底层是反射）实现的。
过滤器是基于方法回调实现的，当我们要执行下一个过滤器或下一个流程时，需要调用FilterChain对象的doFilter方法进行回调执行。

部分应用场景示例

拦截器：

1、登录验证，判断用户是否登录;
2、权限验证，判断用户是否有权限访问资源，如校验token;
3、日志记录，记录请求操作日志（用户ip，访问时间等），以便统计请求访问量;
4、处理 cookie、本地化、国际化、主题等;
5、性能监控，监控请求处理时长等;
6、通用行为：读取cookie得到用户信息并将用户对象放入请求，从而方便后续流程使用，还有如提取 Locale、Theme 信息等，只要是多个处理器都需要的即可使用拦截器实现;

过滤器

1、过滤敏感词汇（防止sql注入）;
2、设置字符编码;
3、URL级别的权限访问控制;
4、压缩响应信息;

拦截器的使用

新建拦截器

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class ServletInterceptor implements HandlerInterceptor {

    /**
     * 在请求处理之前进行调用（Controller方法调用之前）
     * 预处理回调方法，实现处理器的预处理
     * 返回值：true表示继续流程；false表示流程中断，不会继续调用其他的拦截器或处理器
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获取请求头中的token
        String token = request.getHeader("token");
        //如果请求头中没有token，抛出异常
        if (StrUtil.isBlankIfStr(token)) {
            // 返回false 或者 自定义封装的异常
            throw new MySelfException("请求头缺少token");
        }
        return true;
    }

    /**
     * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
     * 后处理回调方法，实现处理器（controller）的后处理，但在渲染视图之前
     * 此时我们可以通过modelAndView对模型数据进行处理或对视图进行处理
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    /**
     * 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
     * 整个请求处理完毕回调方法，即在视图渲染完毕时回调，
     * 如性能监控中我们可以在此记录结束时间并输出消耗时间，
     * 还可以进行一些资源清理，类似于try-catch-finally中的finally，
     * 但仅调用处理器执行链中
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

配置拦截器

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    @Autowired
    private ServletInterceptor servletInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(servletInterceptor)
                // 配置拦截的路径
                .addPathPatterns("/**")
                // 配置不需拦截的路径
                .excludePathPatterns("/admin/**")
                // 配置拦截器顺序，数字越大执行越靠后
                .order(1);

    }
}

过滤器的使用

新建过滤器

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.multipart.support.StandardServletMultipartResolver;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.Charset;

@Slf4j
public class ServletStreamFilter implements Filter {

    @Override //可不重写
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
        log.info("ServletStreamFilter 过滤器成功初始化");
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        String contentType = req.getContentType();
        String method = "multipart/form-data";
        if (contentType != null && contentType.contains(method)) {
            // 将转化后的 request 放入过滤链中
            request = new StandardServletMultipartResolver().resolveMultipart(request);
        }
        // 若后续不在使用request中的东西，直接放行即可
        // chain.doFilter(req, resp);
        
        // 若后续还会用到request中的东西，使用该方法操作
        // 扩展request，使其能够能够重复读取requestBody
        ServletRequest requestWrapper = new RequestWrapper(request);
        // 这里需要放行，但是要注意放行的 request是requestWrapper
        chain.doFilter(requestWrapper, resp);
    }

    @Override //可不重写
    public void destroy() {
        Filter.super.destroy();
        log.info("ServletStreamFilter 过滤器被销毁");
    }

    // 内部类
    static class RequestWrapper extends HttpServletRequestWrapper {
        /**
         * 存储body数据的容器
         */
        private final byte[] body;

        public RequestWrapper(HttpServletRequest request) throws IOException {
            super(request);
            // 将body数据存储起来
            String bodyStr = getBodyString(request);
            body = bodyStr.getBytes(Charset.defaultCharset());
        }

        /**
         * 获取请求Body
         *
         * @param request request
         * @return String
         */
        public String getBodyString(final ServletRequest request) throws IOException {
            return inputStream2String(request.getInputStream());
        }

        /**
         * 获取请求Body
         *
         * @return String
         */
        public String getBodyString() throws IOException {
            final InputStream inputStream = new ByteArrayInputStream(body);
            return inputStream2String(inputStream);
        }

        /**
         * 将inputStream里的数据读取出来并转换成字符串
         *
         * @param inputStream inputStream
         * @return String
         */
        private String inputStream2String(InputStream inputStream) throws IOException {
            StringBuilder sb = new StringBuilder();
            BufferedReader reader = null;
            reader = new BufferedReader(new InputStreamReader(inputStream, Charset.defaultCharset()));
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            return sb.toString();
        }

        @Override
        public BufferedReader getReader() throws IOException {
            return new BufferedReader(new InputStreamReader(getInputStream()));
        }

        @Override
        public ServletInputStream getInputStream() throws IOException {
            final ByteArrayInputStream inputStream = new ByteArrayInputStream(body);
            return new ServletInputStream() {
                @Override
                public int read() throws IOException {
                    return inputStream.read();
                }

                @Override
                public boolean isFinished() {
                    return false;
                }

                @Override
                public boolean isReady() {
                    return false;
                }

                @Override
                public void setReadListener(ReadListener readListener) {
                }
            };
        }
    }

}

配置过滤器

import com.company.filter.ServletStreamFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyFilterConfig {
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        // 创建一个注册过滤器对象
        FilterRegistrationBean registrationBean = new FilterRegistrationBean(new ServletStreamFilter());
        // 设置过滤拦截匹配规则,/*是匹配所有
        // registrationBean.addUrlPatterns("/*");
        // 只拦截test下面的接口
        registrationBean.addUrlPatterns("/test/*");
        // 给过滤器起名字
        registrationBean.setName("servletStreamFilter-");
        // 存在多个过滤器时，设置执行顺序，值越大，执行顺序越靠后
        registrationBean.setOrder(2);
        // 返回这个注册过滤器对象
        return registrationBean;
    }
}