【aop】使用SpringBoot AOP 记录操作日志、异常日志【转载】

秒速五厘米 2023-01-19 11:58 63阅读 0赞

前言

文章转载自：https://www.cnblogs.com/wm-dv/p/11735828.html

原本内容(实现步骤)

使用SpringBoot AOP 记录操作日志、异常日志
　　平时我们在做项目时经常需要对一些重要功能操作记录日志，方便以后跟踪是谁在操作此功能；我们在操作某些功能时也有可能会发生异常，但是每次发生异常要定位原因我们都要到服务器去查询日志才能找到，而且也不能对发生的异常进行统计，从而改进我们的项目，要是能做个功能专门来记录操作日志和异常日志那就好了， 当然我们肯定有方法来做这件事情，而且也不会很难，我们可以在需要的方法中增加记录日志的代码，和在每个方法中增加记录异常的代码，最终把记录的日志存到数据库中。听起来好像很容易，但是我们做起来会发现，做这项工作很繁琐，而且都是在做一些重复性工作，还增加大量冗余代码，这种方式记录日志肯定是不可行的。　　
　　我们以前学过Spring 三大特性，IOC（控制反转），DI（依赖注入），AOP（面向切面），那其中AOP的主要功能就是将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来。今天我们就来用springBoot Aop 来做日志记录，好了，废话说了一大堆还是上货吧。

  • 创建数据库
    操作日志表
    在这里插入图片描述
    异常日志表
    在这里插入图片描述

  • 添加maven依赖


    org.springframework.boot
    spring-boot-starter-aop

  • 创建自定义注解：@OperLog

    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;

    /* 自定义操作日志注解 @author wu /
    @Target(ElementType.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上
    @Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执行
    @Documented
    public @interface OperLog { 

    1. String operModul() default ""; // 操作模块
    2. String operType() default "";  // 操作类型
    3. String operDesc() default "";  // 操作说明

    }

  • 创建切面类记录操作日志

    import java.lang.reflect.Method;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;

    import javax.servlet.http.HttpServletRequest;

    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;

    import com.gexin.fastjson.JSON;
    import com.hyd.zcar.cms.common.utils.IPUtil;
    import com.hyd.zcar.cms.common.utils.annotation.OperLog;
    import com.hyd.zcar.cms.common.utils.base.UuidUtil;
    import com.hyd.zcar.cms.common.utils.security.UserShiroUtil;
    import com.hyd.zcar.cms.entity.system.log.ExceptionLog;
    import com.hyd.zcar.cms.entity.system.log.OperationLog;
    import com.hyd.zcar.cms.service.system.log.ExceptionLogService;
    import com.hyd.zcar.cms.service.system.log.OperationLogService;

    /* 切面处理类，操作日志异常日志记录处理 @author wu @date 2019/03/21 /
    @Aspect
    @Component
    public class OperLogAspect { 

    1. /** * 操作版本号 * <p> * 项目启动时从命令行传入，例如：java -jar xxx.war --version=201902 * </p> */
    2. @Value("${version}")
    3. private String operVer;
    5. @Autowired
    6. private OperationLogService operationLogService;
    8. @Autowired
    9. private ExceptionLogService exceptionLogService;
    11. /** * 设置操作日志切入点 记录操作日志 在注解的位置切入代码 */
    12. @Pointcut("@annotation(com.hyd.zcar.cms.common.utils.annotation.OperLog)")
    13. public void operLogPoinCut() { 
    14. }
    16. /** * 设置操作异常切入点记录异常日志 扫描所有controller包下操作 */
    17. @Pointcut("execution(* com.hyd.zcar.cms.controller..*.*(..))")
    18. public void operExceptionLogPoinCut() { 
    19. }
    21. /** * 正常返回通知，拦截用户操作日志，连接点正常执行完成后执行， 如果连接点抛出异常，则不会执行 * * @param joinPoint 切入点 * @param keys 返回结果 */
    22. @AfterReturning(value = "operLogPoinCut()", returning = "keys")
    23. public void saveOperLog(JoinPoint joinPoint, Object keys) { 
    24.     // 获取RequestAttributes
    25.     RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
    26.     // 从获取RequestAttributes中获取HttpServletRequest的信息
    27.     HttpServletRequest request = (HttpServletRequest) requestAttributes
    28.             .resolveReference(RequestAttributes.REFERENCE_REQUEST);
    30.     OperationLog operlog = new OperationLog();
    31.     try { 
    32.         operlog.setOperId(UuidUtil.get32UUID()); // 主键ID
    34.         // 从切面织入点处通过反射机制获取织入点处的方法
    35.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    36.         // 获取切入点所在的方法
    37.         Method method = signature.getMethod();
    38.         // 获取操作
    39.         OperLog opLog = method.getAnnotation(OperLog.class);
    40.         if (opLog != null) { 
    41.             String operModul = opLog.operModul();
    42.             String operType = opLog.operType();
    43.             String operDesc = opLog.operDesc();
    44.             operlog.setOperModul(operModul); // 操作模块
    45.             operlog.setOperType(operType); // 操作类型
    46.             operlog.setOperDesc(operDesc); // 操作描述
    47.         }
    48.         // 获取请求的类名
    49.         String className = joinPoint.getTarget().getClass().getName();
    50.         // 获取请求的方法名
    51.         String methodName = method.getName();
    52.         methodName = className + "." + methodName;
    54.         operlog.setOperMethod(methodName); // 请求方法
    56.         // 请求的参数
    57.         Map<String, String> rtnMap = converMap(request.getParameterMap());
    58.         // 将参数所在的数组转换成json
    59.         String params = JSON.toJSONString(rtnMap);
    61.         operlog.setOperRequParam(params); // 请求参数
    62.         operlog.setOperRespParam(JSON.toJSONString(keys)); // 返回结果
    63.         operlog.setOperUserId(UserShiroUtil.getCurrentUserLoginName()); // 请求用户ID
    64.         operlog.setOperUserName(UserShiroUtil.getCurrentUserName()); // 请求用户名称
    65.         operlog.setOperIp(IPUtil.getRemortIP(request)); // 请求IP
    66.         operlog.setOperUri(request.getRequestURI()); // 请求URI
    67.         operlog.setOperCreateTime(new Date()); // 创建时间
    68.         operlog.setOperVer(operVer); // 操作版本
    69.         operationLogService.insert(operlog);
    70.     } catch (Exception e) { 
    71.         e.printStackTrace();
    72.     }
    73. }
    75. /** * 异常返回通知，用于拦截异常日志信息 连接点抛出异常后执行 * * @param joinPoint 切入点 * @param e 异常信息 */
    76. @AfterThrowing(pointcut = "operExceptionLogPoinCut()", throwing = "e")
    77. public void saveExceptionLog(JoinPoint joinPoint, Throwable e) { 
    78.     // 获取RequestAttributes
    79.     RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
    80.     // 从获取RequestAttributes中获取HttpServletRequest的信息
    81.     HttpServletRequest request = (HttpServletRequest) requestAttributes
    82.             .resolveReference(RequestAttributes.REFERENCE_REQUEST);
    84.     ExceptionLog excepLog = new ExceptionLog();
    85.     try { 
    86.         // 从切面织入点处通过反射机制获取织入点处的方法
    87.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    88.         // 获取切入点所在的方法
    89.         Method method = signature.getMethod();
    90.         excepLog.setExcId(UuidUtil.get32UUID());
    91.         // 获取请求的类名
    92.         String className = joinPoint.getTarget().getClass().getName();
    93.         // 获取请求的方法名
    94.         String methodName = method.getName();
    95.         methodName = className + "." + methodName;
    96.         // 请求的参数
    97.         Map<String, String> rtnMap = converMap(request.getParameterMap());
    98.         // 将参数所在的数组转换成json
    99.         String params = JSON.toJSONString(rtnMap);
    100.         excepLog.setExcRequParam(params); // 请求参数
    101.         excepLog.setOperMethod(methodName); // 请求方法名
    102.         excepLog.setExcName(e.getClass().getName()); // 异常名称
    103.         excepLog.setExcMessage(stackTraceToString(e.getClass().getName(), e.getMessage(), e.getStackTrace())); // 异常信息
    104.         excepLog.setOperUserId(UserShiroUtil.getCurrentUserLoginName()); // 操作员ID
    105.         excepLog.setOperUserName(UserShiroUtil.getCurrentUserName()); // 操作员名称
    106.         excepLog.setOperUri(request.getRequestURI()); // 操作URI
    107.         excepLog.setOperIp(IPUtil.getRemortIP(request)); // 操作员IP
    108.         excepLog.setOperVer(operVer); // 操作版本号
    109.         excepLog.setOperCreateTime(new Date()); // 发生异常时间
    111.         exceptionLogService.insert(excepLog);
    113.     } catch (Exception e2) { 
    114.         e2.printStackTrace();
    115.     }
    117. }
    119. /** * 转换request 请求参数 * * @param paramMap request获取的参数数组 */
    120. public Map<String, String> converMap(Map<String, String[]> paramMap) { 
    121.     Map<String, String> rtnMap = new HashMap<String, String>();
    122.     for (String key : paramMap.keySet()) { 
    123.         rtnMap.put(key, paramMap.get(key)[0]);
    124.     }
    125.     return rtnMap;
    126. }
    128. /** * 转换异常信息为字符串 * * @param exceptionName 异常名称 * @param exceptionMessage 异常信息 * @param elements 堆栈信息 */
    129. public String stackTraceToString(String exceptionName, String exceptionMessage, StackTraceElement[] elements) { 
    130.     StringBuffer strbuff = new StringBuffer();
    131.     for (StackTraceElement stet : elements) { 
    132.         strbuff.append(stet + "\n");
    133.     }
    134.     String message = exceptionName + ":" + exceptionMessage + "\n\t" + strbuff.toString();
    135.     return message;
    136. }

    }

  • 在Controller层方法添加@OperLog注解
    在这里插入图片描述

  • 操作日志、异常日志查询功能
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

附件sql

因为我们的需求没有异常记录，有异常会发邮件的，所以我这边只添加了日志记录表（且里面没有操作员名称）。

  1. DROP TABLE IF EXISTS `md_operation_log`;
  2. CREATE TABLE `md_operation_log` (
  3.   `oper_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  4.   `oper_modul` varchar(64) DEFAULT NULL COMMENT '功能模块',
  5.   `oper_type` varchar(64) DEFAULT NULL COMMENT '操作类型',
  6.   `oper_desc` varchar(500) DEFAULT NULL COMMENT '操作描述',
  7.   `oper_requ_param` text COMMENT '请求参数',
  8.   `oper_resp_param` text COMMENT '返回参数',
  9.   `oper_user_id` int(11) DEFAULT NULL COMMENT '操作员id',
  10.   `oper_method` varchar(255) DEFAULT NULL COMMENT '操作方法',
  11.   `oper_uri` varchar(255) DEFAULT NULL COMMENT '请求uri',
  12.   `oper_ip` varchar(255) DEFAULT NULL COMMENT '请求ip',
  13.   `oper_create_time` datetime DEFAULT NULL COMMENT '请求时间',
  14.   `oper_ver` varchar(255) DEFAULT NULL COMMENT '请求版本号',
  15.   PRIMARY KEY (`oper_id`)
  16. ) ENGINE=InnoDB AUTO_INCREMENT=252 DEFAULT CHARSET=utf8mb4 COMMENT='操作日志表';

改动

我这里把他这个操作类型类根据自己的需求改成了枚举，原先是常量。
原因：
首先，依然有常量的功能；
其次，在回显的时候，在枚举里面通过方法，可以根据value值获取到名称；
最后，可以再加一个接口，把整个枚举类转map返回到前端，让前端方便根据类型来查询。
示例如下：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
枚举类代码

  1. public enum OperLogTypeEnum { 
  2.     LIST("列表","list"),
  3.     ADD("添加","add"),
  4.     EDIT("编辑","edit"),
  5.     DELETE("删除","delete"),
  6.     DISABLE("禁用","disable"),
  7.     CANCEL("取消","cancel"),
  8.     DOWNLOAD("下载","download");
  10.     private String typeName;
  11.     private String typeValue;
  13.     /** * 获取类型名称 * * @param typeValue * @return */
  14.     public static String getTypeName(String typeValue){ 
  15.         for (OperLogTypeEnum operLogTypeEnum : OperLogTypeEnum.values()) { 
  16.             if(operLogTypeEnum.getTypeValue().equals(typeValue)){ 
  17.                 return operLogTypeEnum.typeName;
  18.             }
  19.         }
  20.         return null;
  21.     }
  23.     OperLogTypeEnum(String typeName, String typeValue) { 
  24.         this.typeName = typeName;
  25.         this.typeValue = typeValue;
  26.     }
  28.     public String getTypeName() { 
  29.         return typeName;
  30.     }
  32.     public void setTypeName(String typeName) { 
  33.         this.typeName = typeName;
  34.     }
  36.     public String getTypeValue() { 
  37.         return typeValue;
  38.     }
  40.     public void setTypeValue(String typeValue) { 
  41.         this.typeValue = typeValue;
  42.     }
  43. }

发表评论

表情：
评论列表 （有 0 条评论，63人围观）

还没有评论，来说两句吧...

相关阅读

    相关 AOP实现日志记录

    需要通过日志记录接口调用信息。便于后期调试排查。并且可能有很多接口都需要进行日志的记录。 接口被调用时日志打印格式如下： ![fe457502eac148888097b0f

    向右看齐向右看齐/ 0 赞/ 137 阅读