Spring Boot之拦截器和过滤器_springboot拦截器和过滤器

Spring Boot之拦截器和过滤器

Spring Boot是一个流行的框架，用于简化Spring应用的开发。它通过简化配置和快速集成常用功能，提高了开发效率。拦截器（Interceptor）和过滤器（Filter）是Web开发中常用的两个组件，用于处理HTTP请求。本文将详细介绍Spring Boot中的拦截器和过滤器的工作原理、使用场景和实现方法。

1. 拦截器（Interceptor）

1.1 拦截器的工作原理

拦截器是一种用于拦截和处理HTTP请求的组件。它类似于Servlet中的过滤器，但更适用于Spring框架。拦截器可以在请求到达控制器之前、请求处理完成后和视图渲染之前执行特定的逻辑。

Spring中的拦截器实现了HandlerInterceptor接口，该接口定义了三个主要方法：

• preHandle(HttpServletRequest request, HttpServletResponse response, Object handler): 在请求处理之前调用，返回true继续处理请求，返回false中断请求。
• postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView): 在请求处理完成后调用，但在视图渲染之前。
• afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex): 在整个请求完成后，即视图渲染之后调用。

1.2 拦截器的使用场景

拦截器常用于以下场景：

• 身份验证和授权: 检查用户是否登录，是否有权限访问特定资源。
• 日志记录: 记录请求的详细信息，如请求URL、处理时间等。
• 请求参数处理: 修改或添加请求参数。
• 全局异常处理: 统一处理请求中的异常。

1.3 拦截器的实现方法

在Spring Boot中创建一个拦截器并进行配置非常简单。下面是一个实现身份验证的拦截器示例：

1.3.1 创建拦截器类

首先，创建一个实现HandlerInterceptor接口的拦截器类：

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

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

@Component
public class AuthInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 检查用户是否登录
        String token = request.getHeader("Authorization");
        if (token == null || !isValidToken(token)) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 可以在此处添加一些处理逻辑
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 可以在此处添加一些清理逻辑
    }

    private boolean isValidToken(String token) {
        // 验证token的有效性
        return "valid-token".equals(token);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

1.3.2 注册拦截器

接下来，需要将拦截器注册到Spring的拦截器链中。创建一个配置类实现WebMvcConfigurer接口：

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 WebConfig implements WebMvcConfigurer {

    @Autowired
    private AuthInterceptor authInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/login", "/register");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

通过这种方式，拦截器将应用于所有请求，但/login和/register路径除外。

2. 过滤器（Filter）

2.1 过滤器的工作原理

过滤器是Servlet规范的一部分，用于对HTTP请求和响应进行预处理或后处理。过滤器可以在请求到达Servlet之前或响应离开Servlet之后执行特定的逻辑。它们通常用于记录日志、压缩响应内容、设置字符编码等。

过滤器实现了javax.servlet.Filter接口，该接口定义了三个主要方法：

• init(FilterConfig filterConfig): 在过滤器实例化后调用，用于初始化。
• doFilter(ServletRequest request, ServletResponse response, FilterChain chain): 每次请求都会调用该方法，在此处编写过滤逻辑。
• destroy(): 在过滤器销毁前调用，用于清理资源。

2.2 过滤器的使用场景

过滤器常用于以下场景：

• 请求日志记录: 记录每个请求的详细信息。
• 响应内容压缩: 对响应内容进行GZIP压缩。
• 字符编码设置: 统一设置请求和响应的字符编码。
• 跨域资源共享（CORS）: 处理跨域请求。

2.3 过滤器的实现方法

在Spring Boot中创建一个过滤器并进行配置也非常简单。下面是一个记录请求日志的过滤器示例：

2.3.1 创建过滤器类

首先，创建一个实现Filter接口的过滤器类：

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;
import java.util.logging.Logger;

public class LogFilter implements Filter {

    private static final Logger logger = Logger.getLogger(LogFilter.class.getName());

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化逻辑
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 记录请求信息
        logger.info("Request received at " + request.getRemoteAddr());
        chain.doFilter(request, response);
        // 记录响应信息
        logger.info("Response sent to " + request.getRemoteAddr());
    }

    @Override
    public void destroy() {
        // 清理逻辑
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2.3.2 注册过滤器

接下来，需要将过滤器注册到Spring的过滤器链中。可以使用@Bean注解在配置类中注册过滤器：

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<LogFilter> loggingFilter() {
        FilterRegistrationBean<LogFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new LogFilter());
        registrationBean.addUrlPatterns("/api/*");
        return registrationBean;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

通过这种方式，过滤器将应用于/api/*路径下的所有请求。

3. 拦截器与过滤器的对比

拦截器和过滤器在功能上有一些重叠，但它们在使用场景和实现细节上有所不同：

• 适用层次:

  • 拦截器：属于Spring MVC层，适用于处理Controller层的逻辑。
  • 过滤器：属于Servlet层，适用于处理整个请求和响应的生命周期。

• 使用范围:

  • 拦截器：主要用于请求预处理和后处理，常用于身份验证、日志记录等。
  • 过滤器：用于请求和响应的整体处理，常用于日志记录、字符编码设置、CORS等。

• 实现方式:

  • 拦截器：通过实现HandlerInterceptor接口并在Spring配置中注册。
  • 过滤器：通过实现javax.servlet.Filter接口并在Spring Boot配置类中注册。

4. 总结

拦截器和过滤器是Web开发中不可或缺的两个组件，它们在处理HTTP请求时提供了强大的功能和灵活性。通过本文的介绍，我们了解了拦截器和过滤器的基本原理、使用场景和具体实现方法。在实际开发中，合理地使用拦截器和过滤器，可以提高应用的安全性、可维护性和性能。

无论是在开发新项目还是维护现有项目，掌握这些技术都能帮助我们更好地应对各种需求。如果你有任何问题或建议，欢迎在评论区留言讨论。