Spring Interceptor vs Filter

偏执的太偏执、 2022-05-01 12:16 156阅读 0赞

### Filter ###

Filter，顾名思义，过滤器，是由servlet容器为每个传入的http请求和每个http响应执行的Java类。 这样，就可以在HTTP传入请求到达资源之前对其进行管理，例如JSP页面，servlet或简单的静态页面; 以相同的方式可以在资源执行后管理HTTP出站响应。

此行为允许实现在许多不同上下文中重用的常用功能。

Filter在只在 Servlet 前后起作用。Filters 通常将请求和响应（request/response） 当做黑盒子，Filter 通常不考虑servlet的实现。

如上图所示，过滤器在Web容器中运行，因此其定义也将包含在web.xml文件中。

<filter>
        <filter-name>CORSFilter</filter-name>
        <filter-class>com.listfeeds.components.CORSFilter</filter-class>
        <init-param>
            <param-name>fake-param</param-name>
            <param-value>fake-param-value</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CORSFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    复制代码

在过滤器定义中，由com.listfeeds.filters.CORSFilter类实现的过滤器具有满足表达式的所有端点：/ \*（在本例中为all）

import java.io.IOException;
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletResponse;
    import org.springframework.stereotype.Component;
    
    public class CORSFilter implements Filter {
    
        public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
    
            HttpServletResponse response = (HttpServletResponse) res;
            response.setHeader("Access-Control-Allow-Origin", "*");
            response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
            response.setHeader("Access-Control-Max-Age", "3600");
            response.setHeader("Access-Control-Allow-Headers", "x-requested-with");
            chain.doFilter(req, res);
        }
    
        public void init(FilterConfig filterConfig) {}
    
        public void destroy() {}
    
    }
    复制代码

Filter包括三个主要方法：

*  init：执行以使用过滤器定义中的init-param元素初始化过滤器
 *  doFilter：为满足“url-pattern”的所有HTTP传入请求执行
 *  destroy：释放过滤器使用的资源

Filter使用场景：

*  身份验证：根据用户身份阻止请求。
 *  记录日志和审核：跟踪Web应用程序的用户。
 *  图像转换：缩放地图等。
 *  数据压缩：使下载量更小。
 *  本地化：将请求和响应定位到特定区域设置。

Request Filters 可以：

*  执行安全检查
 *  重新格式化请求标头或正文
 *  请求记录与审计

Response Filters 可以：

*  压缩响应流
 *  追加或改变响应流
 *  完全创造一个不同的回应

Filter的轮子有：

*  认证 Filters
 *  日志和请求审计 Filters
 *  图像转换 Filters
 *  数据压缩 Filters
 *  加密 FIlter
 *  ...

### Interceptor ###

Spring拦截器类似于Servlet过滤器，但它们在Spring Context中起作用，因此管理HTTP请求和响应的功能非常强大，但它们可以实现更加软化的行为，因为它可以访问所有Spring上下文。

Interceptor能够深入到方法前后、异常抛出前后等，因此拦截器的使用具有更大的弹性。允许用户介入（hook into）请求的生命周期，在请求过程中获取信息，Interceptor 通常和请求更加耦合。

Spring拦截器在SpringMVC上下文中执行，因此它们已在spring-servlet.xml文件中定义：

<mvc:interceptors>
        <bean class="com.listfeeds.interceptors.LogContextInterceptor" />
        <bean class="com.listfeeds.interceptors.TimedInterceptor" />
    </mvc:interceptors>
    复制代码

com.listfeeds.interceptors.LogContextInterceptor拦截器类，用于向Log4j Thread上下文添加参数。

import java.util.Map;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.commons.lang.StringUtils;
    import org.apache.log4j.MDC;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.method.HandlerMethod;
    import org.springframework.web.servlet.HandlerMapping;
    import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
    
    public class LogContextInterceptor extends HandlerInterceptorAdapter {
    
        private static final Logger log = LoggerFactory.getLogger(LogContextInterceptor.class);
    
        public static final String LOG_IDENTIFYING_TOKEN = "logIdentifyingToken";
    
        @Override
        public void afterCompletion(
                HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                throws Exception {
    
            HandlerMethod methodHandler = (HandlerMethod) handler;
            log.debug("END EXECUTION method {} request: {}", methodHandler.getMethod().getName(), request.getRequestURI());
    
            Boolean settato = (Boolean) request.getAttribute(LOG_IDENTIFYING_TOKEN);
            if(settato != null && settato) {
                MDC.remove(LOG_IDENTIFYING_TOKEN);
            }
        }
    
        @Override
        public boolean preHandle(HttpServletRequest request,
                HttpServletResponse response, Object handler) throws Exception {
    
            try {
                if( MDC.get(LOG_IDENTIFYING_TOKEN) == null ) {
    
                    /* Retrieve parameters useful for logging */
                    @SuppressWarnings("unchecked")
                    Map<String,String> pathVariables = 
                    (Map<String, String>) request.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
    
                    String applicationId = null;
                    if ( pathVariables != null ) 
                        applicationId = pathVariables.get("applicationId");
    
                    if ( StringUtils.isEmpty(applicationId) ) 
                        applicationId = request.getParameter("applicationId");
    
                    String loggingToken = 
                            String.format("ApplicationId: %s", applicationId);
    
                    MDC.put(LOG_IDENTIFYING_TOKEN, loggingToken);
                    request.setAttribute(LOG_IDENTIFYING_TOKEN, Boolean.TRUE);
                }
    
    
            }
            catch ( IllegalArgumentException e)
            {
                log.warn("Prehandle",e);
                return true;
            }
            finally {
                HandlerMethod methodHandler = (HandlerMethod) handler;
                //logger.debug("START EXECUTION " + methodHandler.getMethod().getName());
                log.debug("START EXECUTION method {} request: {}", methodHandler.getMethod().getName(), request.getRequestURI());
    
    
            }
    
    
            return true;
        }
    
    }
    复制代码

interceptor 包含如下几个主要方法：

*  preHandle：在执行目标资源之前执行
 *  afterCompletion：执行目标资源后执行（渲染视图后）
 *  posttHandle：拦截处理程序的执行

转载于:https://juejin.im/post/5cbeac5b6fb9a0324a08abc7