Spring Boot中拦截器的编写

于 2025-06-27 00:45:16 发布
阅读量840 收藏 13
点赞数 10
CC 4.0 BY-SA版权
分类专栏： Spring相关技术 文章标签： spring boot 后端 拦截器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java_t_t/article/details/148936710

步骤

  1. 实现HandlerInterceptor接口；或继承HandlerInterceptorAdapter类；

  2. 实现WebMvcConfigurer接口，在addInterceptors方法中注册拦截器

说明

  1. HandlerInterceptorAdapter类实现了AsyncHandlerInterceptor接口，该接口继承自HandlerInterceptor接口，比HandlerInterceptor多了一个afterConcurrentHandlingStarted方法

  2. 方法执行顺序：

    1. preHandle在执行controller方法前执行，当preHandle返回为true时，继续往下执行，否则返回

    2. postHandle在执行controller方法后，返回结果前执行；具体是在渲染视图前，参数有一个ModelAndVie 对象，可以对试图进行处理

    3. afterCompletion在整个请求流程处理完成后执行，可以用于记录接口耗时等

    4. 如果controller方法的返回值是java.util.concurrent.Callable类型，执行顺序是：preHandle -> controller方法 -> afterConcurrentHandlingStarted, 用一个新的线程执行 preHandle -> postHandle -> afterCompletion

  3. 如果有多个拦截器，执行顺序由注册顺序决定（除了preHandle方法，其它方法正好跟注册顺序相反）
    如：有拦截器A和B，注册顺序为A -> B
    拦截器方法的执行顺序为：
    A.preHandle -> B.preHandle -> controller方法 -> B.postHandle -> A.postHandle -> B.afterCompletion -> A.afterCompletion
    或（继承了HandlerInterceptorAdapter类，且返回值为java.util.concurrent.Callable类型）：
    A.preHandle -> B.preHandle -> controller方法 -> B.afterConcurrentHandlingStarted -> A.afterConcurrentHandlingStarted --启用另一个线程–> A.preHandle -> B.preHandle -> B.postHandle -> A.postHandle -> B.afterCompletion -> A.afterCompletion

另，如果需要在preHandle中打印请求参数，当需要从post的输入流中获取请求体时，由于输入流只能获取一次，会导致controller获取请求体时抛出异常（Required request body is missing），解决办法是继承HttpServletRequestWrapper类，重写getInputStream和getReader方法，并用Filter过滤器在Interceptor拦截器之前，将默认的ServletRequest对象替换为自定义的ServletRequest对象（HttpServletRequestWrapper实现了HttpServletRequest接口，该接口继承自ServletRequest接口）

代码

编写拦截器：

import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.Nullable;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Locale;

@Slf4j
@Configuration
public class GlobalInterceptor implements HandlerInterceptor {
    private static final String[] SIZE_UNIT = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", "BB"};
    private static final ThreadLocal<Long> threadLocal = new ThreadLocal<>();

    @Autowired
    private PropertiesConfig propertiesConfig;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        threadLocal.set(System.currentTimeMillis());
        String body = getRequestBody(request);
        log.info("\n↓↓↓preHandle start↓↓↓\n接口请求信息\n请求方法:{}\nURI:{}\nQueryString:{}\nbody:\n{}\n↑↑↑preHandle end↑↑↑",
                request.getMethod(), request.getRequestURI(), request.getQueryString(), body);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        // 执行controller方法后，返回结果前执行
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        log.info("\n↓↓↓afterCompletion start↓↓↓\n接口耗时情况\n请求方法:{}\nURI:{}\n用时:{}ms\n↑↑↑afterCompletion end↑↑↑",
                request.getMethod(), request.getRequestURI(), System.currentTimeMillis() - threadLocal.get());
        // 此处必须手动remove，否则会导致内存泄漏
        threadLocal.remove();
    }

    /**
     * 将输入流转换为字符串
     *
     * @param request 请求
     * @return 输入流转换后的字符串
     * @throws IOException 读取输入流异常
     */
    private String getRequestBody(HttpServletRequest request) throws IOException {
        String contentType = request.getContentType();
        if (contentType == null || !PropertiesConfig.TEXT_CONTENT_TYPES.contains(contentType.toLowerCase(Locale.ROOT))) {
            return "content-type为：" + contentType + ", 不在配置的文本请求体类型中, 不打印请求体";
        }
        if (request.getContentLengthLong() > propertiesConfig.getLogMaxBody()) {
            return "请求体大小为：" + expressSize(request.getContentLengthLong()) + ", 超出日志打印的body大小限制，不打印请求体";
        }
        ServletInputStream inputStream = request.getInputStream();
        byte[] bytes = new byte[1024];
        StringBuilder sb = new StringBuilder();
        int length = inputStream.read(bytes);
        while (length > 0) {
            sb.append(new String(bytes, 0, length, Charset.defaultCharset()));
            length = inputStream.read(bytes);
        }
        return sb.toString();
    }

    /**
     * 将字节大小转换为合适的表示单位
     * long能表达的最大字节大小为7EB
     *
     * @param size 字节大小
     * @return 转换后的字节大小
     */
    private static String expressSize(long size) {
        if (size <= 0) {
            return "0B";
        }
        int index = 0;
        while (size >= 1024) {
            size >>= 10;
            index++;
        }
        if (index >= SIZE_UNIT.length) {
            return "too big size...";
        }
        return size + SIZE_UNIT[index];
    }
}

注册拦截器：

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 GlobalWebMvcConfigure implements WebMvcConfigurer {
    @Autowired
    private GlobalInterceptor globalInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(globalInterceptor)
                // 添加拦截路径
                .addPathPatterns("/**")
                // .addPathPatterns("/test/add1")
                // .addPathPatterns("/test/add2")
                // 添加不拦截的路径
                .excludePathPatterns("/test/exclude1")
                .excludePathPatterns("/test/exclude2");
    }
}

继承HttpServletRequestWrapper并重写相关方法：

import jakarta.servlet.ReadListener;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import org.springframework.util.StreamUtils;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class RepeatReadInputStreamHttpServletRequest extends HttpServletRequestWrapper {
    private byte[] bytes;

    public RepeatReadInputStreamHttpServletRequest(HttpServletRequest request) throws IOException {
        super(request);
        bytes = StreamUtils.copyToByteArray(request.getInputStream());
    }

    @Override
    public BufferedReader getReader() {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    @Override
    public ServletInputStream getInputStream() {
        final ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
        return new ServletInputStream() {
            @Override
            public int read() {
                return inputStream.read();
            }

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {
            }
        };
    }
}

实现Filter接口，并注册拦截器：

import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.FilterConfig;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.support.WebApplicationContextUtils;

import java.io.IOException;
import java.util.Locale;

@Configuration
public class RequestFilter implements Filter {
    private PropertiesConfig propertiesConfig;

    /**
     * 过滤器中无法使用@Autowired进行自动注入（Filter归tomcat管理，bean归spring管理）
     *
     * @param filterConfig FilterConfig对象
     */
    @Override
    public void init(FilterConfig filterConfig) {
        ServletContext context = filterConfig.getServletContext();
        ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(context);
        propertiesConfig = ctx.getBean(PropertiesConfig.class);
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        ServletRequest requestWrapper = null;
        if (servletRequest instanceof HttpServletRequest) {
            String contentType = servletRequest.getContentType();
            if (contentType != null && PropertiesConfig.TEXT_CONTENT_TYPES.contains(contentType.toLowerCase(Locale.ROOT))) {
                requestWrapper = new RepeatReadInputStreamHttpServletRequest((HttpServletRequest) servletRequest);
            }
        }
        if (requestWrapper == null) {
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            filterChain.doFilter(requestWrapper, servletResponse);
        }
    }

    @Bean
    public FilterRegistrationBean doFilterRegistration() {
        FilterRegistrationBean<RequestFilter> registration = new FilterRegistrationBean<RequestFilter>();
        registration.setFilter(new RequestFilter());
        registration.addUrlPatterns("/*");
        return registration;
    }
}

配置类：

import lombok.Getter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

import java.util.Set;

@Getter
@Configuration
public class PropertiesConfig {
    /**
     * 常见的文本格式类型的body
     */
    public static final Set<String> TEXT_CONTENT_TYPES = Set.of("text/plain", "text/html", "text/xml",
            "application/xhtml+xml", "application/xml", "application/atom+xml", "application/json", "application/x-www-form-urlencoded");

    /**
     * 设置日志打印的body大小限制（默认64k）
     */
    @Value("${log.max-body:65536}")
    private long logMaxBody;
}

参考文章：

  1. Spring Boot 拦截器、过滤器、监听器

  2. springboot请求体中的流只能读取一次的问题

SpringBoot教程(六) | SpringBoot开发拦截器
weixin_42907150的博客
01-15 916
首先实现HandlerInterceptor 接口SpringMVC中给我提供了一个接口叫做 HandlerInterceptor, 我们实现了这个接口之后，需要实现里面的几个方法。这几个方法就是用来定义我们拦截器的业务逻辑实现。java复制代码package org.springframework.web.servlet;java复制代码 package org . springframework . web . servlet;} }
spring boot3token拦截器链的设计与实现
蒾酒的博客
03-07 5916
本文介绍了spring boot后端服务开发中有关如何设计拦截器的思路，坚持看完相信对你有帮助。同时欢迎订阅springboot系列专栏，持续分享spring boot的使用经验。首先，需要定义第一个拦截器类，该拦截器类需要实现 Spring 框架提供的接口。该拦截器只做一件事就是刷新token。/***/@Slf4j@Component@Override// 1、从请求头中获取token// 2.解析token// 3.获取用户信息。
SpringBoot拦截器的编写
一朝风月
07-01 976
本文将讲述SpringBoot拦截器的编写，通过举一个Token第三方认证的例子让读者了解在SpringBoot中拦截器该如何编写，在讲解拦截器之前，可能有读者会对过滤器和拦截器的区别产生疑问，首先我先介绍一下过滤器和拦截器有哪些区别，具体写代码的时候根据具体场景选择使用。
springboot拦截器
qq_35643146的博客
05-29 2057
​ 拦截器（Interceptor）是一种特殊的组件，它可以在请求处理的过程中对请求和响应进行拦截和处理。拦截器可以在请求到达目标处理器之前、处理器处理请求之后以及视图渲染之前执行特定的操作。拦截器的主要目的是在不修改原有代码的情况下，实现对请求和响应的统一处理。返回值类型方法声明描述boolean该方法在控制器处理请求方法前执行，其返回值表示是否中断后续操作，返回 true 表示继续向下执行，返回 false 表示中断后续操作。void。
Spring boot 拦截器的编写
m0_46043168的博客
10-16 1270
编写拦截器需要在Controller层，编写两个类。 一个类类名：Interceptor1（类名没有特定要求） 另一个类名：InterceptorConfig （类名没有特定要求） InterceptorConfig类实现WebMvcConfigurer 接口 其主要作用是编写拦截规则，这里我只重写了addInterceptors方法（主类上方需要添加注解@Configuration） 2 代码解释：addPathPatterns（“/**”）这个方法表示拦截所有路径。 ...
Spring Boot编写拦截器教程实例解析
08-19
在Spring Boot中编写拦截器是一种常见的需求，拦截器可以在请求到达控制器（Controller）之前或之后进行拦截处理，用于执行一些通用的操作，例如验证、日志记录、权限检查等。 拦截器的实现主要涉及以下几个关键点...
spring boot 登录拦截器
07-12
在Spring Boot应用中，登录拦截器是一个至关重要的组件，它用于保护特定的Web资源，确保只有经过身份验证的用户才能访问。Spring Boot结合了Spring MVC框架，提供了方便的方式来实现这样的拦截器。本篇文章将深入...
spring boot配置拦截器代码实例
08-25
在 Spring Boot 应用程序中，可以通过在 `application.properties` 文件中添加以下配置来启用拦截器： ```properties spring: web: interceptors: - ApiAccessInterceptor ``` 此处，我们将 `...
java + spring boot +jpa 拦截器分库分表demo
03-30
在Spring Boot中注册拦截器，我们需要在配置类中使用`@EnableAspectJAutoProxy`开启AOP代理，并通过`@Bean`注解声明拦截器实例。然后，使用`@Around`注解定义切点，即拦截所有的JPA操作。 在实际开发中，为了使分库...
springboot编写拦截器
qq_39746820的博客
05-03 921
拦截器执行顺序 preHandler 预先处理方法: 最先执行方法 返回值布尔类型 true 放行请求,false中断,放行后执行controller内容。 postHandler 过程中处理: controller返回之后回到postHandler这个方法执行,执行完成这个方法开始响应浏览器 。 afterCompletion 最后完成: 当响应结束之后会执行拦截器中这个方法内容。
SpringBoot教程（六） | SpringBoot开发拦截器
最新发布
qq_20236937的博客
07-06 535
拦截器： 是在请求进入到Controller 的一层AOP处理，相当于在Controller之前、之中和之后可以定义一些我们自己的业务逻辑。首先实现HandlerInterceptor 接口SpringMVC中给我提供了一个接口叫做 HandlerInterceptor, 我们实现了这个接口之后，需要实现里面的几个方法。这几个方法就是用来定义我们拦截器的业务逻辑实现。
基于springboot写的拦截器
Richard_666的博客
12-11 339
第一步：书写一个类 package com.lpy.controller.interceptor; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.springframework.web.servlet.HandlerInterce...
SpringBoot 之拦截器
cpongo55
01-28 407
一：登录1、编写html thymeleaf请求地址2、禁用thymeleaf 模版缓存3、页面提示信息的判断3.1调转数据4、防止首页重复提交数据，使用重定向的方式进行处理并进行映射模版 二：拦截器1、注册连接器...
SpringBoot之拦截器
浩泽学编程的博客
09-26 327
SpringBoot拦截器讲解（原理、源码讲解）
springboot+自定义注解+拦截器的写法
_若初心的博客
03-05 1916
1、定义自定义注解的名称/** * 在需要验证openid的Controller的方法上使用此注解 */ @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface AccessRequired { }2、写自定义的拦截器，需继承HandlerInterceptor拦截器public c...
SpringBoot拦截器
热门推荐
weixin_52120555的博客
03-07 1万+
1.什么是拦截器？ 拦截器可以根据 URL 对请求进行拦截，主要应用于登陆校验、权限验证、乱码解决、性能监控和异常处理等功能。 2.定义拦截器步骤 在 Spring Boot 项目中，使用拦截器功能通常需要以下 3 步： 1.定义拦截器； 2.注册拦截器； 3.指定拦截规则（如果是拦截所有，静态资源也会被拦截）。 一、定义拦截器 在 Spring Boot 中定义拦截器十分的简单，只需要创建一个拦截器类，并实现 HandlerInterceptor 接口，重写以下三个方法。 @Slf4j @Componen
Spring Boot 拦截器
2303_78892316的博客
04-14 1281
自定义拦截器：实现HandlerInterceptor接口@Slf4j@Component@Override//true代表通过，false代表拦截//log.info("目标方法执行前执行");@Override//log.info("目标方法执行后执行");
springboot 拦截器
我不会写代码呀的博客
04-27 620
在web开发的过程中，为了实现登录权限验证，我们往往需要添加一个拦截器在用户的的请求到达controller层的时候实现登录验证，那么SpringBoot如何添加拦截器呢？步骤如下：1.继承WebMvcConfigureAdapter类，覆盖其addInterceptors接口,注册我们自定义的拦截器：/** * 注册拦截器 */ @Configuration //@EnableAutoCon...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值