Spring Interceptor vs Filter

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：拦截处理程序的执行