Springboot基于Aop日志拦截接口

朱雀 2023-06-30 07:00 27阅读 0赞

依赖：

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>

代码：

package com.talent.service.aop;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.TypeReference;
    import io.netty.handler.codec.json.JsonObjectDecoder;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang.StringUtils;
    import org.apache.commons.lang.time.StopWatch;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.core.DefaultParameterNameDiscoverer;
    import org.springframework.core.ParameterNameDiscoverer;
    import org.springframework.stereotype.Component;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Objects;
    
    /**
     * @program: Talent-Master
     * @description: Api接口统一拦截日志aop
     * @author: yarm.yang
     * @create: 2020-01-15 11:22
     */
    @Component
    @Aspect
    @Slf4j
    public class ApiLogAop {
    
        // 切点
        @Pointcut("execution(* com.talent.controller..*.*(..)))")
        public void pointcut(){}
    
        @Around("pointcut()")
        public Object handle(ProceedingJoinPoint joinPoint) throws Throwable {
    
            Long watchTime = 0L;
            try {
                HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
                //IP地址
                String ipAddr = getRemoteHost(request);
                String url = request.getRequestURL().toString();
                Map<String, String[]> parameterMap = request.getParameterMap();
                String parameterStr = preHandle(parameterMap);
    
                Map<String, String> reqMap = preHandle(joinPoint);
                if(StringUtils.isNotBlank(parameterStr)){
                    log.info("请求源IP:{},请求URL:{},请求URL参数：{},请求JSON参数:{}", ipAddr, url, parameterStr, reqMap);
                }else {
                    log.info("请求源IP:{},请求URL:{},请求JSON参数:{}", ipAddr, url, reqMap);
                }
    
                StopWatch stopWatch = new StopWatch();
                // 执行目标方法
                stopWatch.start();
                Object result = joinPoint.proceed();
                stopWatch.stop();
                watchTime = stopWatch.getTime();
    
                String respParam = postHandle(result);
                log.info("请求源IP:{},请求URL:{},返回参数:{},请求时间：{}ms", ipAddr, url, respParam, watchTime);
                return result;
            }catch (Exception e){
                log.error("日志aop拦截Exception异常：{}", JSONObject.toJSON(e.getMessage()).toString());
            }catch (Throwable throwable){
                log.error("日志aop拦截Throwable异常：{}", JSONObject.toJSON(throwable.getMessage()).toString());
            }
            return null;
        }
    
        /**
         * @Description: 解析url带的参数
         * @Param: [parameterMap]
         * @Return: java.lang.String
         * @Author: yarm.yang
         * @Date: 2020/1/15 13:56
         */
        private String preHandle(Map<String, String[]> parameterMap) {
            String result = "";
    
            if(parameterMap == null || parameterMap.size() == 0) return result;
    
            StringBuffer sb = new StringBuffer();
            for (Map.Entry entry : parameterMap.entrySet()){
                String key = (String)entry.getKey();
                String[] value = (String[])entry.getValue();
                String valueArr = Arrays.toString(value);
                String valueStr = "";
                if(StringUtils.isNotBlank(valueArr) && valueArr.startsWith("[") && valueArr.endsWith("]")){
                    valueStr = valueArr.substring(1, valueArr.lastIndexOf(']'));
                }
                sb.append(key).append("=").append(valueStr).append("&");
            }
    
            result = sb.toString();
    
            if(StringUtils.isNotBlank(result) && result.endsWith("&")){
                result = result.substring(0, result.lastIndexOf('&'));
            }
            return result;
        }
    
        /**
         * url入参数据，返回json
         * @param joinPoint
         * @param request
         * @return
         */
        private String preHandle(ProceedingJoinPoint joinPoint,HttpServletRequest request) {
    
            String reqParam = "";
            Signature signature = joinPoint.getSignature();
            MethodSignature methodSignature = (MethodSignature) signature;
            Method targetMethod = methodSignature.getMethod();
            Annotation[] annotations = targetMethod.getAnnotations();
            for (Annotation annotation : annotations) {
                //此处可以改成自定义的注解
                if (annotation.annotationType().equals(RequestMapping.class)) {
                    reqParam = JSON.toJSONString(request.getParameterMap());
                    break;
                }
            }
            return reqParam;
        }
    
        /**
         * @Description: json请求参数
         * @Param: [joinPoint]
         * @Return: java.util.Map<java.lang.String,java.lang.String>
         * @Author: yarm.yang
         * @Date: 2020/1/16 9:48
         */
        private static Map<String, String> preHandle(ProceedingJoinPoint joinPoint) {
            // 参数值
            Object[] args = joinPoint.getArgs();
            ParameterNameDiscoverer pnd = new DefaultParameterNameDiscoverer();
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            String[] parameterNames = pnd.getParameterNames(method);
    
            Map<String, Object> paramMap = new HashMap<>(32);
            for (int i = 0; i < parameterNames.length; i++) {
                if(i == 0){
                    paramMap.put("p", args[i]);
                }else {
                    // 约定好取第一个参数 直接过滤
                    continue;
                    // paramMap.put(parameterNames[i], args[i]);
                }
            }
            // 返回map
            Map<String, String> resultMap = new HashMap<>(32);
            Object p = paramMap.get("p");
            if(Objects.isNull(p)) return resultMap;
    
            Map<String, Object> tempMap = JSON.parseObject(JSON.toJSONString(p),new TypeReference<Map<String,Object>>(){});
    
            tempMap.forEach((k,v) -> {
                resultMap.put(k, v + "");
            });
    
            return resultMap;
        }
    
        /**
         * 返回数据
         * @param retVal
         * @return
         */
        private String postHandle(Object retVal) {
            if(null == retVal){
                return "";
            }
            return JSON.toJSONString(retVal);
        }
    
    
        /**
         * 获取目标主机的ip
         * @param request
         * @return
         */
        private String getRemoteHost(HttpServletRequest request) {
            String ip = request.getHeader("x-forwarded-for");
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
            return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
        }
    
    }

获取切点方法参数列表

private String paramToJson(ProceedingJoinPoint joinPoint) {
            String reqParam = "";
            // 参数值
            Object[] args = joinPoint.getArgs();
            ParameterNameDiscoverer pnd = new DefaultParameterNameDiscoverer();
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            String[] parameterNames = pnd.getParameterNames(method);
            Map<String, Object> paramMap = new HashMap<>(32);
            for (int i = 0; i < parameterNames.length; i++) {
                paramMap.put(parameterNames[i], args[i]);
            }
            reqParam = JSONObject.toJSONString(paramMap);
            return reqParam;
        }