Springboot项目修改请求参数

这篇博客探讨了如何处理前端传递给后端的不包含时分秒的日期参数问题。作者提出了两种解决方案:1) 使用AOP切面,在Controller方法执行前修改参数,将结束日期设置为当天23:59:59;2) 实现自定义过滤器,通过HttpServletRequestWrapper修改请求参数,将searchEndDate添加23:59:59。这两种方法旨在确保正确地传递完整的时间范围给后台处理。

需求:前端传过来两个参数searchStartDate和searchEndDate,但是传的是带日期格式的,不带时分秒的,这就导致传到后台的时间都是00:00:0,searchStartDate倒无所谓,searchEndDate需加上23:59:59。

思路:1.用切面的方式,在切面对controller进行拦截

 

@Component
@Aspect
@Log4j2
public class SearchFormateAspect {

    @Pointcut("execution(public * cn.com.test.controller.*.*(..))")
    public void getMethods() {
    }

    @Before("getMethods()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {

        //获取目标方法的参数信息
        Object[] obj = joinPoint.getArgs();

        for (Object argItem : obj) {
            if (argItem instanceof BaseEntity) {
                BaseEntity baseEntity = (BaseEntity) argItem;
                // 前端传入年月日,searchEndDate拼接23:59:59
                Date searchEndDate = baseEntity.getSearchEndDate();
                if (searchEndDate != null) {
                    searchEndDate = DateUtils.setHours(searchEndDate,23);
                    searchEndDate = DateUtils.setMinutes(searchEndDate,59);
                    searchEndDate = DateUtils.setSeconds(searchEndDate,59);
                    baseEntity.setSearchEndDate(searchEndDate);
                }
            }
        }
    }
}

2.过滤器,自定义一个过滤器,自定义wrapper实现HttpServletRequestWrapper

@Component
@Slf4j
public class SearchDateFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws IOException, ServletException {

        // 获取你需要的参数
        String searchStartDate = request.getParameter("searchStartDate");
        String searchEndDate = request.getParameter("searchEndDate");
        if (StringUtils.isBlank(searchStartDate) && StringUtils.isBlank(searchEndDate)) {
            chain.doFilter(request, response);
        } else {
            RequestParameterWrapper wrapper = new RequestParameterWrapper(request);
            chain.doFilter(wrapper, response);
        }
    }

}
public class RequestParameterWrapper extends HttpServletRequestWrapper {
    private Map<String, String[]> params = new HashMap<>();

    public RequestParameterWrapper(HttpServletRequest request) {
        super(request);
        this.params.putAll(this.getParameterMap());
    }

    /**
     * 重写getParameter,代表参数从当前类中的map获取
     *
     * @param name
     * @return
     */
    @Override
    public String getParameter(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        HashMap<String, String[]> newMap = new HashMap<>();
        newMap.putAll(super.getParameterMap());
        String[] searchEndDate = newMap.get("searchEndDate");
        if(searchEndDate != null && !StringUtils.isBlank(searchEndDate[0])){
            newMap.put("searchEndDate", new String[]{searchEndDate[0] + " 23:59:59"});
        }
        return Collections.unmodifiableMap(newMap);
    }

    /**
     * 同上
     *
     * @param name
     * @return
     */
    @Override
    public String[] getParameterValues(String name) {
        return params.get(name);
    }
}

<think>嗯,用户问的是如何在Spring Boot中打印请求参数和返回结果。首先,我得回想一下自己以前处理类似需求的经验。记得Spring Boot有拦截器或者过滤器可以用,或者用AOP面向切面编程。不过具体怎么操作呢? 首先,打印请求参数。可能需要获取HTTP请求中的参数,比如GET请求的查询参数,或者POST请求的body体内容。对于GET请求,可以通过HttpServletRequest的getParameterMap来获取参数。对于POST请求,如果是表单提交,也可以用同样的方法,但如果是JSON格式,可能需要读取输入流来获取body内容。不过要注意,输入流一旦读取了,后续处理可能会出问题,所以可能需要用ContentCachingRequestWrapper来缓存请求内容。 然后是关于返回结果。返回结果可能在处理完控制器方法之后,所以可以在拦截器的afterCompletion方法里处理,或者使用ResponseBodyAdvice接口来拦截响应体。或者用AOP的环绕通知,在方法执行前后记录请求和响应。 另外,用户可能需要简单的配置,所以是否有一些现成的库或者注解可以用?比如Spring自带的日志功能,或者使用actuator端点?不过可能用户想要的是自定义的日志输出,所以还是自己实现比较靠谱。 接下来,步骤大概是这样的:创建一个拦截器,在preHandle方法里记录请求的信息,包括URL、方法类型、参数等。对于POST的body,需要用缓存请求包装类,否则输入流只能读一次。然后在afterCompletion方法里记录响应的数据,这时候响应已经发送给客户端了,可以通过ContentCachingResponseWrapper来获取响应内容。 另外,ResponseBodyAdvice可以用来处理返回的对象,这样可以在写入响应之前记录日志。或者使用@ControllerAdvice配合@ResponseBody来修改响应,不过记录日志的话可能用这个不太合适。 对了,还有过滤器(Filter)的方式,比如使用OncePerRequestFilter,在过滤器中包装请求和响应,然后记录日志。不过过滤器是在拦截器之前执行的,可能更底层一些。 具体实现的话,可能需要考虑以下几点: 1. 创建拦截器类实现HandlerInterceptor,重写preHandle和afterCompletion方法。 2. 在preHandle中记录请求参数,处理GET和POST的不同情况。 3. 使用ContentCachingRequestWrapper和ContentCachingResponseWrapper来缓存请求和响应的内容,以便多次读取。 4. 在afterCompletion中获取响应状态码和响应内容。 5. 配置拦截器,将其注册到Spring Boot的拦截器链中。 另外,处理请求体的时候需要注意字符编码问题,否则读取的内容可能会乱码。同时,文件上传之类的请求可能需要特殊处理,避免将文件内容全部记录到日志中,影响性能。 还有,响应内容如果是JSON格式,可能需要将其转换为字符串记录。使用Jackson的ObjectMapper可以做到这一点,或者直接读取缓存的响应内容字节数组,转换成字符串。 测试的时候,可能需要发送不同的请求类型(GET、POST)来验证日志是否正确输出。同时,确保拦截器不会对性能造成太大影响,特别是在高并发的情况下,日志记录应该尽量高效。 可能用户还希望排除某些特定的路径,比如健康检查的端点,或者静态资源,这时候在注册拦截器时可以配置排除的路径模式。 总结下来,实现方法大致有两种:拦截器配合包装类,或者使用AOP。拦截器的方法可能更直接,而AOP可以更灵活地针对特定的控制器方法进行处理。不过用户可能更倾向于使用拦截器的方式,因为能统一处理所有请求。 最后,代码示例应该包括拦截器的实现、包装类的使用、以及如何注册拦截器。同时提醒用户注意性能和大请求体的处理,避免内存溢出。</think>在 Spring Boot 中打印请求参数和返回结果,可以通过以下两种常用方式实现: --- ### **方法一:使用拦截器(Interceptor)** 通过实现 `HandlerInterceptor` 接口,结合请求/响应包装类,记录请求和响应信息。 #### 1. 创建拦截器类 ```java import org.springframework.stereotype.Component; import org.springframework.web.servlet.HandlerInterceptor; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @Component public class LogInterceptor implements HandlerInterceptor { // 请求处理前记录参数 @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) { // 包装请求以缓存请求体(用于后续读取) if (request instanceof ContentCachingRequestWrapper) { ContentCachingRequestWrapper requestWrapper = (ContentCachingRequestWrapper) request; logRequest(requestWrapper); } return true; } // 请求完成后记录响应 @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) { ContentCachingResponseWrapper responseWrapper = (ContentCachingResponseWrapper) response; logResponse(responseWrapper); } private void logRequest(ContentCachingRequestWrapper request) { String requestBody = new String(request.getContentAsByteArray(), StandardCharsets.UTF_8); System.out.println("请求参数: " + requestBody); } private void logResponse(ContentCachingResponseWrapper response) { String responseBody = new String(response.getContentAsByteArray(), StandardCharsets.UTF_8); System.out.println("返回结果: " + responseBody); } } ``` #### 2. 配置拦截器注册 ```java 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 { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new LogInterceptor()) .addPathPatterns("/**") .excludePathPatterns("/static/**"); // 排除静态资源 } } ``` #### 3. 配置请求/响应包装过滤器 确保请求和响应被包装,以便多次读取内容: ```java import javax.servlet.*; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.springframework.stereotype.Component; import org.springframework.web.util.ContentCachingRequestWrapper; import org.springframework.web.util.ContentCachingResponseWrapper; @Component public class ContentCachingFilter implements Filter { @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) { HttpServletRequest req = new ContentCachingRequestWrapper((HttpServletRequest) request); HttpServletResponse res = new ContentCachingResponseWrapper((HttpServletResponse) response); chain.doFilter(req, res); // 确保响应内容写入客户端 res.copyBodyToResponse(); } } ``` --- ### **方法二:使用 AOP 面向切面** 通过 AOP 拦截 Controller 方法,记录入参和返回值。 #### 1. 添加 AOP 依赖 ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ``` #### 2. 定义切面类 ```java import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.springframework.stereotype.Component; @Aspect @Component public class LogAspect { @Around("execution(* com.example.demo.controller.*.*(..))") // 拦截指定包下的Controller public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable { // 打印请求参数 Object[] args = joinPoint.getArgs(); System.out.println("请求参数: " + Arrays.toString(args)); // 执行方法并获取返回值 Object result = joinPoint.proceed(); // 打印返回结果 System.out.println("返回结果: " + result); return result; } } ``` --- ### **注意事项** 1. **性能影响**:频繁记录大请求体或响应体可能影响性能,建议生产环境按需使用。 2. **敏感信息**:避免打印敏感数据(如密码、Token)。 3. **文件上传**:不适用于文件上传请求(避免内存溢出)。 --- 两种方法各有优劣: - **拦截器**:适合全局统一处理,但需处理请求/响应包装。 - **AOP**:更灵活,可针对特定 Controller 或方法,但需依赖 AOP 配置。 根据实际场景选择合适方案即可。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值