Spring AOP实现接口请求记录到数据库的示例代码

更新时间：2022年09月26日 14:37:45 作者：AboutChristopher

这篇文章主要介绍了Spring AOP实现接口请求记录到数据库,代码包括引入AOP依赖及创建日志记录表，代码简单易懂，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

1.引入AOP依赖

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

2.创建日志记录表

DROP TABLE IF EXISTS `rule_operate_log`;
CREATE TABLE `rule_operate_log`  (
    id INT(11) NOT NULL AUTO_INCREMENT COMMENT '日志id',
    path VARCHAR(4000) NULL DEFAULT NULL COMMENT '接口地址',
    http_method VARCHAR(32) NULL DEFAULT NULL COMMENT '请求方法',
    status_code VARCHAR(32) NULL DEFAULT NULL COMMENT '请求返回状态码',
    create_time_char VARCHAR(32) NULL DEFAULT NULL COMMENT '日志时间',
    create_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '日志时间戳',
    ip varchar(200) NULL DEFAULT NULL COMMENT '请求ip',
    params mediumtext NULL COMMENT '请求参数',
    result mediumtext NULL COMMENT '返回值',
    exception mediumtext NULL COMMENT '接口异常',
    user_id VARCHAR(32) NULL DEFAULT NULL COMMENT '操作用户',
    user_account VARCHAR(32) NULL DEFAULT NULL COMMENT '操作用户账号',
    user_name VARCHAR(200) NULL DEFAULT NULL COMMENT '操作用户名称',
    user_org_id VARCHAR(32) NULL DEFAULT NULL COMMENT '操作用户机构id',
    user_org_name VARCHAR(200) NULL DEFAULT NULL COMMENT '操作用户机构名称',
    operate_name VARCHAR(200) NULL DEFAULT NULL COMMENT '操作名称',
    operate_position VARCHAR(200) NULL DEFAULT NULL COMMENT '操作位置',
    log_type VARCHAR(32) NULL DEFAULT NULL COMMENT '日志类型 error：错误日志 operate：操作日志',
    category_id VARCHAR(32) NULL DEFAULT NULL COMMENT '分类机构id',
    cost INT(11) NULL DEFAULT NULL COMMENT '接口耗时',
    PRIMARY KEY (id)
) COMMENT = '操作日志表';

3.日志实体类

import java.util.Date;

public class RuleOperateLog {
    /**
     * id
     */
    private Integer id;
    /**
     * 接口地址
     */
    private String path;
    /**
     * 请求方法
     */
    private String httpMethod;
    /**
     * 请求返回状态码
     */
    private String statusCode;
    /**
     * 日志时间
     */
    private String createTimeChar;
    /**
     * 日志时间戳
     */
    private Date createTime;
    /**
     * 请求ip
     */
    private String ip;
    /**
     * 请求参数
     */
    private String params;
    /**
     * 返回值
     */
    private String result;
    /**
     * 接口异常
     */
    private String exception;
    /**
     * 操作用户
     */
    private String userId;
    /**
     * 操作用户账号
     */
    private String userAccount;
    /**
     * 操作用户名称
     */
    private String userName;
    /**
     * 操作用户机构
     */
    private String userOrgId;
    /**
     * 操作用户机构名称
     */
    private String userOrgName;
    /**
     * 操作名称
     */
    private String operateName;
    /**
     * 操作位置
     */
    private String operatePosition;
    /**
     * 日志类型
     */
    private String logType;
    /**
     * 分类机构id
     */
    private String categoryId;
    /**
     * 请求耗时
     */
    private Integer cost;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public String getHttpMethod() {
        return httpMethod;
    }

    public void setHttpMethod(String httpMethod) {
        this.httpMethod = httpMethod;
    }

    public String getStatusCode() {
        return statusCode;
    }

    public void setStatusCode(String statusCode) {
        this.statusCode = statusCode;
    }

    public String getCreateTimeChar() {
        return createTimeChar;
    }

    public void setCreateTimeChar(String createTimeChar) {
        this.createTimeChar = createTimeChar;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public String getParams() {
        return params;
    }

    public void setParams(String params) {
        this.params = params;
    }

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    public String getException() {
        return exception;
    }

    public void setException(String exception) {
        this.exception = exception;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUserAccount() {
        return userAccount;
    }

    public void setUserAccount(String userAccount) {
        this.userAccount = userAccount;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserOrgId() {
        return userOrgId;
    }

    public void setUserOrgId(String userOrgId) {
        this.userOrgId = userOrgId;
    }

    public String getUserOrgName() {
        return userOrgName;
    }

    public void setUserOrgName(String userOrgName) {
        this.userOrgName = userOrgName;
    }

    public String getOperateName() {
        return operateName;
    }

    public void setOperateName(String operateName) {
        this.operateName = operateName;
    }

    public String getOperatePosition() {
        return operatePosition;
    }

    public void setOperatePosition(String operatePosition) {
        this.operatePosition = operatePosition;
    }

    public String getLogType() {
        return logType;
    }

    public void setLogType(String logType) {
        this.logType = logType;
    }

    public String getCategoryId() {
        return categoryId;
    }

    public void setCategoryId(String categoryId) {
        this.categoryId = categoryId;
    }

    public Integer getCost() {
        return cost;
    }

    public void setCost(Integer cost) {
        this.cost = cost;
    }
}

4.Dao+Mapper+service

import com.xxx.xxx.xxx.entity.RuleOperateLog;

/**
 * 操作日志(RuleOperateLog)表数据库访问层
 *
 * @author hx
 * @since 2022-08-23
 */
public interface RuleOperateLogDao {

    /**
     * 新增数据
     *
     * @param operateLog
     * @return
     */
    int insert(RuleOperateLog operateLog);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xxx.xxx.xxx.dao.RuleOperateLogDao">

    <resultMap type="com.xxx.xxx.xxx.entity.RuleOperateLog" id="RuleOperateLogMap">
        <result property="id" column="id" jdbcType="INTEGER"/>
        <result property="path" column="path" jdbcType="VARCHAR"/>
        <result property="httpMethod" column="http_method" jdbcType="VARCHAR"/>
        <result property="statusCode" column="status_code" jdbcType="VARCHAR"/>
        <result property="createTimeChar" column="create_time_char" jdbcType="VARCHAR"/>
        <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
        <result property="ip" column="ip" jdbcType="VARCHAR"/>
        <result property="params" column="params" jdbcType="VARCHAR"/>
        <result property="result" column="result" jdbcType="VARCHAR"/>
        <result property="exception" column="exception" jdbcType="VARCHAR"/>
        <result property="userId" column="user_id" jdbcType="VARCHAR"/>
        <result property="userAccount" column="user_account" jdbcType="VARCHAR"/>
        <result property="userName" column="user_name" jdbcType="VARCHAR"/>
        <result property="userOrgId" column="user_org_id" jdbcType="VARCHAR"/>
        <result property="userOrgName" column="user_org_name" jdbcType="VARCHAR"/>
        <result property="operateName" column="operate_name" jdbcType="VARCHAR"/>
        <result property="operatePosition" column="operate_position" jdbcType="VARCHAR"/>
        <result property="logType" column="log_type" jdbcType="VARCHAR"/>
        <result property="categoryId" column="category_id" jdbcType="VARCHAR"/>
        <result property="cost" column="cost" jdbcType="INTEGER"/>
    </resultMap>

    <insert id="insert" keyProperty="id" useGeneratedKeys="true">
        insert into rule_operate_log (id, path, http_method, status_code, create_time_char, create_time,
                                      ip, params, result, exception, user_id, user_account, user_name, user_org_id,
                                      user_org_name, operate_name, operate_position, log_type, category_id, cost)
        values (#{id}, #{path}, #{httpMethod}, #{statusCode}, #{createTimeChar}, #{createTime}, #{ip}, #{params}, #{result},
                #{exception},#{userId}, #{userAccount}, #{userName}, #{userOrgId}, #{userOrgName}, #{operateName}, #{operatePosition},
                #{logType}, #{categoryId}, #{cost})
    </insert>

</mapper>

import com.xxx.xxx.xxx.entity.RuleOperateLog;

/**
 * 操作日志(RuleOperateLog)表服务接口
 *
 * @author hx
 * @since 2022-08-23
 */
public interface RuleOperateLogService {

    /**
     * 保存日志
     *
     * @param ruleOperateLog
     * @return
     */
    void saveLog(RuleOperateLog ruleOperateLog);

}

import com.xxx.xxx.xxx.dao.RuleOperateLogDao;
import com.xxx.xxx.xxx.entity.RuleOperateLog;
import com.xxx.xxx.xxx.service.RuleOperateLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 操作日志(RuleOperateLog)表服务实现类
 *
 * @author hx
 * @since 2022-08-23
 */
@Service("RuleOperateLogService")
public class RuleOperateLogServiceImpl implements RuleOperateLogService {

    @Autowired
    private RuleOperateLogDao operateLogDao;

    @Override
    public void saveLog(RuleOperateLog ruleOperateLog) {
        operateLogDao.insert(ruleOperateLog);
    }
}

5.自定义注解

import java.lang.annotation.*;

@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface LogResource {
    /**
     * 服务名称
     * @return
     */
    String name();

    /**
     * 操作位置描述
     * @return
     */
    String position() default "";

    /**
     * 日志类型
     * @return
     */
    String logType() default "";
}

6.操作日志切面类

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.com.xxx.xxx.xxx.annotation.LogResource;
import com.com.xxx.xxx.xxx.constants.LogTypeConstants;
import com.com.xxx.xxx.xxx.entity.RuleOperateLog;
import com.com.xxx.xxx.xxx.service.RuleOperateLogService;
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.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 操作日志切面类
 *
 * @author hx
 * @since 2022-08-23
 */

@Aspect
@Component
public class OperateLogAspect {

    @Autowired
    private RuleOperateLogService operateLogService;

    //扫描使用@LogResource注解的方法
    @Pointcut("@annotation(com.com.xxx.xxx.xxx.annotation.LogResource)")
    public void logPointCut() { };

    @Around("logPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Date startTime = new Date();
        String exception = null;
        String result = null;
        try {
            Object obj = point.proceed();
            if (obj != null) {
                result = JSONObject.toJSONString(obj);
            }
            return obj;
        } catch (Exception e) {
            //请求时报错
            exception = e.toString();
            throw e;
        } finally {
            //操作和报错日志都记录
            HttpServletResponse response
                    = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
            int statusCode = response.getStatus();
            if (exception != null) {
                /** CHECKSTYLE:OFF:MagicNumber */
                statusCode = 500;
                /** CHECKSTYLE:ON:MagicNumber */
            }
            syncSaveLog(point, startTime, new Date(), exception, result, statusCode);
        }
    }

    @Async
    void syncSaveLog(ProceedingJoinPoint joinPoint, Date startTime, Date endTime,
                     String exception, String result, int statusCode) {
        RuleOperateLog log = new RuleOperateLog();
        try {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            LogResource annotation = method.getAnnotation(LogResource.class);
            if (annotation != null) {
                //注解上的描述
                log.setOperateName(annotation.name());
            }
            Date nowDate = new Date();
            log.setCreateTimeChar(new SimpleDateFormat("yyyyMMddhhmmss").format(nowDate));
            log.setCreateTime(nowDate);
            //入参
            if (joinPoint.getArgs() != null) {
                try {
                    log.setParams(JSONObject.toJSONString(joinPoint.getArgs(),
                            SerializerFeature.IgnoreNonFieldGetter));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            Long cost = endTime.getTime() - startTime.getTime();
            log.setCost(cost.intValue());
            HttpServletRequest request
                    = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            if (request != null) {
                log.setUserName(request.getHeader(HttpHeaders.USER_AGENT));
                log.setPath(request.getRequestURI());
                log.setHttpMethod(request.getMethod());
                log.setIp(request.getRemoteAddr());
            }
            log.setStatusCode(String.valueOf(statusCode));
            log.setResult(result);
            /** CHECKSTYLE:OFF:MagicNumber */
            if (statusCode > 400 && exception != null) {
                log.setException(exception);
                log.setLogType(LogTypeConstants.ERROR);
            } else {
                log.setLogType(LogTypeConstants.OPERATE);
            }
            /** CHECKSTYLE:ON:MagicNumber */
            operateLogService.saveLog(log);
        } catch (Exception e) {
            e.printStackTrace();
        }

/*        //启动一个线程，执行报错日志防止影响主请求
        new Thread() {
            @Override
            public void run() {
                try {
                    //保存到数据库
                    operLogMapper.insertOper(operLog);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }.start();*/
    }
}

7.使用

到此这篇关于Spring AOP实现接口请求记录到数据库的文章就介绍到这了,更多相关Spring AOP接口请求记录数据库内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

springboot结合mybatis-plus基于session模拟短信注册功能
本文主要介绍了springboot结合mybatis-plus基于session模拟短信注册功能，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-11-11
Java使用jxl包写Excel文件适合列宽实现
用jxl.jar包，读写过Excel文件。也没有注意最适合列宽的问题，但是jxl.jar没有提供最适合列宽的功能，上次用到写了一下，可以基本实现最适合列宽。
2013-11-11
SpringBoot通过ip获取归属地的几种方式分享
在日常我们逛网站的时候会发现我们登录后会出现归属地信息,例如：我在广州登录会显示广东广州,有些更加精确的会显示到区县,那么我们来看看有哪些方式来获取归属地信息,今天我们来聊一聊
2023-09-09
解决在Idea 2020.2下使用 Lombok的注解不生效的问题(插件安装了,依赖也写了,自动注解也设置了）
这篇文章主要介绍了在Idea 2020.2下使用 Lombok的注解不生效的问题(插件安装了,依赖也写了,自动注解也设置了）,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-08-08
JAVA防止重复提交Web表单的方法
这篇文章主要介绍了JAVA防止重复提交Web表单的方法,涉及Java针对表单的相关处理技巧,具有一定参考借鉴价值,需要的朋友可以参考下
2015-10-10
Java实现简单的学生教师管理系统
这篇文章主要为大家详细介绍了Java实现简单的学生教师管理系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-02-02
Java中锁的分类与使用方法
这篇文章主要给大家介绍了关于Java中锁分类与使用的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-04-04
Java通用BouncyCastle实现的DES3加密的方法
这篇文章主要介绍了Java通用BouncyCastle实现的DES3加密的方法,本文给大家介绍的非常详细，对大家的学习或工作，具有一定的参考借鉴价值，需要的朋友可以参考下
2020-12-12
java 线程池封装及拒绝策略示例详解
这篇文章主要为大家介绍了java 线程池封装及拒绝策略示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-12-12
解析Java的JVM以及类与对象的概念
这篇文章主要介绍了解析Java的JVM以及类与对象的概念,是Java入门学习中的基础知识,需要的朋友可以参考下
2015-09-09