如何在Java项目中集成拦截器，并对请求与响应参数进行存储

Mr.huang

已于 2024-04-19 18:50:00 修改

阅读量382

点赞数 6

分类专栏： JAVA 文章标签： java 开发语言

于 2024-04-16 17:29:30 首次发布

本文链接：https://blog.csdn.net/m0_73843666/article/details/137833253

版权

JAVA 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

目的

日常开发中，因为某些原因（架构日志不支持长期存储/审计需要等等）我们往往想对自己的模块中的接口进行一个个性化的记录。当然我们会想到用原生AOP+注解的形式去实现，但是Spring提供的拦截器也同样的好用，所以这里用拦截器实现了一个简单的日志记录。在做这个需求前，网上我也查了很多资料，要不含糊其辞，要不杂七杂八，最后就是跑不通。

实现

日志实体类

首先，存储嘛，你需要有对应的表结构，这里提供一个实体类，表结构大家自己想象

@Data
@Table(name = "t_report_log_record")
public class ReportLogRecordDO {

    @Id
    @ApiModelProperty("主键id")
    private Long id;

    
    @ApiModelProperty("创建时间")
    @JsonFormat(
        pattern = "yyyy-MM-dd HH:mm:ss"
    )
    private LocalDateTime createAt;

    @ApiModelProperty("更新时间")
    @JsonFormat(
        pattern = "yyyy-MM-dd HH:mm:ss"
    )
    
    private LocalDateTime updateAt;
    @ApiModelProperty("创建人")
    
    private String createBy;
    @ApiModelProperty("修改人")
    
    private String updateBy;
    /**
     * 请求接口唯一session标识
     */
    @Column(name = "request_id")
    private String requestId;

    /**
     * 客户端请求ip
     */
    @Column(name = "client_ip")
    private String clientIp;

    /**
     * 客户端请求路径
     */
    @Column(name = "url")
    private String url;

    /**
     * 请求方式 post，get等
     */
    @Column(name = "method")
    private String method;

    /**
     * 请求参数内容，json格式
     */
    @Column(name = "request_param")
    private String requestParam;

    /**
     * 响应内容，json格式
     */
    @Column(name = "response_param")
    private String responseParam;

    /**
     * 响应状态
     */
    @Column(name = "http_status_code")
    private Integer httpStatusCode;

    /**
     * 请求人
     */
    @Column(name = "requester")
    private String requester;

    /**
     * 服务名称
     */
    @Column(name = "service_name")
    private String serviceName;

    /**
     * appid
     */
    @Column(name = "mn_appid")
    private String mnAppid;


    /**
     * api_type
     */
    @Column(name = "api_type")
    private Integer apiType;

    /**
     * 请求耗费时间 毫秒值
     */
    @Column(name = "spend_time")
    private Long  spendTime;

    /**
     * 是否删除 1 删除  0 未删除
     */
    @Column(name = "logic_delete")
    private Integer logicDelete;
}

配置拦截器

这里同样也实现了ApplicationContextAware接口，因为拦截器中无法注入对象，所以咱曲线救国一下

/**
 * @author huang
 * @description 日志拦截器，对所有controller层的POST请求进行拦截，记录请求和响应数据
 * @date 2024/3/19 14:33
 */
@Component
@Slf4j
@Order(-1)
public class LoggerInterceptor implements HandlerInterceptor, ApplicationContextAware {
/** 下面用到的相关常量
    public static final String LOGGER_ENTITY = "report_logger_entity";
    public static final String START_TIME = "report_start_time";
    */

    private ApplicationContext applicationContext;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String method = request.getMethod();
        if (HttpMethod.POST.name().equals(method)) {
            ReportLogRecordDO recordDO = new ReportLogRecordDO();
            recordDO.setClientIp(this.getClientIp(request));
            recordDO.setMethod(method);
            recordDO.setUrl(request.getRequestURI());
            recordDO.setRequester(JwtUtils.currentUserNameOrSys());
            recordDO.setCreateAt(LocalDateTime.now());
            recordDO.setCreateBy(JwtUtils.userIdOrSys());
            recordDO.setServiceName(Constants.CLIENT_ID);
            String appid = request.getHeader(Constants.MN_APPID);
            if (StringUtils.isNotBlank(appid)) {
                recordDO.setMnAppid(appid);
            }
            request.setAttribute(Constants.LOGGER_ENTITY, recordDO);
            request.setAttribute(Constants.START_TIME, System.currentTimeMillis());

        }
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        String method = request.getMethod();
        if (HttpMethod.POST.name().equals(method)) {
            try {
                ReportLogRecordDO recordDO = (ReportLogRecordDO) request.getAttribute(Constants.LOGGER_ENTITY);
                Long startTime = (Long) request.getAttribute(Constants.START_TIME);
                recordDO.setHttpStatusCode(response.getStatus());
                recordDO.setSpendTime(System.currentTimeMillis() - startTime);
                recordDO.setUpdateBy(JwtUtils.userIdOrSys());
                recordDO.setUpdateAt(LocalDateTime.now());
                recordDO.setLogicDelete(0);
                ReportLogRecordService logRecordService = applicationContext.getBean(ReportLogRecordService.class);
                logRecordService.sendLogMsg(recordDO);//这里就是走存储日志的逻辑了，我这里采用的mq异步存储
            } catch (BeansException e) {
                log.error("**************报告日志响应后处理异常***************！异常信息:",e);
            }
        }
    }


    private String getClientIp(HttpServletRequest request) {
        String ipAddress = request.getHeader("X-Forwarded-For");
        if (ipAddress == null) {
            ipAddress = request.getHeader("Proxy-Client-IP");
        }
        if (ipAddress == null) {
            ipAddress = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ipAddress == null) {
            ipAddress = request.getRemoteAddr();
        }
        if (ipAddress != null && ipAddress.length() > 15) { // "XXX.XXX.XXX.XXX".length() = 15
            if (ipAddress.indexOf(",") > 0) {
                ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
            }
        }
        return ipAddress;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }
}

你以为这样就行了？

当然不行，HttpServletRequest中的请求参数，单单这样搞是拿不到的，就算再这里拿到了，你的api层也就获取不到参数了，因为Servlet中的请求参数是以一种一次性流的方式存在的，当它被读取了一次后就销毁了（大概这个意思吧，描述的可能不太准确，就是只能读取一次）。

所以解决的办法有两种，

一是将HttpServletRequest进行一层包装（wapper），具体怎么做，很多CSDN博主有描述和实践。这种方法我没搞通！！！。

二是我现在用的这种方法，继承RequestBodyAdviceAdapter与ResponseBodyAdvice。

上代码：

@ControllerAdvice
public class RequestBodyAdviceHandle extends RequestBodyAdviceAdapter {

    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter,
                                Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        if (HttpMethod.POST.name().equals(request.getMethod())) {
            ReportLogRecordDO recordDO = (ReportLogRecordDO)request.getAttribute(Constants.LOGGER_ENTITY);
            if (recordDO != null) {
                recordDO.setRequestParam(JSON.toJSONString(body,
                        SerializerFeature.DisableCircularReferenceDetect,
                        SerializerFeature.WriteMapNullValue));
                request.removeAttribute(Constants.LOGGER_ENTITY);
                request.setAttribute(Constants.LOGGER_ENTITY,recordDO);
            }
        }
        return body;
    }

}

@ControllerAdvice
public class ResponseBodyAdviceHandle implements ResponseBodyAdvice<Object> {
    @Override
    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
        return true;
    }
    @Nullable
    @Override
    public Object beforeBodyWrite(@Nullable Object body, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        ServletServerHttpRequest sshr = (ServletServerHttpRequest) serverHttpRequest;
        HttpMethod method = sshr.getMethod();
        if (method != null && HttpMethod.POST.name().equals(method.name())) {
            HttpServletRequest req = sshr.getServletRequest();
            //ApiResponse 是我们的统一响应类，当然你可以换成你们的
            if (body instanceof ApiResponse) {
                ApiResponse result = (ApiResponse) body;
                if (result != null) {
                    ReportLogRecordDO recordDO = (ReportLogRecordDO) req.getAttribute(Constants.LOGGER_ENTITY);
                    recordDO.setResponseParam(JSON.toJSONString(body,
                            SerializerFeature.DisableCircularReferenceDetect,
                            SerializerFeature.WriteMapNullValue));
                    recordDO.setRequestId(result.getRequestId());
                    req.removeAttribute(Constants.LOGGER_ENTITY);
                    req.setAttribute(Constants.LOGGER_ENTITY, recordDO);
                }
            }
        }
        return body;
    }
}

至于为什么要这样做，大家可以查一查资料，比我胡言乱语，扰乱大家心智强的多。

最后，注册拦截器

/**
 * @description mvc配置
 * @author huang
 * @date 2024/3/19 14:37
 */
@Configuration
public class RequestConfig implements WebMvcConfigurer {

    @Resource
    private LoggerInterceptor requestUrlInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 添加拦截器，配置拦截地址
        registry.addInterceptor(requestUrlInterceptor).addPathPatterns("/**");
    }
}

大功告成，至于存储日志那一块，我相信大家都会做，且第一个代码块中有注释，有心的仔细看一看。

创作不易，要个三连！

2024年04月19日更新

上线第二天，业务高峰期，服务器崩了，CPU彪100%，

初步判断是大对象造成的频繁FullGC；

建议：响应参数比较大的，入参比较大的要考虑清楚！！！

我的做法：舍弃响应参数，对于入参比较大的抽取必要参数，进行存储，等我后续更新吧！

Mr.huang

关注

6
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
1
评论
如何在Java项目中集成拦截器，并对请求与响应参数进行存储

日常开发中，因为某些原因（架构日志不支持长期存储/审计需要等等）我们往往想对自己的模块中的接口进行一个个性化且的记录。当然我们会想到用原生AOP+注解的形式去实现，但是Spring提供的拦截器也同样的好用，所以这里用拦截器实现了一个简单的日志记录。在做这个需求前，网上我也查了很多资料，要不含糊其辞，要不杂七杂八，最后就是跑不通。
复制链接

扫一扫