Spring中的过滤器与拦截器：概述和区别

Spring框架提供了多种组件用于处理Web请求，其中两个常用的组件是过滤器（Filter）和拦截器（Interceptor）。尽管它们都用于对请求进行处理，但它们之间存在一些重要的区别。

过滤器（Filter）：请求与响应的守门员

概述

过滤器是Java EE规范的一部分，它在Servlet容器内部工作，可以对请求和响应进行过滤和修改。过滤器通常用于在请求到达Servlet之前或响应离开Servlet之后执行一些操作。这些操作包括日志记录、字符编码转换、安全认证等通用任务。

执行时机

过滤器在请求进入Servlet容器之前和响应离开Servlet容器之前执行，因此它们是请求生命周期的一部分。过滤器的执行顺序可以在web.xml配置文件中进行设置，以确保它们按照期望的顺序执行。

作用范围

过滤器的范围非常广泛，它们可以用于处理所有类型的请求和响应，包括静态资源、JSP页面以及Servlet产生的响应。

功能

过滤器通常用于执行以下任务：

• 请求和响应的日志记录。
• 字符编码转换，确保请求和响应的字符集一致。
• 安全认证，验证用户是否有权限访问某个资源。
• 请求参数的处理，如解析请求参数、过滤恶意输入等。

示例代码

以下是一个简单的过滤器示例，用于记录请求的处理时间：

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 java.io.IOException;

public class TimingFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 过滤器初始化代码
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        long startTime = System.currentTimeMillis();

        // 执行过滤链中的下一个过滤器或Servlet
        chain.doFilter(request, response);

        long endTime = System.currentTimeMillis();
        long elapsedTime = endTime - startTime;

        System.out.println("请求处理时间：" + elapsedTime + "毫秒");
    }

    @Override
    public void destroy() {
        // 过滤器销毁代码
    }
}

上述代码中的TimingFilter用于记录请求的处理时间，并将其打印到控制台。

拦截器（Interceptor）：Spring MVC的助手

概述

拦截器是Spring框架提供的组件，专门用于处理Spring MVC的请求。它们是Spring MVC的一部分，用于对Controller的请求进行预处理和后处理。拦截器通常用于实现与业务逻辑相关的操作，如权限验证、数据准备、日志记录等。

执行时机

拦截器在请求进入Controller之前和离开Controller之后执行。因此，拦截器可以在请求到达Controller之前执行一些准备工作，也可以在Controller处理请求后执行一些后续操作。

作用范围

拦截器仅作用于Spring MVC的请求，它们不会处理静态资源或其他非Spring MVC的请求。

功能

拦截器通常用于执行以下任务：

• 权限验证，确定用户是否有权访问某个URL或Controller方法。
• 数据准备，将一些常用的数据预先设置到Model中，以便在视图中使用。
• 日志记录，记录请求和响应的信息。
• 资源清理，例如关闭打开的文件或数据库连接。

示例代码

以下是一个简单的拦截器示例，用于记录请求的URL和处理时间：

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoggingInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 在请求到达Controller之前执行
        System.out.println("请求URL: " + request.getRequestURL());
        request.setAttribute("startTime", System.currentTimeMillis());
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        // 在Controller处理请求后，视图渲染前执行
        long startTime = (long) request.getAttribute("startTime");
        long endTime = System.currentTimeMillis();
        long elapsedTime = endTime - startTime;
        System.out.println("处理时间：" + elapsedTime + "毫秒");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // 在视图渲染完成后执行
    }
}

上述代码中的LoggingInterceptor用于记录请求的URL和处理时间，并在请求处理后打印处理时间。

过滤器、拦截器、service()方法，dispatc()方法的执行顺序

Spring过滤器（Filter）的高级用法

过滤器链

过滤器链是指多个过滤器按照一定的顺序组成的链条。在请求进入Servlet容器之前，这些过滤器会按照定义的顺序依次执行；在响应离开Servlet容器之前，这些过滤器也会按照相反的顺序执行。过滤器链的典型应用是处理不同类型的请求，每个过滤器负责不同的处理逻辑。

以下是一个使用过滤器链的示例，其中包含两个过滤器，一个用于记录请求日志，另一个用于进行字符编码转换：

public class RequestLoggingFilter implements Filter {
    // ...
}

public class CharacterEncodingFilter implements Filter {
    // ...
}

// 在web.xml配置文件中定义过滤器链
<filter>
    <filter-name>requestLoggingFilter</filter-name>
    <filter-class>com.example.RequestLoggingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>requestLoggingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>com.example.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

在上述示例中，两个过滤器分别用于日志记录和字符编码转换，并通过<filter-mapping>配置将它们应用到所有URL模式上。

过滤器的条件判断

过滤器可以根据特定的条件来决定是否执行过滤操作。这可以通过在doFilter方法中添加条件判断逻辑来实现。例如，你可以根据请求的URL、请求参数、请求头等信息来决定是否执行过滤操作。

以下是一个示例，展示了如何根据请求的URL判断是否执行日志记录过滤器：

public class RequestLoggingFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String requestURI = httpRequest.getRequestURI();

        // 根据请求的URL判断是否执行日志记录
        if (requestURI.startsWith("/admin")) {
            // 执行日志记录
            System.out.println("记录管理员请求日志：" + requestURI);
        }

        // 继续执行过滤链中的下一个过滤器或Servlet
        chain.doFilter(request, response);
    }
    // ...
}

在上述示例中，RequestLoggingFilter根据请求的URL判断是否记录日志。只有当请求的URL以"/admin"开头时，才会执行日志记录操作。

Spring拦截器（Interceptor）的高级用法

多拦截器配置

Spring MVC允许配置多个拦截器，它们按照配置的顺序依次执行。这为开发人员提供了更多的灵活性，可以根据需求将不同的拦截器应用到不同的URL模式上。

以下是一个示例，展示了如何配置多个拦截器并指定它们的执行顺序：

@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {
    @Bean
    public LoggingInterceptor loggingInterceptor() {
        return new LoggingInterceptor();
    }

    @Bean
    public AuthorizationInterceptor authorizationInterceptor() {
        return new AuthorizationInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 配置拦截器并指定执行顺序
        registry.addInterceptor(loggingInterceptor()).addPathPatterns("/**");
        registry.addInterceptor(authorizationInterceptor()).addPathPatterns("/secure/**");
    }
}

在上述示例中，我们定义了两个拦截器LoggingInterceptor和AuthorizationInterceptor，并通过addInterceptors方法配置了它们的执行顺序。loggingInterceptor被应用到所有URL模式上，而authorizationInterceptor只被应用到"/secure/**"模式的URL上。

拦截器的前后处理

拦截器可以在Controller方法执行前和执行后执行一些额外的处理逻辑。这对于请求参数的处理、响应数据的处理以及异常处理非常有用。

以下是一个示例，展示了如何在拦截器中实现前后处理逻辑：

public class LoggingInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 在请求到达Controller之前执行
        System.out.println("请求URL: " + request.getRequestURL());
        request.setAttribute("startTime", System.currentTimeMillis());
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        // 在Controller处理请求后，视图渲染前执行
        long startTime = (long) request.getAttribute("startTime");
        long endTime = System.currentTimeMillis();
        long elapsedTime = endTime - startTime;
        System.out.println("处理时间：" + elapsedTime + "毫秒");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // 在视图渲染完成后执行
        // 可以用于资源清理等操作
    }
}

在上述示例中，LoggingInterceptor的preHandle方法用于记录请求的开始时间，postHandle方法用于计算请求处理时间，而afterCompletion方法可用于资源清理等操作。这些方法可以帮助你实现更多的前后处理逻辑。

选择何时使用过滤器和拦截器

选择使用过滤器还是拦截器取决于你的需求和场景：

• 如果你需要处理通用的请求和响应逻辑，如字符编码转换、日志记录或安全认证，那么使用过滤器是一个不错的选择。
• 如果你需要对Spring MVC的请求进行特定的预处理和后处理，如权限验证、数据准备或日志记录，那么使用拦截器更为合适。

通常情况下，过滤器更适合处理与Servlet容器相关的通用任务，而拦截器更适合与Spring MVC相关的请求处理。

总结：

• 过滤器和拦截器都是处理Web请求的重要组件，但它们在用途和配置方面有一些区别。
• 过滤器工作在Servlet容器层面，可以处理所有类型的请求和响应，通常用于通用任务。
• 拦截器工作在Spring MVC层面，只能处理Spring MVC的请求，通常用于与业务逻辑相关的处理。
• 选择何时使用过滤器或拦截器取决于你的需求，可以根据场景进行选择和配置。

区别：

• 过滤器是基于函数回调，拦截器是基于java的反射机制的。
• 2、过滤器是servlet规范规定的，只能用于web程序中，而拦截器是在spring容器中，它不依赖servlet容器。
• 3、过滤器可以拦截几乎所有的请求(包含对静态资源的请求)，而拦截器只拦截action请求(不拦截静态资源请求)。
• 4、滤器不能访问action上下文、值栈里的对象，拦截器可以访问action上下文、值栈里的对象。
• 5、在action的生命周期中，过滤器只能在容器初始化时被调用一次，拦截器可以多次被调用，而。
• 6、拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。
• 7、拦截器是被包裹在过滤器之中。