在Spring Boot开发中，拦截器是一种强大且灵活的工具，它能够在请求到达控制器之前或响应返回客户端之前执行自定义逻辑。通过拦截器，我们可以实现各种常见的功能，如日志记录、身份认证、权限校验、数据压缩等。本文将详细介绍Spring Boot拦截器的概念、使用方法、常见应用场景及最佳实践，旨在帮助开发者全面掌握Spring Boot拦截器的使用。

1. 什么是拦截器？

拦截器（Interceptor）是一种动态拦截处理机制，允许在请求处理的各个阶段插入额外的逻辑。拦截器主要用于对HTTP请求进行预处理和后处理，可以在以下几个阶段进行干预：

1. 请求预处理：在请求到达控制器方法之前执行。
2. 请求后处理：在控制器方法执行之后、视图渲染之前执行。
3. 完成处理：在整个请求完成之后执行，用于进行资源清理等操作。

2. Spring Boot中的拦截器

在Spring Boot中，拦截器是基于Spring MVC的HandlerInterceptor接口实现的。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)：在整个请求完成之后调用，用于进行资源清理等操作。

2.1 创建拦截器

首先，我们需要创建一个实现HandlerInterceptor接口的拦截器类。

package com.example.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class CustomInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("Pre Handle method is Calling");
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("Post Handle method is Calling");
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) throws Exception {
        System.out.println("Request and Response is completed");
    }
}

2.2 注册拦截器

然后，我们需要在配置类中注册这个拦截器。我们可以通过继承WebMvcConfigurer接口并重写addInterceptors方法来实现拦截器的注册。

package com.example.config;
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;
import com.example.interceptor.CustomInterceptor;
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private CustomInterceptor customInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(customInterceptor).addPathPatterns("/**");
    }
}

在上面的代码中，我们将自定义的拦截器CustomInterceptor注册到Spring MVC的拦截器链中，并指定它对所有请求路径/**进行拦截。

3. 常见的拦截器应用场景

拦截器在实际开发中有着广泛的应用，下面我们将介绍几个常见的应用场景。

3.1 日志记录

在大型应用中，记录日志是一个非常重要的功能。通过拦截器，我们可以在请求处理的各个阶段记录日志，方便问题排查和性能分析。

package com.example.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class LoggingInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("Request URL: " + request.getRequestURL());
        System.out.println("Start Time: " + System.currentTimeMillis());
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("Request URL: " + request.getRequestURL());
        System.out.println("End Time: " + System.currentTimeMillis());
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) throws Exception {
        System.out.println("Request URL: " + request.getRequestURL());
        System.out.println("Request and Response is completed");
    }
}

3.2 身份认证

在许多应用中，确保用户的身份合法性是至关重要的。通过拦截器，我们可以在请求到达控制器之前进行身份认证，拦截非法请求。

package com.example.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
public class AuthenticationInterceptor 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;
    }
    private boolean isValidToken(String token) {
        // 验证token的合法性
        return "valid-token".equals(token);
    }
}

3.3 权限校验

除了身份认证外，许多应用还需要进行权限校验。通过拦截器，我们可以在请求到达控制器之前校验用户是否有权限访问某些资源。

package com.example.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
public class AuthorizationInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String userRole = getUserRole(request);
        if (!hasPermission(userRole, request.getRequestURI())) {
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
            return false;
        }
        return true;
    }
    private String getUserRole(HttpServletRequest request) {
        // 获取用户角色
        return "USER";
    }
    private boolean hasPermission(String userRole, String requestURI) {
        // 校验用户是否有权限访问该URI
        return "ADMIN".equals(userRole);
    }
}

3.4 数据压缩

为了提高网络传输效率，我们可以在拦截器中对响应数据进行压缩处理。

package com.example.interceptor;
import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
import java.util.zip.GZIPOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class CompressionInterceptor implements HandlerInterceptor {
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        if (response.getContentType() != null && response.getContentType().contains("application/json")) {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream);
            PrintWriter printWriter = new PrintWriter(gzipOutputStream);
            // 获取响应数据并压缩
            String responseData = response.getOutputStream().toString();
            printWriter.write(responseData);
            printWriter.close();
            gzipOutputStream.close();
            byte[] compressedData = byteArrayOutputStream.toByteArray();
            response.setHeader("Content-Encoding", "gzip");
            response.setContentLength(compressedData.length);
            response.getOutputStream().write(compressedData);
        }
    }
}

4. 拦截器的高级用法

除了基本的拦截器使用方法外，Spring Boot还支持一些高级用法，如多拦截器链、动态注册拦截器和全局异常处理等。

4.1 多拦截器链

Spring Boot允许在一个应用中注册多个拦截器，并按照注册顺序依次执行。我们可以在addInterceptors方法中注册多个拦截器。

package com.example.config;
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;
import com.example.interceptor.LoggingInterceptor;
import com.example.interceptor.AuthenticationInterceptor;
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoggingInterceptor loggingInterceptor;
    @Autowired
    private AuthenticationInterceptor authenticationInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loggingInterceptor).addPathPatterns("/**");
        registry.addInterceptor(authenticationInterceptor).addPathPatterns("/**");
    }
}

在上述代码中，LoggingInterceptor和AuthenticationInterceptor会按顺序依次执行。

4.2 动态注册拦截器

有时候，我们需要根据特定条件动态注册拦截器。Spring Boot提供了InterceptorRegistration接口，允许在运行时动态添加或删除拦截器。

package com.example.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
@Configuration
public class DynamicWebConfig implements WebMvcConfigurer {
    @Autowired
    private HandlerInterceptor customInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        InterceptorRegistration registration = registry.addInterceptor(customInterceptor).addPathPatterns("/**");
        // 根据条件动态添加或删除拦截器
        if (shouldAddInterceptor()) {
            registration.addPathPatterns("/dynamic/**");
        } else {
            registration.excludePathPatterns("/dynamic/**");
        }
    }
    private boolean shouldAddInterceptor() {
        // 判断是否需要添加拦截器
        return true;
    }
}

4.3 全局异常处理

通过拦截器，我们还可以实现全局异常处理，统一处理应用中的异常情况。可以在拦截器的afterCompletion方法中捕获异常，并进行相应处理。

package com.example.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
public class ExceptionHandlingInterceptor implements HandlerInterceptor {
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) throws Exception {
        if (exception != null) {
            // 记录异常日志或发送通知
            System.err.println("Exception caught: " + exception.getMessage());
        }
    }
}

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

在Spring Boot中，除了拦截器外，还有一种类似的机制叫做过滤器（Filter）。拦截器和过滤器在功能上有一定的重叠，但它们的使用场景和实现方式有所不同。

5.1 拦截器

拦截器是Spring MVC框架的一部分，主要用于处理Spring MVC的请求和响应。拦截器的主要特点包括：

• 基于Spring MVC：拦截器只能拦截Spring MVC的请求和响应。
• 与控制器紧密结合：拦截器在控制器方法调用前后和请求完成后进行拦截。
• 使用方便：拦截器使用Spring的HandlerInterceptor接口，易于配置和使用。

5.2 过滤器

过滤器是Java Servlet规范的一部分，主要用于在Web应用的请求和响应过程中进行过滤。过滤器的主要特点包括：

• 基于Servlet：过滤器可以拦截所有类型的请求和响应，包括静态资源、JSP页面等。
• 通用性强：过滤器可以用于任何基于Servlet的Web应用，不仅限于Spring MVC。
• 实现复杂：过滤器使用Servlet的Filter接口，需要手动管理过滤链。

5.3 拦截器与过滤器的选择

拦截器和过滤器各有优劣，具体选择哪种机制取决于实际需求：

• 如果需要拦截Spring MVC的请求和响应，推荐使用拦截器，因其与Spring MVC集成紧密，使用方便。
• 如果需要拦截所有类型的请求和响应，推荐使用过滤器，因其通用性强，适用范围广。

6. 实践案例：构建一个复杂的拦截器链

为了更好地理解Spring Boot拦截器的应用，下面我们通过一个实际案例，展示如何在一个复杂项目中使用拦截器实现各种功能。

6.1 项目背景

假设我们要开发一个电商系统，包含用户管理、商品管理和订单处理等多个模块。我们需要在项目中使用拦截器实现以下功能：

1. 日志记录：记录所有请求的URL和处理时间。
2. 身份认证：确保用户的身份合法性。
3. 权限校验：校验用户是否有权限访问某些资源。
4. 数据压缩：对响应数据进行压缩处理。

6.2 项目结构

ecommerce
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── ecommerce
│   │   │               ├── config
│   │   │               │   ├── WebConfig.java
│   │   │               ├── interceptor
│   │   │               │   ├── LoggingInterceptor.java
│   │   │               │   ├── AuthenticationInterceptor.java
│   │   │               │   ├── AuthorizationInterceptor.java
│   │   │               │   ├── CompressionInterceptor.java
│   │   │               ├── controller
│   │   │               │   ├── UserController.java
│   │   │               │   ├── ProductController.java
│   │   │               │   ├── OrderController.java
└── pom.xml

6.3 配置类

package com.example.config;
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;
import com.example.interceptor.LoggingInterceptor;
import com.example.interceptor.AuthenticationInterceptor;
import com.example.interceptor.AuthorizationInterceptor;
import com.example.interceptor.CompressionInterceptor;
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoggingInterceptor loggingInterceptor;
    @Autowired
    private AuthenticationInterceptor authenticationInterceptor;
    @Autowired
    private AuthorizationInterceptor authorizationInterceptor;
    @Autowired
    private CompressionInterceptor compressionInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loggingInterceptor).addPathPatterns("/**");
        registry.addInterceptor(authenticationInterceptor).addPathPatterns("/**");
        registry.addInterceptor(authorizationInterceptor).addPathPatterns("/**");
        registry.addInterceptor(compressionInterceptor).addPathPatterns("/**");
    }
}

6.4 拦截器类

// LoggingInterceptor.java
package com.example.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class LoggingInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("Request URL: " + request.getRequestURL());
        System.out.println("Start Time: " + System.currentTimeMillis());
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("Request URL: " + request.getRequestURL());
        System.out.println("End Time: " + System.currentTimeMillis());
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) throws Exception {
        System.out.println("Request URL: " + request.getRequestURL());
        System.out.println("Request and Response is completed");
    }
}

// AuthenticationInterceptor.java
package com.example.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
public class AuthenticationInterceptor 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;
    }
    private boolean isValidToken(String token) {
        // 验证token的合法性
        return "valid-token".equals(token);
    }
}

// AuthorizationInterceptor.java
package com.example.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
public class AuthorizationInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String userRole = getUserRole(request);
        if (!hasPermission(userRole, request.getRequestURI())) {
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
            return false;
        }
        return true;
    }
    private String getUserRole(HttpServletRequest request) {
        // 获取用户角色
        return "USER";
    }
    private boolean hasPermission(String userRole, String requestURI) {
        // 校验用户是否有权限访问该URI
        return "ADMIN".equals(userRole);
    }
}

// CompressionInterceptor.java
package com.example.interceptor;
import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
import java.util.zip.GZIPOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class CompressionInterceptor implements HandlerInterceptor {
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        if (response.getContentType() != null && response.getContentType().contains("application/json")) {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream);
            PrintWriter printWriter = new PrintWriter(gzipOutputStream);
            // 获取响应数据并压缩
            String responseData = response.getOutputStream().toString();
            printWriter.write(responseData);
            printWriter.close();
            gzipOutputStream.close();
            byte[] compressedData = byteArrayOutputStream.toByteArray();
            response.setHeader("Content-Encoding", "gzip");
            response.setContentLength(compressedData.length);
            response.getOutputStream().write(compressedData);
        }
    }
}

6.5 控制器类

// UserController.java
package com.example.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/users")
public class UserController {
    @GetMapping
    public String getUsers() {
        return "User List";
    }
}

// ProductController.java
package com.example.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/products")
public class ProductController {
    @GetMapping
    public String getProducts() {
        return "Product List";
    }
}

// OrderController.java
package com.example.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/orders")
public class OrderController {
    @GetMapping
    public String getOrders() {
        return "Order List";
    }
}

7. 最佳实践

在实际开发中，使用Spring Boot拦截器时应遵循一些最佳实践，以确保拦截器的高效和稳定。

7.1 合理设计拦截器链

拦截器链的设计应遵循职责单一、功能明确的原则。每个拦截器应只负责一个特定的功能，如日志记录、身份认证、权限校验等。通过合理设计拦截器链，可以提高代码的可读性和可维护性。

7.2 避免拦截器中执行耗时操作

拦截器主要用于请求的预处理和后处理，避免在拦截器中执行耗时操作，如数据库查询、大量计算等。耗时操作应放在异步任务中执行，以避免阻塞主线程，影响应用的响应时间。

7.3 使用合适的异常处理机制

在拦截器中捕获异常时，应使用合适的异常处理机制，避免异常在拦截器中被吞掉。可以通过全局异常处理机制，统一处理拦截器中的异常。

7.4 充分利用Spring的依赖注入

在拦截器中，可以充分利用Spring的依赖注入机制，将需要的服务或组件注入到拦截器中，以提高代码的可测试性和可维护性。

8. 总结

Spring Boot拦截器是一个强大且灵活的工具，能够在请求处理的各个阶段插入自定义逻辑，实现各种常见的功能。通过本文的介绍，我们详细了解了Spring Boot拦截器的概念、使用方法、常见应用场景及最佳实践。此外，通过实际案例，我们进一步理解了如何在复杂项目中使用拦截器实现各种功能。