关于后端:面试一文知晓拦截器和过滤器的区别

5次阅读

共计 8718 个字符，预计需要花费 22 分钟才能阅读完成。

TOC

而后具体执行流程如下：

1、拦截器不依赖与 servlet 容器是 SpringMVC 自带的，过滤器依赖于 Servlet 容器。

2、拦截器是基于 java 的反射机制的，而过滤器是基于函数回调。

3、拦截器只能对 action 申请起作用，而过滤器则能够对简直所有的申请起作用。

4、拦截器能够拜访 controller 上下文、值栈里的对象，而过滤器不能拜访。

拦截器的 preHandle 办法在进入 controller 前执行，而拦截器的 postHandle 办法在执行完 controller 业务流程后，在视图解析器解析 ModelAndView 之前执行，能够操控 Controller 的 ModelAndView 内容。而 afterCompletion 是在视图解析器解析渲染 ModelAndView 实现之后执行的

过滤器是在服务器启动时就会创立的，只会创立一个实例，常驻内存，也就是说服务器一启动就会执行 Filter 的 init(FilterConfig config) 办法. 当 Filter 被移除或服务器失常敞开时，会执行 destroy 办法

5、拦截器能够获取 IOC 容器中的各个 bean，而过滤器就不行，这点很重要，在拦截器里注入一个 service，能够调用业务逻辑。

对于这句话的解读是：咱们晓得拦截器是 SprinMVC 自带的，而 SpringMVC 存在 Controller 层的，而 controller 层能够拜访到 service 层，service 层是不能拜访 service 层的，而过滤器是客户端和服务端之间申请与响应的过滤

6、过滤器和拦截器触发机会、工夫、中央不一样

过滤器是在申请进入容器后，但申请进入 servlet 之前进行预处理的。申请完结返回也是在 servlet 解决完后，返回给前端之前, 如果看不懂能够看 7 完后再来了解

7、过滤器包裹住 servlet，servlet 包裹住拦截器。

过滤器是在 web 利用启动的时候初始化一次, 在 web 利用进行的时候销毁
能够对申请的 URL 进行过滤, 对敏感词过滤
挡在拦截器的外层
实现的是 javax.servlet.Filter 接口，是 Servlet 标准的一部分
在申请进入容器后，但在进入 servlet 之前进行预处理，申请完结是在 servlet 解决完当前
依赖 Web 容器
会屡次执行

1.1HttpServletRequestWrapper

在申请达到之前对 request 进行批改

package com.qnbc.lir.filter;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.util.Arrays;

/**
 *  在申请达到之前对 request 进行批改
 *
 * @author qnbc
 */
@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.qnbc.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 qnbc
 */
@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.qnbc.lir.configuration;

import com.qnbc.lir.filter.RequestFilter;
import com.qnbc.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 qnbc
 */
@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;
    }
}

实现 org.springframework.web.servlet.HandlerInterceptor 接口，动静代理
拦截器利用场景, 性能剖析, 权限查看, 日志记录
是一个 Spring 组件，并由 Spring 容器治理，并不
不依赖 Tomcat 等容器，是能够独自应用的。不仅能利用在 web 程序中，也能够用于 Application、Swing 等程序中
是在申请进入 servlet 后，在进入 Controller 之前进行预处理的，Controller 中渲染了对应的视图之后申请完结

2.1 登录拦挡

package com.qnbc.lir.interceptor;

import com.qnbc.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 qnbc
 */
@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.qnbc.lir.configuration;

import com.qnbc.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 qnbc
 */
@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/");
//    }
}

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

次要用来监听对象的创立与销毁的产生, 比方 session 的创立销毁, request 的创立销毁, ServletContext 创立销毁

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

因为 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>

面试的时候再有什么高频问题，私信我，我来给出答案，祝你上岸！！！
记得关注，别找不到了

本文由 mdnice 多平台公布

正文完

后端

发表至：后端

2023-06-29

0

关于后端:idea启动build过慢问题

关于后端:海外APP推送上篇厂商通道与谷歌FCM通道的差异

关于后端:2021-年年度蕞佳开源软件

关于后端:Java-SE基础巩固四集合类

关于java:设计模式-创建型

关于后端:面试一文知晓拦截器和过滤器的区别

背景

关系图

拦截器和过滤器的区别

实操

1. 过滤器

1.1HttpServletRequestWrapper

1.2 OncePerRequestFilter

1.3 配置

2. 拦截器

2.1 登录拦挡

2.2 配置

3. 监听器

三、留神

1. 动态资源问题

2. 登录拦挡 ajax 重定向

总结

站内搜索