SpringBoot中日志切面实现小结_Java

在应用开发中，日志记录对于监控、调试和追踪用户行为至关重要。spring boot 虽然内置了强大的日志框架，但在某些情况下，我们可能需要更细粒度的日志管理。spring aop 提供了一种灵活的方式来实现方法级别的日志记录，而无需侵入业务代码。本文将介绍如何通过 spring aop 切面来实现这一功能。

什么是spring aop？

spring aop 是一个面向切面的编程（aop）框架，它允许开发者将横切关注点（如日志记录、事务管理等）与业务逻辑分离。通过使用 spring aop，我们可以在不修改业务代码的情况下，为应用程序添加日志记录功能。

spring aop 详细可以看这篇文章 spring aop入门

日志切面的设计

在我们的示例中，我们定义了一个 syslog 注解，用于标记需要记录日志的方法。接着，我们创建了一个日志切面 logaspect，它会拦截所有带有 syslog 注解的方法，并记录日志信息。

syslog 注解

首先，我们定义了一个 syslog 注解，它可以用来标记需要记录日志的方法：

@target({elementtype.method})
@retention(retentionpolicy.runtime)
@documented
public @interface syslog {
    string value() default "";
}

这个注解非常简单，它只有一个 value 属性，用于存储日志的描述信息。

日志切面 logaspect

接下来，我们创建了 logaspect 切面类，它会拦截所有带有 syslog 注解的方法：

@aspect
@component
public class logaspect {
    // 省略其他成员变量和方法

    @around("@annotation(syslog)")
    public object logaround(proceedingjoinpoint joinpoint, syslog syslog) throws throwable {
        // 日志记录逻辑
    }
}

在这个切面中，我们使用了 @around 注解来定义一个环绕通知，它会在目标方法执行前后记录日志信息。

日志记录的实现

在 logaspect 切面类中，我们实现了 logaround 方法，它会在目标方法执行前后记录日志信息：

@around("@annotation(syslog)")
public object logaround(proceedingjoinpoint joinpoint, syslog syslog) throws throwable {
    log log = new log();
    log.settimestamp(new date());
    log.setdescription(syslog.value());
    log.setmethodname(joinpoint.getsignature().getname());
    log.setparameters(arrays.tostring(joinpoint.getargs()));

    try {
        object result = joinpoint.proceed();
        log.setlevel("info");
        log.setmessage("方法 " + joinpoint.getsignature().getname() + " 执行成功。");
        return result;
    } catch (exception e) {
        log.setlevel("error");
        log.setmessage("方法 " + joinpoint.getsignature().getname() + " 执行过程中发生异常。");
        log.setexception(e.tostring());
        throw e;
    } finally {
        logservice.save(log);
    }
}

在这个环绕通知中，我们首先创建了一个 log 对象，并设置了日志的基本信息，如时间戳、描述、方法名和参数。然后，我们执行目标方法，并根据执行结果记录日志信息。如果目标方法执行过程中发生异常，我们会记录异常信息。

测试

完整代码

maven依赖

在 pom.xml 文件中添加依赖：

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-aop</artifactid>
</dependency>

sql脚本

创建日志表的 sql 脚本：

drop table if exists `logs`;
create table `logs`  (
  `id` bigint not null auto_increment comment '主键id',
  `description` varchar(255) character set utf8mb4 collate utf8mb4_0900_ai_ci null default null comment '描述',
  `level` varchar(10) character set utf8mb4 collate utf8mb4_0900_ai_ci not null comment '日志级别',
  `timestamp` datetime not null comment '时间戳',
  `message` text character set utf8mb4 collate utf8mb4_0900_ai_ci not null comment '日志消息',
  `class_name` varchar(255) character set utf8mb4 collate utf8mb4_0900_ai_ci null default null comment '类名',
  `method_name` varchar(255) character set utf8mb4 collate utf8mb4_0900_ai_ci null default null comment '方法名',
  `parameters` varchar(255) character set utf8mb4 collate utf8mb4_0900_ai_ci null default null comment '参数',
  `user_identifier` varchar(255) character set utf8mb4 collate utf8mb4_0900_ai_ci null default null comment '用户标识',
  `exception` text character set utf8mb4 collate utf8mb4_0900_ai_ci null comment '异常信息',
  primary key (`id`) using btree
) engine = innodb auto_increment = 2 character set = utf8mb4 collate = utf8mb4_0900_ai_ci comment = '日志表' row_format = dynamic;

日志实体类 log

我们定义了一个 log 实体类，用于存储日志信息：

/**
 * 日志实体类
 *
 * @author 王闻薪
 */
@data
@tablename("logs")
public class log implements serializable {

    private static final long serialversionuid = 1l;

    /**
     * 主键id
     */
    @tableid(value = "id", type = idtype.auto)
    private long id;

    /**
     * 描述
     */
    @tablefield("description")
    private string description;

    /**
     * 日志级别
     */
    @tablefield("level")
    private string level;

    /**
     * 时间戳
     */
    @tablefield("timestamp")
    private date timestamp;

    /**
     * 日志消息
     */
    @tablefield("message")
    private string message;

    /**
     * 类名
     */
    @tablefield("class_name")
    private string classname;

    /**
     * 方法名
     */
    @tablefield("method_name")
    private string methodname;


    /**
     * 参数
     */
    @tablefield("parameters")
    private string parameters;

    /**
     * 用户标识
     */
    @tablefield("user_identifier")
    private string useridentifier;

    /**
     * 异常信息
     */
    @tablefield("exception")
    private string exception;

}

这个实体类映射到数据库中的 logs 表，用于存储日志的详细信息。

切面代码

日志切面类 logaspect：

package org.example.demo.aspectj;

import lombok.extern.slf4j.slf4j;
import org.aspectj.lang.proceedingjoinpoint;
import org.aspectj.lang.annotation.around;
import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.pointcut;
import org.example.demo.annotation.syslog;
import org.example.demo.entity.log;
import org.example.demo.service.ilogservice;
import org.example.demo.utils.tokenservice;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.component;

import java.util.arrays;
import java.util.date;

/**
 * 日志切面类
 * 用于拦截标注有@syslog注解的方法，并记录日志信息。
 *
 * @author 王闻薪
 */
@slf4j
@aspect // 标记为切面类
@component // 将此切面类交给spring管理
public class logaspect {

    @autowired
    private ilogservice logservice;

    @autowired
    private tokenservice tokenservice;

    /**
     * 环绕通知
     * 拦截带有@syslog注解的方法，并在方法执行前后进行日志记录。
     *
     * @param joinpoint 连接点对象，包含方法的调用信息。
     * @param syslog 注解对象，包含日志描述信息。
     * @return 方法执行结果。
     * @throws throwable 可能抛出的异常。
     */
    @around("@annotation(syslog)")
    public object logaround(proceedingjoinpoint joinpoint, syslog syslog) throws throwable {
        // 创建日志对象
        log log = new log();
        log.setlevel("info");
        log.settimestamp(new date());
        log.setuseridentifier(getuserid().tostring());
        log.setdescription(syslog.value());
        // 记录方法调用前的日志
        logbefore(joinpoint, log);

        try {
            // 继续执行目标方法
            object result = joinpoint.proceed();

            // 记录方法调用后的日志
            logafter(joinpoint, result, log);
            log.setmessage("方法 " + joinpoint.getsignature().getname() + " 执行成功。");

            return result;
        } catch (exception e) {
            // 记录异常日志
            logexception(joinpoint, e, log);
            log.setlevel("error");
            log.setmessage("方法 " + joinpoint.getsignature().getname() + " 执行过程中发生异常。");
            throw e; // 重新抛出异常
        } finally {
            // 保存日志到数据库
            logservice.save(log);
        }
    }

    /**
     * 记录方法调用前的日志信息。
     *
     * @param joinpoint 连接点对象，包含方法的调用信息。
     * @param log 日志对象，用于存储日志信息。
     */
    private void logbefore(proceedingjoinpoint joinpoint, log log) {
        log.setclassname(joinpoint.getsignature().getdeclaringtypename());
        log.setmethodname(joinpoint.getsignature().getname());
        log.setparameters(arrays.tostring(joinpoint.getargs()));
        log.settimestamp(new date()); // 设置日志时间
    }

    /**
     * 记录方法调用后的日志信息。
     *
     * @param joinpoint 连接点对象，包含方法的调用信息。
     * @param result 方法执行结果。
     * @param log 日志对象，用于存储日志信息。
     */
    private void logafter(proceedingjoinpoint joinpoint, object result, log log) {
        log.setmessage(log.getmessage() + result);
    }

    /**
     * 记录方法执行过程中的异常信息。
     *
     * @param joinpoint 连接点对象，包含方法的调用信息。
     * @param e 捕获的异常对象。
     * @param log 日志对象，用于存储日志信息。
     */
    private void logexception(proceedingjoinpoint joinpoint, exception e, log log) {
        log.setexception(e.tostring());
        log.setmessage(log.getmessage() + " 异常信息：" + e.getmessage());
    }

    /**
     * 获取当前用户id。
     *
     * @return 用户id。
     */
    private long getuserid() {
        return tokenservice.getuserid();
    }
}