6種常見的SpringBoot攔截器使用場景及實現(xiàn)方式
更新時間：2025年04月30日 08:21:53 作者：風象南
這篇文章主要為大家詳細介紹了SpringBoot中6種常見的攔截器使用場景及其實現(xiàn)方式,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下
在構(gòu)建企業(yè)級Web應用時，我們經(jīng)常需要在請求處理的不同階段執(zhí)行一些通用邏輯，如權(quán)限驗證、日志記錄、性能監(jiān)控等。
Spring MVC的攔截器(Interceptor)機制提供了一種優(yōu)雅的方式來實現(xiàn)這些橫切關(guān)注點，而不必在每個控制器中重復編寫相同的代碼。
本文將介紹SpringBoot中6種常見的攔截器使用場景及其實現(xiàn)方式。
攔截器基礎(chǔ)
什么是攔截器
攔截器是Spring MVC框架提供的一種機制，用于在控制器(Controller)處理請求前后執(zhí)行特定的邏輯。
攔截器與過濾器的區(qū)別
1. 歸屬不同：過濾器(Filter)屬于Servlet規(guī)范，攔截器屬于Spring框架。
2. 攔截范圍：過濾器能攔截所有請求，攔截器只能攔截Spring MVC的請求。
3. 執(zhí)行順序：請求首先經(jīng)過過濾器，然后才會被攔截器處理。
攔截器的生命周期方法
攔截器通過實現(xiàn)HandlerInterceptor接口來定義，該接口包含三個核心方法：
1. preHandle() ：在控制器方法執(zhí)行前調(diào)用，返回true表示繼續(xù)執(zhí)行，返回false表示中斷請求。
2. postHandle() ：在控制器方法執(zhí)行后、視圖渲染前調(diào)用。
3. afterCompletion() ：在整個請求完成后調(diào)用，無論是否有異常發(fā)生。
場景一：用戶認證攔截器
使用場景
用戶認證攔截器主要用于:
- 驗證用戶是否已登錄
- 檢查用戶是否有權(quán)限訪問特定資源
- 實現(xiàn)無狀態(tài)API的JWT token驗證
實現(xiàn)代碼
@Component
public class AuthenticationInterceptor implements HandlerInterceptor {
@Autowired
private JwtTokenProvider jwtTokenProvider;
@Autowired
private UserService userService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 跳過非控制器方法的處理
if (!(handler instanceof HandlerMethod)) {
return true;
}
HandlerMethod handlerMethod = (HandlerMethod) handler;
// 檢查是否有@PermitAll注解，有則跳過認證
PermitAll permitAll = handlerMethod.getMethodAnnotation(PermitAll.class);
if (permitAll != null) {
return true;
}
// 從請求頭中獲取token
String token = request.getHeader("Authorization");
if (token == null || !token.startsWith("Bearer ")) {
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.getWriter().write("{"error": "未授權(quán)，請先登錄"}");
return false;
}
token = token.substring(7); // 去掉"Bearer "前綴
try {
// 驗證token
if (!jwtTokenProvider.validateToken(token)) {
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.getWriter().write("{"error": "Token已失效，請重新登錄"}");
return false;
}
// 從token中獲取用戶信息并設(shè)置到請求屬性中
String username = jwtTokenProvider.getUsernameFromToken(token);
User user = userService.findByUsername(username);
if (user == null) {
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.getWriter().write("{"error": "用戶不存在"}");
return false;
}
// 檢查方法是否有@RequireRole注解
RequireRole requireRole = handlerMethod.getMethodAnnotation(RequireRole.class);
if (requireRole != null) {
// 檢查用戶是否有所需角色
String[] roles = requireRole.value();
boolean hasRole = false;
for (String role : roles) {
if (user.hasRole(role)) {
hasRole = true;
break;
}
}
if (!hasRole) {
response.setStatus(HttpServletResponse.SC_FORBIDDEN);
response.getWriter().write("{"error": "權(quán)限不足"}");
return false;
}
}
// 將用戶信息放入請求屬性
request.setAttribute("currentUser", user);
return true;
} catch (Exception e) {
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.getWriter().write("{"error": "Token驗證失敗"}");
return false;
}
}
}配置注冊
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
@Autowired
private AuthenticationInterceptor authenticationInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(authenticationInterceptor)
.addPathPatterns("/api/**")
.excludePathPatterns("/api/auth/login", "/api/auth/register");
}
}自定義注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PermitAll {
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequireRole {
String[] value();
}最佳實踐
1. 使用注解來標記需要認證或特定權(quán)限的接口
2. 將攔截器中的業(yè)務(wù)邏輯抽取到專門的服務(wù)類中
3. 為不同安全級別的API設(shè)計不同的路徑前綴
4. 添加詳細的日志記錄，便于問題排查
場景二：日志記錄攔截器
使用場景
日志記錄攔截器主要用于：
- 記錄API請求和響應內(nèi)容
- 跟蹤用戶行為
- 收集系統(tǒng)使用統(tǒng)計數(shù)據(jù)
- 輔助問題排查
實現(xiàn)代碼
@Component
@Slf4j
public class LoggingInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 記錄請求開始時間
long startTime = System.currentTimeMillis();
request.setAttribute("startTime", startTime);
// 記錄請求信息
String requestURI = request.getRequestURI();
String method = request.getMethod();
String remoteAddr = request.getRemoteAddr();
String userAgent = request.getHeader("User-Agent");
// 獲取當前用戶（如果已通過認證攔截器）
Object currentUser = request.getAttribute("currentUser");
String username = currentUser != null ? ((User) currentUser).getUsername() : "anonymous";
// 記錄請求參數(shù)
Map<String, String[]> paramMap = request.getParameterMap();
StringBuilder params = new StringBuilder();
if (!paramMap.isEmpty()) {
for (Map.Entry<String, String[]> entry : paramMap.entrySet()) {
params.append(entry.getKey())
.append("=")
.append(String.join(",", entry.getValue()))
.append("&");
}
if (params.length() > 0) {
params.deleteCharAt(params.length() - 1);
}
}
// 記錄請求體（僅POST/PUT/PATCH請求）
String requestBody = "";
if (HttpMethod.POST.matches(method) ||
HttpMethod.PUT.matches(method) ||
HttpMethod.PATCH.matches(method)) {
// 使用包裝請求對象來多次讀取請求體
ContentCachingRequestWrapper wrappedRequest =
new ContentCachingRequestWrapper(request);
// 為了觸發(fā)內(nèi)容緩存，我們需要獲取一次輸入流
if (wrappedRequest.getContentLength() > 0) {
wrappedRequest.getInputStream().read();
requestBody = new String(wrappedRequest.getContentAsByteArray(),
wrappedRequest.getCharacterEncoding());
}
}
log.info(
"REQUEST: {} {} from={} user={} userAgent={} params={} body={}",
method,
requestURI,
remoteAddr,
username,
userAgent,
params,
requestBody
);
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
// 計算請求處理時間
long startTime = (Long) request.getAttribute("startTime");
long endTime = System.currentTimeMillis();
long processingTime = endTime - startTime;
// 記錄響應狀態(tài)和處理時間
int status = response.getStatus();
String requestURI = request.getRequestURI();
String method = request.getMethod();
if (ex != null) {
log.error(
"RESPONSE: {} {} status={} time={}ms error={}",
method,
requestURI,
status,
processingTime,
ex.getMessage()
);
} else {
log.info(
"RESPONSE: {} {} status={} time={}ms",
method,
requestURI,
status,
processingTime
);
}
}
}配置與使用
@Bean
public FilterRegistrationBean<ContentCachingFilter> contentCachingFilter() {
FilterRegistrationBean<ContentCachingFilter> registrationBean = new FilterRegistrationBean<>();
registrationBean.setFilter(new ContentCachingFilter());
registrationBean.addUrlPatterns("/api/*");
return registrationBean;
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(loggingInterceptor)
.addPathPatterns("/**");
}自定義內(nèi)容緩存過濾器
public class ContentCachingFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
FilterChain filterChain) throws ServletException, IOException {
ContentCachingRequestWrapper wrappedRequest = new ContentCachingRequestWrapper(request);
ContentCachingResponseWrapper wrappedResponse = new ContentCachingResponseWrapper(response);
try {
filterChain.doFilter(wrappedRequest, wrappedResponse);
} finally {
wrappedResponse.copyBodyToResponse();
}
}
}最佳實踐
1. 對敏感信息（如密碼、信用卡號等）進行脫敏處理
2. 設(shè)置合理的日志級別和輪轉(zhuǎn)策略
3. 針對大型請求/響應體，考慮只記錄部分內(nèi)容或摘要
4. 使用MDC(Mapped Diagnostic Context)記錄請求ID，便于跟蹤完整請求鏈路
場景三：性能監(jiān)控攔截器
使用場景
性能監(jiān)控攔截器主要用于：
- 監(jiān)控API響應時間
- 識別性能瓶頸
- 統(tǒng)計慢查詢
- 提供性能指標用于系統(tǒng)優(yōu)化
實現(xiàn)代碼
@Component
@Slf4j
public class PerformanceMonitorInterceptor implements HandlerInterceptor {
// 慢請求閾值，單位毫秒
@Value("${app.performance.slow-request-threshold:500}")
private long slowRequestThreshold;
@Autowired
private MetricsService metricsService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
String controllerName = handlerMethod.getBeanType().getSimpleName();
String methodName = handlerMethod.getMethod().getName();
request.setAttribute("controllerName", controllerName);
request.setAttribute("methodName", methodName);
request.setAttribute("startTime", System.currentTimeMillis());
}
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
Long startTime = (Long) request.getAttribute("startTime");
if (startTime != null) {
long processingTime = System.currentTimeMillis() - startTime;
String controllerName = (String) request.getAttribute("controllerName");
String methodName = (String) request.getAttribute("methodName");
String uri = request.getRequestURI();
// 記錄性能數(shù)據(jù)
metricsService.recordApiPerformance(controllerName, methodName, uri, processingTime);
// 記錄慢請求
if (processingTime > slowRequestThreshold) {
log.warn("Slow API detected: {} {}.{} - {}ms (threshold: {}ms)",
uri, controllerName, methodName, processingTime, slowRequestThreshold);
// 記錄慢請求到專門的監(jiān)控系統(tǒng)
metricsService.recordSlowRequest(controllerName, methodName, uri, processingTime);
}
}
}
}指標服務(wù)實現(xiàn)
@Service
@Slf4j
public class MetricsServiceImpl implements MetricsService {
// 使用滑動窗口記錄最近的性能數(shù)據(jù)
private final ConcurrentMap<String, SlidingWindowMetric> apiMetrics = new ConcurrentHashMap<>();
// 慢請求記錄隊列
private final Queue<SlowRequestRecord> slowRequests = new ConcurrentLinkedQueue<>();
// 保留最近1000條慢請求記錄
private static final int MAX_SLOW_REQUESTS = 1000;
@Override
public void recordApiPerformance(String controller, String method, String uri, long processingTime) {
String apiKey = controller + "." + method;
apiMetrics.computeIfAbsent(apiKey, k -> new SlidingWindowMetric())
.addSample(processingTime);
// 可以在這里添加Prometheus或其他監(jiān)控系統(tǒng)的指標記錄
}
@Override
public void recordSlowRequest(String controller, String method, String uri, long processingTime) {
SlowRequestRecord record = new SlowRequestRecord(
controller, method, uri, processingTime, LocalDateTime.now()
);
slowRequests.add(record);
// 如果隊列超過最大容量，移除最早的記錄
while (slowRequests.size() > MAX_SLOW_REQUESTS) {
slowRequests.poll();
}
}
@Override
public List<ApiPerformanceMetric> getApiPerformanceMetrics() {
List<ApiPerformanceMetric> metrics = new ArrayList<>();
for (Map.Entry<String, SlidingWindowMetric> entry : apiMetrics.entrySet()) {
String[] parts = entry.getKey().split("\.");
String controller = parts[0];
String method = parts.length > 1 ? parts[1] : "";
SlidingWindowMetric metric = entry.getValue();
metrics.add(new ApiPerformanceMetric(
controller,
method,
metric.getAvg(),
metric.getMin(),
metric.getMax(),
metric.getCount()
));
}
return metrics;
}
@Override
public List<SlowRequestRecord> getSlowRequests() {
return new ArrayList<>(slowRequests);
}
// 滑動窗口指標類
private static class SlidingWindowMetric {
private final LongAdder count = new LongAdder();
private final LongAdder sum = new LongAdder();
private final AtomicLong min = new AtomicLong(Long.MAX_VALUE);
private final AtomicLong max = new AtomicLong(0);
public void addSample(long value) {
count.increment();
sum.add(value);
// 更新最小值
while (true) {
long currentMin = min.get();
if (value >= currentMin || min.compareAndSet(currentMin, value)) {
break;
}
}
// 更新最大值
while (true) {
long currentMax = max.get();
if (value <= currentMax || max.compareAndSet(currentMax, value)) {
break;
}
}
}
public long getCount() {
return count.sum();
}
public double getAvg() {
long countValue = count.sum();
return countValue > 0 ? (double) sum.sum() / countValue : 0;
}
public long getMin() {
return min.get() == Long.MAX_VALUE ? 0 : min.get();
}
public long getMax() {
return max.get();
}
}
}實體類定義
@Data
@AllArgsConstructor
public class ApiPerformanceMetric {
private String controllerName;
private String methodName;
private double avgProcessingTime;
private long minProcessingTime;
private long maxProcessingTime;
private long requestCount;
}
@Data
@AllArgsConstructor
public class SlowRequestRecord {
private String controllerName;
private String methodName;
private String uri;
private long processingTime;
private LocalDateTime timestamp;
}指標服務(wù)接口
public interface MetricsService {
void recordApiPerformance(String controller, String method, String uri, long processingTime);
void recordSlowRequest(String controller, String method, String uri, long processingTime);
List<ApiPerformanceMetric> getApiPerformanceMetrics();
List<SlowRequestRecord> getSlowRequests();
}性能監(jiān)控控制器
@RestController
@RequestMapping("/admin/metrics")
public class MetricsController {
@Autowired
private MetricsService metricsService;
@GetMapping("/api-performance")
public List<ApiPerformanceMetric> getApiPerformanceMetrics() {
return metricsService.getApiPerformanceMetrics();
}
@GetMapping("/slow-requests")
public List<SlowRequestRecord> getSlowRequests() {
return metricsService.getSlowRequests();
}
}最佳實踐
1. 使用滑動窗口統(tǒng)計，避免內(nèi)存無限增長
2. 為不同API設(shè)置不同的性能閾值
3. 將性能數(shù)據(jù)導出到專業(yè)監(jiān)控系統(tǒng)(如Prometheus)
4. 設(shè)置告警機制，及時發(fā)現(xiàn)性能問題
5. 只對重要接口進行詳細監(jiān)控，避免過度監(jiān)控帶來的性能開銷
場景四：接口限流攔截器
使用場景
接口限流攔截器主要用于：
- 防止接口被惡意頻繁調(diào)用
- 保護系統(tǒng)資源，避免過載
- 實現(xiàn)API訪問量控制
- 防止DoS攻擊
實現(xiàn)代碼
@Component
@Slf4j
public class RateLimitInterceptor implements HandlerInterceptor {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Value("${app.rate-limit.enabled:true}")
private boolean enabled;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
if (!enabled) {
return true;
}
if (!(handler instanceof HandlerMethod)) {
return true;
}
HandlerMethod handlerMethod = (HandlerMethod) handler;
// 獲取限流注解
RateLimit rateLimit = handlerMethod.getMethodAnnotation(RateLimit.class);
if (rateLimit == null) {
// 沒有配置限流注解，不進行限流
return true;
}
// 獲取限流類型
RateLimitType limitType = rateLimit.type();
// 根據(jù)限流類型獲取限流鍵
String limitKey = getLimitKey(request, limitType);
// 獲取限流配置
int limit = rateLimit.limit();
int period = rateLimit.period();
// 執(zhí)行限流檢查
boolean allowed = checkRateLimit(limitKey, limit, period);
if (!allowed) {
// 超過限流，返回429狀態(tài)碼
response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
response.getWriter().write("{"error":"Too many requests","message":"請求頻率超過限制，請稍后再試"}");
return false;
}
return true;
}
private String getLimitKey(HttpServletRequest request, RateLimitType limitType) {
String key = "rate_limit:";
switch (limitType) {
case IP:
key += "ip:" + getClientIp(request);
break;
case USER:
// 從認證信息獲取用戶ID
Object currentUser = request.getAttribute("currentUser");
String userId = currentUser != null ?
String.valueOf(((User) currentUser).getId()) : "anonymous";
key += "user:" + userId;
break;
case API:
key += "api:" + request.getRequestURI();
break;
case IP_API:
key += "ip_api:" + getClientIp(request) + ":" + request.getRequestURI();
break;
case USER_API:
Object user = request.getAttribute("currentUser");
String id = user != null ?
String.valueOf(((User) user).getId()) : "anonymous";
key += "user_api:" + id + ":" + request.getRequestURI();
break;
default:
key += "global";
}
return key;
}
private boolean checkRateLimit(String key, int limit, int period) {
// 使用Redis的原子操作進行限流檢查
Long count = redisTemplate.execute(connection -> {
// 遞增計數(shù)器
Long currentCount = connection.stringCommands().incr(key.getBytes());
// 如果是第一次遞增，設(shè)置過期時間
if (currentCount != null && currentCount == 1) {
connection.keyCommands().expire(key.getBytes(), period);
}
return currentCount;
}, true);
return count != null && count <= limit;
}
private String getClientIp(HttpServletRequest request) {
String ipAddress = request.getHeader("X-Forwarded-For");
if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("Proxy-Client-IP");
}
if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("WL-Proxy-Client-IP");
}
if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getRemoteAddr();
if ("127.0.0.1".equals(ipAddress) || "0:0:0:0:0:0:0:1".equals(ipAddress)) {
// 根據(jù)網(wǎng)卡取本機配置的IP
try {
InetAddress inet = InetAddress.getLocalHost();
ipAddress = inet.getHostAddress();
} catch (UnknownHostException e) {
log.error("獲取本機IP失敗", e);
}
}
}
// 對于多個代理的情況，第一個IP為客戶端真實IP
if (ipAddress != null && ipAddress.contains(",")) {
ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
}
return ipAddress;
}
}限流注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
/**
* 限流類型
*/
RateLimitType type() default RateLimitType.IP;
/**
* 限制次數(shù)
*/
int limit() default 100;
/**
* 時間周期(秒)
*/
int period() default 60;
}
public enum RateLimitType {
/**
* 按IP地址限流
*/
IP,
/**
* 按用戶限流
*/
USER,
/**
* 按接口限流
*/
API,
/**
* 按IP和接口組合限流
*/
IP_API,
/**
* 按用戶和接口組合限流
*/
USER_API,
/**
* 全局限流
*/
GLOBAL
}使用示例
@RestController
@RequestMapping("/api/products")
public class ProductController {
@Autowired
private ProductService productService;
@GetMapping
@RateLimit(type = RateLimitType.IP, limit = 100, period = 60)
public List<Product> getProducts() {
return productService.findAll();
}
@GetMapping("/{id}")
@RateLimit(type = RateLimitType.IP, limit = 200, period = 60)
public Product getProduct(@PathVariable Long id) {
return productService.findById(id)
.orElseThrow(() -> new ResourceNotFoundException("Product not found"));
}
@PostMapping
@RequireRole("ADMIN")
@RateLimit(type = RateLimitType.USER, limit = 10, period = 60)
public Product createProduct(@RequestBody @Valid ProductRequest productRequest) {
return productService.save(productRequest);
}
}最佳實踐
1. 根據(jù)接口重要性和資源消耗設(shè)置不同的限流規(guī)則
2. 使用分布式限流解決方案，如Redis+Lua腳本
3. 為特定用戶群體設(shè)置不同的限流策略
4. 在限流響應中提供合理的重試建議
5. 監(jiān)控限流情況，及時調(diào)整限流閾值
場景五：請求參數(shù)驗證攔截器
使用場景
請求參數(shù)驗證攔截器主要用于：
- 統(tǒng)一處理參數(shù)驗證邏輯
- 提供友好的錯誤信息
- 防止非法參數(shù)導致的安全問題
- 減少控制器中的重復代碼
實現(xiàn)代碼
@Component
@Slf4j
public class RequestValidationInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
if (!(handler instanceof HandlerMethod)) {
return true;
}
HandlerMethod handlerMethod = (HandlerMethod) handler;
// 檢查方法參數(shù)是否需要驗證
Parameter[] parameters = handlerMethod.getMethod().getParameters();
for (Parameter parameter : parameters) {
// 檢查是否有@RequestBody注解
if (parameter.isAnnotationPresent(RequestBody.class) &&
parameter.isAnnotationPresent(Valid.class)) {
// 該參數(shù)需要驗證，在控制器方法中會自動驗證
// 這里只需確保我們能處理驗證失敗的情況
// 通過全局異常處理器處理MethodArgumentNotValidException
// 記錄驗證將要發(fā)生
log.debug("將對 {}.{} 的請求體參數(shù) {} 進行驗證",
handlerMethod.getBeanType().getSimpleName(),
handlerMethod.getMethod().getName(),
parameter.getName());
}
// 檢查是否有@RequestParam注解
RequestParam requestParam = parameter.getAnnotation(RequestParam.class);
if (requestParam != null) {
String paramName = requestParam.value().isEmpty() ?
parameter.getName() : requestParam.value();
String paramValue = request.getParameter(paramName);
// 檢查必填參數(shù)
if (requestParam.required() && (paramValue == null || paramValue.isEmpty())) {
response.setStatus(HttpStatus.BAD_REQUEST.value());
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
response.getWriter().write(
"{"error":"參數(shù)錯誤","message":"缺少必填參數(shù): " + paramName + ""}");
return false;
}
// 檢查參數(shù)格式（如果有注解）
if (parameter.isAnnotationPresent(Pattern.class) && paramValue != null) {
Pattern pattern = parameter.getAnnotation(Pattern.class);
if (!paramValue.matches(pattern.regexp())) {
response.setStatus(HttpStatus.BAD_REQUEST.value());
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
response.getWriter().write(
"{"error":"參數(shù)錯誤","message":"參數(shù) " +
paramName + " 格式不正確: " + pattern.message() + ""}");
return false;
}
}
}
// 檢查是否有@PathVariable注解
PathVariable pathVariable = parameter.getAnnotation(PathVariable.class);
if (pathVariable != null) {
// 對于PathVariable的驗證主要依賴RequestMappingHandlerMapping的正則匹配
// 這里可以添加額外的驗證邏輯，如數(shù)值范圍檢查等
}
}
return true;
}
}全局異常處理
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
/**
* 處理請求體參數(shù)驗證失敗的異常
*/
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<Map<String, Object>> handleValidationExceptions(
MethodArgumentNotValidException ex) {
Map<String, String> errors = new HashMap<>();
ex.getBindingResult().getAllErrors().forEach(error -> {
String fieldName = ((FieldError) error).getField();
String errorMessage = error.getDefaultMessage();
errors.put(fieldName, errorMessage);
});
Map<String, Object> body = new HashMap<>();
body.put("error", "參數(shù)驗證失敗");
body.put("details", errors);
return ResponseEntity.badRequest().body(body);
}
/**
* 處理請求參數(shù)綁定失敗的異常
*/
@ExceptionHandler(MissingServletRequestParameterException.class)
public ResponseEntity<Map<String, Object>> handleMissingParams(
MissingServletRequestParameterException ex) {
Map<String, Object> body = new HashMap<>();
body.put("error", "參數(shù)錯誤");
body.put("message", "缺少必填參數(shù): " + ex.getParameterName());
return ResponseEntity.badRequest().body(body);
}
/**
* 處理路徑參數(shù)類型不匹配的異常
*/
@ExceptionHandler(MethodArgumentTypeMismatchException.class)
public ResponseEntity<Map<String, Object>> handleTypeMismatch(
MethodArgumentTypeMismatchException ex) {
Map<String, Object> body = new HashMap<>();
body.put("error", "參數(shù)類型錯誤");
body.put("message", "參數(shù) " + ex.getName() + " 應為 " +
ex.getRequiredType().getSimpleName() + " 類型");
return ResponseEntity.badRequest().body(body);
}
}使用示例
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
@GetMapping
public List<User> getUsers(
@RequestParam(required = false)
@Pattern(regexp = "^[a-zA-Z0-9]+$", message = "只能包含字母和數(shù)字")
String keyword,
@RequestParam(defaultValue = "0")
@Min(value = 0, message = "頁碼不能小于0")
Integer page,
@RequestParam(defaultValue = "10")
@Min(value = 1, message = "每頁條數(shù)不能小于1")
@Max(value = 100, message = "每頁條數(shù)不能大于100")
Integer size) {
return userService.findUsers(keyword, page, size);
}
@PostMapping
public User createUser(@RequestBody @Valid UserCreateRequest request) {
return userService.createUser(request);
}
@GetMapping("/{id}")
public User getUser(@PathVariable @Positive(message = "用戶ID必須為正整數(shù)") Long id) {
return userService.findById(id)
.orElseThrow(() -> new ResourceNotFoundException("User not found"));
}
}自定義驗證請求類
@Data
public class UserCreateRequest {
@NotBlank(message = "用戶名不能為空")
@Size(min = 4, max = 20, message = "用戶名長度必須在4-20之間")
@Pattern(regexp = "^[a-zA-Z0-9_]+$", message = "用戶名只能包含字母、數(shù)字和下劃線")
private String username;
@NotBlank(message = "密碼不能為空")
@Size(min = 6, max = 20, message = "密碼長度必須在6-20之間")
@Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$",
message = "密碼必須包含大小寫字母和數(shù)字")
private String password;
@NotBlank(message = "郵箱不能為空")
@Email(message = "郵箱格式不正確")
private String email;
@NotBlank(message = "手機號不能為空")
@Pattern(regexp = "^1[3-9]\d{9}$", message = "手機號格式不正確")
private String phone;
@NotNull(message = "年齡不能為空")
@Min(value = 18, message = "年齡必須大于或等于18歲")
@Max(value = 120, message = "年齡必須小于或等于120歲")
private Integer age;
@NotEmpty(message = "角色不能為空")
private List<String> roles;
@Valid
private Address address;
}
@Data
public class Address {
@NotBlank(message = "省份不能為空")
private String province;
@NotBlank(message = "城市不能為空")
private String city;
@NotBlank(message = "詳細地址不能為空")
private String detail;
@Pattern(regexp = "^\d{6}$", message = "郵編必須為6位數(shù)字")
private String zipCode;
}最佳實踐
1. 結(jié)合Spring Validation框架進行深度驗證
2. 為常用驗證規(guī)則創(chuàng)建自定義注解
3. 提供清晰、具體的錯誤信息
4. 記錄驗證失敗的情況，發(fā)現(xiàn)潛在的問題
5. 對敏感API進行更嚴格的參數(shù)驗證
場景六：國際化處理攔截器
使用場景
國際化處理攔截器主要用于：
- 根據(jù)請求頭或用戶設(shè)置確定語言
- 切換應用的本地化資源
- 提供多語言支持
- 增強用戶體驗
實現(xiàn)代碼
@Component
public class LocaleChangeInterceptor implements HandlerInterceptor {
@Autowired
private MessageSource messageSource;
private final List<Locale> supportedLocales = Arrays.asList(
Locale.ENGLISH, // en
Locale.SIMPLIFIED_CHINESE, // zh_CN
Locale.TRADITIONAL_CHINESE, // zh_TW
Locale.JAPANESE, // ja
Locale.KOREAN // ko
);
// 默認語言
private final Locale defaultLocale = Locale.ENGLISH;
// 語言參數(shù)名
private String paramName = "lang";
// 用于檢測語言的HTTP頭
private List<String> localeHeaders = Arrays.asList(
"Accept-Language",
"X-Locale"
);
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 嘗試從請求參數(shù)中獲取語言設(shè)置
String localeParam = request.getParameter(paramName);
Locale locale = null;
if (localeParam != null && !localeParam.isEmpty()) {
locale = parseLocale(localeParam);
}
// 如果請求參數(shù)中沒有有效的語言設(shè)置，嘗試從HTTP頭中獲取
if (locale == null) {
for (String header : localeHeaders) {
String localeHeader = request.getHeader(header);
if (localeHeader != null && !localeHeader.isEmpty()) {
locale = parseLocaleFromHeader(localeHeader);
if (locale != null) {
break;
}
}
}
}
// 如果無法確定語言，使用默認語言
if (locale == null) {
locale = defaultLocale;
}
// 將解析出的語言設(shè)置到LocaleContextHolder中
LocaleContextHolder.setLocale(locale);
// 將語言信息放入請求屬性中，便于在視圖中使用
request.setAttribute("currentLocale", locale);
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
// 請求結(jié)束后清除語言設(shè)置
LocaleContextHolder.resetLocaleContext();
}
/**
* 解析語言參數(shù)
*/
private Locale parseLocale(String localeParam) {
Locale requestedLocale = Locale.forLanguageTag(localeParam.replace('_', '-'));
// 檢查請求的語言是否在支持的語言列表中
for (Locale supportedLocale : supportedLocales) {
if (supportedLocale.getLanguage().equals(requestedLocale.getLanguage())) {
// 如果語言匹配，但國家可能不同，使用完整的支持語言
return supportedLocale;
}
}
return null;
}
/**
* 從Accept-Language頭解析語言
*/
private Locale parseLocaleFromHeader(String headerValue) {
// 解析Accept-Language頭，格式如: "en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7"
String[] parts = headerValue.split(",");
for (String part : parts) {
String[] subParts = part.split(";");
String localeValue = subParts[0].trim();
Locale locale = Locale.forLanguageTag(localeValue.replace('_', '-'));
// 檢查是否是支持的語言
for (Locale supportedLocale : supportedLocales) {
if (supportedLocale.getLanguage().equals(locale.getLanguage())) {
return supportedLocale;
}
}
}
return null;
}
}國際化配置
@Configuration
public class LocaleConfig {
@Bean
public LocaleResolver localeResolver() {
SessionLocaleResolver resolver = new SessionLocaleResolver();
resolver.setDefaultLocale(Locale.ENGLISH);
return resolver;
}
@Bean
public MessageSource messageSource() {
ReloadableResourceBundleMessageSource messageSource =
new ReloadableResourceBundleMessageSource();
messageSource.setBasename("classpath:i18n/messages");
messageSource.setDefaultEncoding("UTF-8");
messageSource.setCacheSeconds(3600); // 刷新緩存的周期（秒）
return messageSource;
}
}國際化工具類
@Component
public class I18nUtil {
@Autowired
private MessageSource messageSource;
/**
* 獲取國際化消息
*
* @param code 消息代碼
* @return 本地化后的消息
*/
public String getMessage(String code) {
return getMessage(code, null);
}
/**
* 獲取國際化消息
*
* @param code 消息代碼
* @param args 消息參數(shù)
* @return 本地化后的消息
*/
public String getMessage(String code, Object[] args) {
Locale locale = LocaleContextHolder.getLocale();
try {
return messageSource.getMessage(code, args, locale);
} catch (NoSuchMessageException e) {
return code;
}
}
}資源文件示例
# src/main/resources/i18n/messages_en.properties
greeting=Hello, {0}!
login.success=Login successful
login.failure=Login failed: {0}
validation.username.notEmpty=Username cannot be empty
validation.password.weak=Password is too weak, must be at least 8 characters
# src/main/resources/i18n/messages_zh_CN.properties
greeting=你好，{0}！
login.success=登錄成功
login.failure=登錄失?。簕0}
validation.username.notEmpty=用戶名不能為空
validation.password.weak=密碼強度不夠，至少需要8個字符在控制器中使用
@RestController
@RequestMapping("/api/auth")
public class AuthController {
@Autowired
private AuthService authService;
@Autowired
private I18nUtil i18nUtil;
@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody LoginRequest request) {
try {
String token = authService.login(request.getUsername(), request.getPassword());
Map<String, Object> response = new HashMap<>();
response.put("token", token);
response.put("message", i18nUtil.getMessage("login.success"));
return ResponseEntity.ok(response);
} catch (AuthenticationException e) {
Map<String, Object> response = new HashMap<>();
response.put("error", i18nUtil.getMessage("login.failure", new Object[]{e.getMessage()}));
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(response);
}
}
@GetMapping("/greeting")
public Map<String, String> greeting(@RequestParam String name) {
Map<String, String> response = new HashMap<>();
response.put("message", i18nUtil.getMessage("greeting", new Object[]{name}));
return response;
}
}在前端獲取當前語言
@RestController
@RequestMapping("/api/locale")
public class LocaleController {
@GetMapping("/current")
public Map<String, Object> getCurrentLocale(HttpServletRequest request) {
Locale currentLocale = (Locale) request.getAttribute("currentLocale");
if (currentLocale == null) {
currentLocale = LocaleContextHolder.getLocale();
}
Map<String, Object> response = new HashMap<>();
response.put("locale", currentLocale.toString());
response.put("language", currentLocale.getLanguage());
response.put("country", currentLocale.getCountry());
return response;
}
@GetMapping("/supported")
public List<Map<String, String>> getSupportedLocales() {
List<Map<String, String>> locales = new ArrayList<>();
locales.add(createLocaleMap(Locale.ENGLISH, "English"));
locales.add(createLocaleMap(Locale.SIMPLIFIED_CHINESE, "簡體中文"));
locales.add(createLocaleMap(Locale.TRADITIONAL_CHINESE, "繁體中文"));
locales.add(createLocaleMap(Locale.JAPANESE, "日本語"));
locales.add(createLocaleMap(Locale.KOREAN, "???"));
return locales;
}
private Map<String, String> createLocaleMap(Locale locale, String displayName) {
Map<String, String> map = new HashMap<>();
map.put("code", locale.toString());
map.put("language", locale.getLanguage());
map.put("displayName", displayName);
return map;
}
}最佳實踐
1. 使用標準的國際化資源文件組織方式
2. 緩存消息資源，避免頻繁加載資源文件
3. 為所有用戶可見的字符串提供國際化支持
4. 允許用戶在界面中切換語言
5. 在會話中保存用戶語言偏好
6. 使用參數(shù)化消息，避免字符串拼接
攔截器的最佳實踐
1. 攔截器注冊順序
攔截器的執(zhí)行順序非常重要，通常應該遵循：
- 認證/授權(quán)攔截器優(yōu)先執(zhí)行
- 日志攔截器盡量靠前，記錄完整信息
- 性能監(jiān)控攔截器包裹整個請求處理過程
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
@Autowired
private AuthenticationInterceptor authInterceptor;
@Autowired
private LoggingInterceptor loggingInterceptor;
@Autowired
private PerformanceMonitorInterceptor performanceInterceptor;
@Autowired
private RateLimitInterceptor rateLimitInterceptor;
@Autowired
private RequestValidationInterceptor validationInterceptor;
@Autowired
private LocaleChangeInterceptor localeInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 1. 國際化攔截器
registry.addInterceptor(localeInterceptor)
.addPathPatterns("/**");
// 2. 日志攔截器
registry.addInterceptor(loggingInterceptor)
.addPathPatterns("/**");
// 3. 性能監(jiān)控攔截器
registry.addInterceptor(performanceInterceptor)
.addPathPatterns("/api/**");
// 4. 限流攔截器
registry.addInterceptor(rateLimitInterceptor)
.addPathPatterns("/api/**");
// 5. 參數(shù)驗證攔截器
registry.addInterceptor(validationInterceptor)
.addPathPatterns("/api/**");
// 6. 認證攔截器
registry.addInterceptor(authInterceptor)
.addPathPatterns("/api/**")
.excludePathPatterns("/api/auth/login", "/api/auth/register");
}
}2. 避免攔截器中的重量級操作
將復雜邏輯抽取到專門的服務(wù)類中
使用異步方式處理日志記錄等非關(guān)鍵路徑操作
緩存頻繁使用的數(shù)據(jù)
避免在攔截器中進行數(shù)據(jù)庫操作
3. 異常處理
攔截器中的異常可能導致整個請求處理鏈中斷
總是使用try-catch捕獲并正確處理異常
關(guān)鍵攔截器（如認證）中的異常應返回適當?shù)腍TTP狀態(tài)碼和錯誤信息
4. 路徑模式配置
精確指定需要攔截的路徑，避免不必要的性能開銷
合理使用excludePathPatterns排除不需要攔截的路徑
對靜態(tài)資源路徑通常應該排除
5. 攔截器的組合使用
設(shè)計獨立、職責單一的攔截器
通過組合使用實現(xiàn)復雜功能
避免在一個攔截器中實現(xiàn)多種不相關(guān)的功能
總結(jié)
通過合理使用這些攔截器，可以極大地提高代碼復用性，減少重復代碼，使應用架構(gòu)更加清晰和模塊化。
在實際應用中，可以根據(jù)具體需求選擇或組合使用這些攔截器，甚至擴展出更多類型的攔截器來滿足特定業(yè)務(wù)場景。
以上就是6種常見的SpringBoot攔截器使用場景及實現(xiàn)方式的詳細內(nèi)容，更多關(guān)于SpringBoot攔截器的資料請關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
本篇文章主要介紹了30分鐘入門Java8之lambda表達式學習，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-04-04
這篇文章主要為大家介紹了線程阻塞喚醒工具LockSupport使用詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-01-01
Spring源碼學習之動態(tài)代理實現(xiàn)流程
這篇文章主要給大家介紹了關(guān)于Spring源碼學習之動態(tài)代理實現(xiàn)流程的相關(guān)資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2021-03-03
函數(shù)式接口是?Java?8?引入的一種接口,用于支持函數(shù)式編程,下面我們就來深入探討函數(shù)式接口的概念、用途以及如何創(chuàng)建和使用函數(shù)式接口吧2023-08-08
java Class文件結(jié)構(gòu)解析常量池字節(jié)碼
這篇文章主要為大家介紹了java Class文件的整體結(jié)構(gòu)解析常量池字節(jié)碼詳細講解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-07-07
這篇文章主要介紹了springboot包裝controller返回值問題，本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下2021-12-12
這篇文章主要介紹了idea安裝插件找不到的問題及解決,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-06-06
詳解Spring Boot 項目啟動時執(zhí)行特定方法
這篇文章主要介紹了詳解Spring Boot 項目啟動時執(zhí)行特定方法，Springboot給我們提供了兩種“開機啟動”某些方法的方式：ApplicationRunner和CommandLineRunner。感興趣的小伙伴們可以參考一下2018-06-06
Java中Comparable與Comparator的區(qū)別解析
這篇文章主要介紹了Java中Comparable與Comparator的區(qū)別解析,實現(xiàn)Comparable接口,重寫compareTo方法,一般在實體類定義的時候就可以選擇實現(xiàn)該接口,提供一個默認的排序方式,供Arrays.sort和Collections.sort使用,需要的朋友可以參考下2024-01-01
springboot集成JWT之雙重token的實現(xiàn)
本文主要介紹了springboot集成JWT之雙重token的實現(xiàn),前端使用accessToken進行登錄和驗證,后端使用refreshToken定期更新accessToken,具有一定的參考價值,感興趣的可以了解一下2025-03-03