自动添加日志记录，@Log注解，日志切面

秒速五厘米 2023-10-13 13:17 148阅读 0赞

##### 在controller的方法上添加注解@Log(description = "重置密码",logType = LogEnum.UPDATE)实现将日志记录添加到表中 #####

切入点log.java

import java.lang.annotation.*;
    
    
    
    @Target({ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Log {
    
        /**
         * 操作系统(4A、督导员、督导员App等）
         */
        String operatingSystem() default "";
    
        /**
         * 操作模块
         */
        String module() default "";
    
        /**
         * 操作描述
         */
        String description() default "";
    
        /**
         * 操作类型 查询 删除 保存
         */
        String logType() default "";
    }

LogHandle.java

import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.core.Ordered;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.Resource;
    import java.lang.reflect.Method;
    
    
    @Aspect
    @Component
    @Slf4j
    public class LogHandle implements Ordered {
        @Resource
        private LogService logService;
    
        /**
         * 日志切入点
         */
        @Pointcut("@annotation(上面log的文件路径xxx.xxx.xxx.log)")
        public void logPointCut(){}
    
        @AfterReturning(pointcut = "logPointCut()")
        public void doAfter(JoinPoint joinPoint){
            log.info("----进入切面----");
            /**
             * 解析Log注解
             */
            String methodName = joinPoint.getSignature().getName();
            Method method = currentMethod(joinPoint,methodName);
            Log log = method.getAnnotation(Log.class);
            logService.put(joinPoint,methodName,log.operatingSystem(),log.module(),log.description(),log.logType());
        }
    
        /**
         * 获取当前执行的方法
         *
         * @param joinPoint  连接点
         * @param methodName 方法名称
         * @return 方法
         */
        private Method currentMethod(JoinPoint joinPoint, String methodName) {
            /**
             * 获取目标类的所有方法，找到当前要执行的方法
             */
            Method[] methods = joinPoint.getTarget().getClass().getMethods();
            Method resultMethod = null;
            for (Method method : methods) {
                if (method.getName().equals(methodName)) {
                    resultMethod = method;
                    break;
                }
            }
            return resultMethod;
        }
    
        @Override
        public int getOrder() {
            return 100;
        }
    }

LogEnum.java

public class LogEnum {
        //operatingSystem
        public final static String SUPERVISOR  = "劳务人员办公系统";
    
        //logType
        public final static String SELECT  = "查询";
        public final static String UPDATE  = "保存";
        public final static String DELETE  = "删除";
    }

syslog.java

import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import javax.persistence.Column;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.Table;
    import java.util.Date;
    
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    @Table(name = "sys_log")
    public class SysLog {
        /**
         * 操作日志id
         */
        @Id
        @GeneratedValue(generator = "JDBC")
        private String id;
    
        /**
         * 操作时间
         */
        @Column(name = "add_time")
        private Date addTime;
    
        /**
         * 操作人Id
         */
        @Column(name = "user_id")
        private String userId;
    
        /**
         * 操作人姓名
         */
        @Column(name = "user_name")
        private String userName;
    
        /**
         * IP
         */
        @Column(name = "IP")
        private String ip;
    
    
        /**
         * 操作描述
         */
        private String description;
    
        /**
         * 操作类型 查询 删除 保存
         */
        @Column(name = "log_type")
        private String logType;
    
    
        /**
         * 入参
         */
        private String params;
    
    
    }

logserver.java

import cn.dev33.satoken.stp.StpUtil;
    import com.alibaba.fastjson.JSONObject;
    
    
    import lombok.extern.slf4j.Slf4j;
    import org.apache.ibatis.javassist.*;
    import org.apache.ibatis.javassist.bytecode.CodeAttribute;
    import org.apache.ibatis.javassist.bytecode.LocalVariableAttribute;
    import org.apache.ibatis.javassist.bytecode.MethodInfo;
    import org.aspectj.lang.JoinPoint;
    import org.springframework.stereotype.Service;
    import org.springframework.util.CollectionUtils;
    import org.springframework.util.StringUtils;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletRequest;
    import java.util.*;
    
    
    @Slf4j
    @Service
    public class LogService {
        @Resource
        private SysLogMapper sysLogMapper;
    
    
    
        public void put(JoinPoint joinPoint, String methodName, String operatingSystem,String module, String description, String logType) {
            try {
                log.info("保存用户操作记录");
                //ip
                HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
                //设备信息(从前端获取)  从header里面获取参数
                String deviceInfo = request.getHeader("deviceInfo");
                // 拿到ip地址
                String ip = IpUtils.getIpAdrress(request);
                //获取方法的形参
                String params = this.operateContent(joinPoint,methodName,request);
                String userId="";
                String userName = "";
           
              
    
    			// 代码保存日志逻辑
                if (!logType.equals(LogEnum.SELECT)){
                    SysLog sysLog = SysLog.builder().id(FunctionUtil.GenerateGUID())
                            .addTime(new Date())
                            .userId(userId)
                            .userName(userName)
                            .ip(ip)
                            .description(description)
                            .logType(logType)
                            .params(params)
                            .build();
                    sysLogMapper.insertSelective(sysLog);
                }
                //保存方法日志到文件中
                /*String url = request.getServletPath() + "/" + methodName;
                xxxx xxx= xxx.xxx("xxx");
                File file = LogInfo.createFile(xxx.getxxx());
                LogInfo.saveLog(file,ip,userId,deviceInfo,url,params);*/
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public String operateContent(JoinPoint joinPoint, String methodName, HttpServletRequest request) throws ClassNotFoundException, NotFoundException {
            String className = joinPoint.getTarget().getClass().getName();
            Object[] params = joinPoint.getArgs();
            String classType = joinPoint.getTarget().getClass().getName();
            Class<?> clazz = Class.forName(classType);
            String clazzName = clazz.getName();
            Map<String,Object > nameAndArgs = getFieldsName(this.getClass(), clazzName, methodName,params);
            StringBuffer bf = new StringBuffer();
            if (!CollectionUtils.isEmpty(nameAndArgs)){
                Iterator it = nameAndArgs.entrySet().iterator();
                while (it.hasNext()){
                    Map.Entry entry = (Map.Entry) it.next();
                    String key = (String) entry.getKey();
                    String value = JSONObject.toJSONString(entry.getValue());
                    bf.append(key).append("=");
                    //bf.append(value).append("&");
                    bf.append(value);
                }
            }
            if (StringUtils.isEmpty(bf.toString())){
                bf.append(request.getQueryString());
            }
            return bf.toString();
        }
    
        private Map<String,Object> getFieldsName(Class cls, String clazzName, String methodName, Object[] args) throws NotFoundException {
            Map<String,Object > map=new HashMap<String,Object>();
    
            ClassPool pool = ClassPool.getDefault();
            ClassClassPath classPath = new ClassClassPath(cls);
            pool.insertClassPath(classPath);
    
            CtClass cc = pool.get(clazzName);
            CtMethod cm = cc.getDeclaredMethod(methodName);
            MethodInfo methodInfo = cm.getMethodInfo();
            CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
            LocalVariableAttribute attr = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
            if (attr == null) {
                // exception
                return map;
            }
            int pos = Modifier.isStatic(cm.getModifiers()) ? 0 : 1;
            for (int i = 0; i < cm.getParameterTypes().length; i++){
                map.put( attr.variableName(i + pos),args[i]);//paramNames即参数名
            }
            return map;
        }
    }