Spring AOP 操作日志实现

男娘i 2023-05-22 08:50 106阅读 0赞

多的不说，直接上代码

**一、注解**

import liquibase.logging.LogType;
    
    import java.lang.annotation.*;
    
    /** * 日志注解类 * 使用方式 @Log(value="某某接口方法") @Log(ignore=true) * @author nick */
    @Documented
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Log { 
    
        /** * 日志描述 * @return */
        String value() default "";
    
        /** * 是否不记录日志 * @return */
        boolean ignore() default false;
    
    
        /** * 日志类型 * @return */
        LogType logType() default LogType.LOG;
    
    }

**二、代码：**

import com.alibaba.fastjson.JSON;
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.annotation.*;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.stereotype.Component;
    import org.springframework.util.StringUtils;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.PrintStream;
    import java.lang.reflect.Method;
    
    /** * @author nick */
    @Aspect
    @Component
    @Slf4j
    public class LogAspect { 
    
        @Value("${cookie.encrypt.key}")
        private String cookieEncryptKey;
    
    
        @Autowired
        private SystemLogRepository systemLogRepository;
    
    
        /** * 获取本次线程参数 */
        private ThreadLocal<SystemLog> threadLocal = new ThreadLocal<>();
    
        /** * 设置切入点 */
        @Pointcut("@annotation(com.xxxx.xclouddesk.logging.annotation.Log)")
        public void pointcut() { }
    
        /** * 切面方法,记录日志 * @return */
        @Around("pointcut()")
        public Object around(ProceedingJoinPoint point){ 
            Object result = null;
            long beginTime = System.currentTimeMillis();
            try { 
                // 执行方法
                result = point.proceed();
            } catch (Throwable e) { 
                log.error("执行记录日志异常：{}",e.getMessage());
            }
            Signature signature = point.getSignature();
            if(!(signature instanceof MethodSignature)) { 
                throw new IllegalArgumentException("暂不支持非方法注解");
            }
            //获取执行的方法
            MethodSignature methodSign = (MethodSignature) signature;
            Method method = methodSign.getMethod();
            //判断是否包含了 无需记录日志的方法
            Log logAnne = AnnotationUtils.getAnnotation(method, Log.class);
            log.info("注解参数：{}",JSON.toJSONString(logAnne));
            if(StringUtils.isEmpty(logAnne) || !logAnne.ignore()) { 
                return result;
            }
            // 执行时长(毫秒)
            long time = System.currentTimeMillis() - beginTime;
            // 获取需要保存的参数
            saveSystemLog(point, time);
            return result;
        }
    
        /** * 获取需要保存的参数 * @param joinPoint * @param time */
        private void saveSystemLog(ProceedingJoinPoint joinPoint, long time) { 
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            SystemLog systemLog = new SystemLog();
            Log logAnnotation = method.getAnnotation(Log.class);
            if (logAnnotation != null) { 
                // 注解上的描述 可以详细描述
                systemLog.setOperation(logAnnotation.value());
                //操作日志内容类型
                log.info("操作日志类型：{}", logAnnotation.logType());
            }
            // 方法名获取
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = signature.getName();
            // 请求的方法参数值
            Object[] args = joinPoint.getArgs();
            // 请求的方法参数名称
            LocalVariableTableParameterNameDiscoverer localVariableTableParameterNameDiscoverer = new LocalVariableTableParameterNameDiscoverer();
            String[] paramNames = localVariableTableParameterNameDiscoverer.getParameterNames(method);
            if (args != null && paramNames != null) { 
                String params = "";
                for (int i = 0; i < args.length; i++) { 
                    params += " " + paramNames[i] + ": " + args[i];
                }
                systemLog.setParams(params);
            }
            //获取request 请求参数
            HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
            //利用RequestContextHolder获取requst对象
            ServletRequestAttributes requestObject = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
            // 获取url
            String url = requestObject.getRequest().getRequestURI();
            // 设置IP地址
            systemLog.setTime(time);
            systemLog.setMethod(className + "." + methodName + "()");
            systemLog.setIp(IpUtils.getIpAddr(request));
            systemLog.setUrl(url);
            systemLog.setCreateTime(System.currentTimeMillis());
            systemLog.setUpdateTime(System.currentTimeMillis());
            //通过线程进行保存日志
            threadLocal.set(systemLog);
        }
    
    
        /** * 方法成功return之后的advice * @param point * @param returning */
        @AfterReturning(value = "pointcut()",returning = "returning")
        public void after(JoinPoint point, Object returning) { 
            SystemLog systemLog = threadLocal.get();
            if(!StringUtils.isEmpty(systemLog)){ 
                log.info("调用返回数据方法：{}",JSON.toJSONString(returning));
                systemLog.setOutOperation(JSON.toJSONString(returning));
                //systemLogRepository.save(systemLog);
            }
            threadLocal.remove();
        }
    
        /** * 报错之后的advice * @param throwing */
        @AfterThrowing(value = "pointcut()",throwing = "throwing")
        public void error(Throwable throwing) { 
            try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) { 
                throwing.printStackTrace(new PrintStream(byteArrayOutputStream));
                //存储报错日志
                log.debug("报错日志：{}",JSON.toJSONString(byteArrayOutputStream.toString()));
            } catch (IOException e) { 
                log.error("存入数据异常：{}",e.getMessage());
            }
            threadLocal.remove();
        }
    
    }

import lombok.Data;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.data.annotation.Id;
    import org.springframework.data.elasticsearch.annotations.Document;
    import java.io.Serializable;
    
    /** * @author nick */
    @Slf4j
    @Data
    @Document(indexName = "systemlog",type = "systemlogtype" ,shards = 1,replicas = 0, refreshInterval = "-1")
    public class SystemLog implements Serializable { 
    
        private static final long serialVersionUID = 215831501598634496L;
        /** * 主键 */
        @Id
        private Long id;
    
        /** * 操作描述 */
        private String operation;
    
        /** * 操作时间 */
        private Long time;
    
        /** * 方法 */
        private String method;
    
        /** * 参数 */
        private String params;
    
        /** * ip */
        private String ip;
    
        /** * url */
        private String  url;
    
        /** * 出参 */
         private String outOperation;
    
        /** * 入参 */
        private String inOperation;
    
        /** * 创建时间 */
        private Long createTime;
    
        /** * 更新时间 */
        private Long updateTime;
    
    }

import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
    import org.springframework.stereotype.Repository;
    
    /** * 存储数据 */
    @Repository
    public interface SystemLogRepository extends ElasticsearchRepository<SystemLog,Long> { 
    }