记录接口的请求参数

package com.example.springboot.log;

import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
class RequestInfoBO {
    /**
     * 用于记录方法路径，或者请求接口
     */
    String uri;
    /**
     * 方法
     */
    String method;
    /**
     * 参数
     */
    String param;
    /**
     * 请求头
     */
    String header;
    /**
     * 请求人Ip
     */
    String userIp;

}

package com.example.springboot.log;

import lombok.Data;
import lombok.NoArgsConstructor;


@Data
@NoArgsConstructor
class RequestInfoBO {
    /**
     * 用于记录方法路径，或者请求接口
     */
    String uri;
    /**
     * 方法
     */
    String method;
    /**
     * 参数
     */
    String param;
    /**
     * 请求头
     */
    String header;
    /**
     * 请求人Ip
     */
    String userIp;

}

package com.example.springboot.log;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.validation.BindingResult;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
import java.util.Map;


@Slf4j
public class RequestInfoUtil {
    private static final ThreadLocal<Boolean> REQUEST_INFO_IS_GOTTEN = new ThreadLocal<>();

    /**
     * 根据切点信息生成请求信息
     *

     */
    public static RequestInfoBO generateRequestInfo(JoinPoint joinPoint) {
        RequestInfoBO result = new RequestInfoBO();
        HttpServletRequest request = getHttpServletRequest();
        if (request != null) {
            result.setUri(request.getServletPath());
            result.setUserIp(request.getRemoteHost());
            result.setHeader(getHeaders(request));
        }
        MethodSignature ms = (MethodSignature) joinPoint.getSignature();
        result.setMethod(ms.toString());
        result.setParam(getParameters(joinPoint, ms));
        return result;
    }

    /**
     * 清理信息，主要清理ThreadLocal信息
     *

     */
    public static void clean() {
        REQUEST_INFO_IS_GOTTEN.remove();
    }

    /**
     * 打印拦截到的参数信息
     *

     * * @param
     */
    public static String printInfo(RequestInfoBO po) {
        StringBuilder sb = new StringBuilder();
        sb.append("==========【请求参数信息】Start======================\n");
        if (StringUtils.isNotBlank(po.getUri())) {
            sb.append("【请求地址（URL）】:" + po.getUri() + "\n");
        }
        if (StringUtils.isNotBlank(po.getMethod())) {
            sb.append("【请求地址（METHOD）】：" + po.getMethod() + "\n");
        }
        if (StringUtils.isNotBlank(po.getParam())) {
            sb.append("【请求参数】：" + po.getParam() + "\n");
        }

        if (StringUtils.isNotBlank(po.getHeader())) {
            sb.append("【请求头】：" + po.getHeader() + "\n");
        }

        if (StringUtils.isNotBlank(po.getUserIp())) {
            sb.append("【请求人IP】：" + po.getUserIp() + "\n");
        }
        sb.append("==========【请求参数信息】End======================\n");
        return sb.toString();
    }

    /**
     * 私有构造函数，禁止其他人创建

     */
    private RequestInfoUtil() {
    }

    /**
     * 获取当前线程的HTTP Request信息，如果已经获取过，就不允许在获取
 
     */
    private static HttpServletRequest getHttpServletRequest() {
        HttpServletRequest request = null;
        Boolean gotten = REQUEST_INFO_IS_GOTTEN.get();
        if (null == gotten) {
            RequestAttributes requestAttributes = RequestContextHolder.currentRequestAttributes();
            if (requestAttributes instanceof ServletRequestAttributes) {
                request = ((ServletRequestAttributes) requestAttributes).getRequest();
            }
            REQUEST_INFO_IS_GOTTEN.set(true);
        }
        return request;
    }

    /**
     * 根据切点获取参数信息
     *

     */
    private static String getParameters(JoinPoint joinPoint, MethodSignature ms) {
        try {
            Object[] args = joinPoint.getArgs();
            LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
            String[] paramNames = u.getParameterNames(ms.getMethod());
            if (args != null && paramNames != null) {
                JSONObject params = new JSONObject();

                for (int i = 0; i < args.length; i++) {
                    if (args[i] instanceof ServletRequest) {
                        ServletRequest request = (ServletRequest) args[i];
                        JSONObject requestJSON = new JSONObject();
                        Map<String, String[]> requestParameterMap = request.getParameterMap();
                        for (Map.Entry<String, String[]> paramEntry : requestParameterMap.entrySet()) {
                            requestJSON.put(paramEntry.getKey(), paramEntry.getValue());
                        }
                        params.put(paramNames[i], requestJSON);
                    } else if (args[i] instanceof ServletResponse || args[i] instanceof MultipartFile || args[i] instanceof BindingResult) {
                        continue;
                    } else {
                        params.put(paramNames[i], args[i]);
                    }
                }
                return params.toJSONString();
            }
            return null;
        } catch (Throwable e) {
            log.error("解析请求参数出错", e);
            return null;
        }
    }


    /**
     * 获取请求头
     *

     */
    private static String getHeaders(HttpServletRequest request) {
        if (null == request) {
            return null;
        } else {
            Enumeration<String> headerNames = request.getHeaderNames();
            JSONObject headerJSON = new JSONObject();
            while (headerNames.hasMoreElements()) {
                String header = headerNames.nextElement();
                String headerValue = request.getHeader(header);
                headerJSON.put(header, headerValue);
            }
            return headerJSON.toJSONString();
        }
    }


}

package com.example.springboot.log;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.MDC;

import java.util.UUID;

/**

 */
public class RequestLogHandler {
    private static final ThreadLocal<String> currentUUID = new ThreadLocal<>();
    private static final String REQUEST_ID = "requestId";

    /**
     * 设置当前线程的RequestId
     *

     */
    public static boolean firstRequestId() {
        String uuid = currentUUID.get();
        if (StringUtils.isNotBlank(uuid)) {
            String mdcUUID = MDC.get(REQUEST_ID);
            if (StringUtils.isBlank(mdcUUID)) {
                MDC.put(REQUEST_ID, uuid);
            }
            return false;
        } else {
            uuid = UUID.randomUUID().toString();
            currentUUID.set(uuid);
            MDC.put(REQUEST_ID, uuid);
            return true;
        }
    }
    /**
     * 清除当前线程的ReuqestId
     *

     */
    public static void cleanRequestId() {
        currentUUID.remove();
        MDC.remove(REQUEST_ID);
    }

    /**
    * 私有构造，禁止显示创建

    */
    private RequestLogHandler() {

    }





}