实现自定义注解存储操作日志功能

最新推荐文章于 2024-08-06 03:31:12 发布
最新推荐文章于 2024-08-06 03:31:12 发布
阅读量419 收藏 1
点赞数 1
文章标签： java spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45411101/article/details/120761090
版权

自定义注解 日志记录 异常处理 环绕通知 AOP
关键词由CSDN通过智能技术生成

1.自定义注解

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

/**
 * @author LWL
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {

    String value() default "";

    int type() default 0;
}

package com.guangyi.project.entity.system_set;

import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Id;
import java.io.Serializable;
import java.util.Date;


/**
 * {@code 功能描述 Log实体}
 * @author LWL
 * @since 2021-07-06 14:12:15
 * @version 1.0
 */
@Data
@NoArgsConstructor
public class Log implements Serializable {
	private static final long serialVersionUID = 1L;
	
	/**
	 * {@code 功能描述: id}
	 */
		@Id
		private Long id;
	/**
	 * {@code 功能描述: 用户id}
	 */
		private Long userId;
	/**
	 * {@code 功能描述: 描述}
	 */
		private String description;
	/**
	 * {@code 功能描述: 异常详细}
	 */
		private String exceptionDetail;
	/**
	 * {@code 功能描述: 日志类型}
	 */
		private String logType;
	/**
	 * {@code 功能描述: 方法名}
	 */
		private String method;
	/**
	 * {@code 功能描述: 参数}
	 */
		private String params;
	/**
	 * {@code 功能描述: 请求ip}
	 */
		private String requestIp;
	/**
	 * {@code 功能描述: 请求耗时}
	 */
		private Long time;
	/**
	 * {@code 功能描述: 用户名}
	 */
		private String username;
	/**
	 * {@code 功能描述: 地址}
	 */
		private String address;
	/**
	 * {@code 功能描述: 浏览器}
	 */
		private String browser;
	/**
	 * {@code 功能描述: }
	 */
		private Integer type;
	/**
	 * {@code 功能描述: 是否删除}
	 */
		private Integer isDel;
	/**
	 * {@code 功能描述: }
	 */
		private Date createdate;
	/**
	 * {@code 功能描述: }
	 */
		private String createuser;
	/**
	 * {@code 功能描述: }
	 */
		private Date changedate;
	/**
	 * {@code 功能描述: }
	 */
		private String changeuser;

	public Log(String logType, Long time) {
		this.logType = logType;
		this.time = time;
	}
}

2.配置环绕通知和异常通知

package com.guangyi.project.aspect;

import com.guangyi.project.entity.system_set.Log;
import com.guangyi.project.security.SecurityUserDetails;
import com.guangyi.project.service.LogService;
import com.guangyi.project.utils.RequestHolder;
import com.guangyi.project.utils.StringUtils;
import com.guangyi.project.utils.ThrowableUtil;
import com.guangyi.project.utils.UserUtil;
import eu.bitwalker.useragentutils.Browser;
import eu.bitwalker.useragentutils.UserAgent;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

/**
 * @author LWL
 */
@Component
@Aspect
@Slf4j
public class LogAspect {

    @Autowired
    private LogService logService;

    ThreadLocal<Long> currentTime = new ThreadLocal<>();

    /**
     * 配置切入点
     */
    @Pointcut("@annotation(com.guangyi.project.config.Log)")
    public void logPointcut() {
        // 该方法无方法体,主要为了让同类中其他方法使用此切入点
    }

    /**
     * 配置环绕通知,使用在方法logPointcut()上注册的切入点
     *
     * @param joinPoint join point for advice
     */
    @Around("logPointcut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        Object result;
        currentTime.set(System.currentTimeMillis());
        result = joinPoint.proceed();
        Log log = new Log("INFO", System.currentTimeMillis() - currentTime.get());
        currentTime.remove();
        HttpServletRequest request = RequestHolder.getHttpServletRequest();
        //获取当前登录用户信息
        SecurityUserDetails loginUser = UserUtil.getLoginUser(request);
        //获取浏览器信息
        String ua = request.getHeader("User-Agent");
        //转成UserAgent对象
        UserAgent userAgent = UserAgent.parseUserAgentString(ua);
        //获取浏览器信息
        Browser browser = userAgent.getBrowser();
        //浏览器名称
        String browserName = browser.getName();
        log.setBrowser(browserName);
        logService.save(loginUser.getUsername(),
                StringUtils.getIp(request), joinPoint,
                log, loginUser.getId());
        return result;
    }

    /**
     * 配置异常通知
     *
     * @param joinPoint join point for advice
     * @param e exception
     */
    @AfterThrowing(pointcut = "logPointcut()", throwing = "e")
    public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
        Log log = new Log("ERROR", System.currentTimeMillis() - currentTime.get());
        currentTime.remove();
        log.setExceptionDetail(ThrowableUtil.getStackTrace(e));
        HttpServletRequest request = RequestHolder.getHttpServletRequest();
        SecurityUserDetails loginUser = UserUtil.getLoginUser(request);
        //获取浏览器信息
        String ua = request.getHeader("User-Agent");
        //转成UserAgent对象
        UserAgent userAgent = UserAgent.parseUserAgentString(ua);
        //获取浏览器信息
        Browser browser = userAgent.getBrowser();
        //浏览器名称
        String browserName = browser.getName();
        log.setBrowser(browserName);
        logService.save(loginUser.getUsername(),
                StringUtils.getIp(request),
                (ProceedingJoinPoint) joinPoint, log, loginUser.getId());
    }
}

RequestHolder

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Objects;

/**
 * 获取 HttpServletRequest
 * @author LWL
 * @date 2018-11-24
 */
public class RequestHolder {

    public static HttpServletRequest getHttpServletRequest() {
        return ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
    }
}

import java.io.PrintWriter;
import java.io.StringWriter;

/**
 * 异常工具 2021-07-06
 * @author LWL
 */
public class ThrowableUtil {

    /**
     * 获取堆栈信息
     */
    public static String getStackTrace(Throwable throwable) {
        StringWriter sw = new StringWriter();
        try (PrintWriter pw = new PrintWriter(sw)) {
            throwable.printStackTrace(pw);
            return sw.toString();
        }
    }
}

3.service

package com.guangyi.project.service;

import com.guangyi.project.entity.system_set.Log;
import com.guangyi.project.model.system.MessageBean;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.scheduling.annotation.Async;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;

/**
 * {@code 功能描述: Log的service层}
 * @author LWL
 * @since 2021-07-02 11:35:38
 * @version 1.0
 */
public interface LogService {

    /**
     * 保存日志数据
     * @param username 用户
     * @param browser 浏览器
     * @param ip 请求IP
     * @param joinPoint /
     * @param log 日志实体
     */
    @Async
    void save(String username, String ip, ProceedingJoinPoint joinPoint, Log log, Long uid);
    /**
     * @description: 操作日志
     * @param httpServletRequest
     * @param map
     * @return: com.guangyi.project.model.system.MessageBean
     * @author: LWL
     * @time: 2021/7/6 16:25
     */
    MessageBean operateLog(HttpServletRequest httpServletRequest, Map<String, Object> map);
}

package com.guangyi.project.service.impl;

import cn.hutool.json.JSONObject;
import com.guangyi.project.config.ErrorEnum;
import com.guangyi.project.entity.system_set.Admin;
import com.guangyi.project.entity.system_set.Log;
import com.guangyi.project.entity.user.Baseuser;
import com.guangyi.project.mapper.system_set.AdminMapper;
import com.guangyi.project.mapper.system_set.LogMapper;
import com.guangyi.project.mapper.user.BaseuserMapper;
import com.guangyi.project.model.querydo.LogDO;
import com.guangyi.project.model.system.MessageBean;
import com.guangyi.project.security.SecurityUserDetails;
import com.guangyi.project.service.LogService;
import com.guangyi.project.service.PkSequenceService;
import com.guangyi.project.utils.ErrorInfoUtil;
import com.guangyi.project.utils.ExceptionFormatUtil;
import com.guangyi.project.utils.StringUtils;
import com.guangyi.project.utils.UserUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Service
public class LogServiceImpl extends BaseService implements LogService {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Resource
    private LogMapper logMapper;
    @Resource
    private PkSequenceService pkSequenceService;
    @Resource
    private AdminMapper adminMapper;
    @Resource
    private BaseuserMapper baseuserMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void save(String username, String ip, ProceedingJoinPoint joinPoint, Log log, Long uid) {

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        com.guangyi.project.config.Log aopLog = method.getAnnotation(com.guangyi.project.config.Log.class);

        // 方法路径
        String methodName = joinPoint.getTarget().getClass().getName() + "." + signature.getName() + "()";

        StringBuilder params = new StringBuilder("{");
        //参数值
        Object[] argValues = joinPoint.getArgs();
        //参数名称
        String[] argNames = ((MethodSignature) joinPoint.getSignature()).getParameterNames();
        if (argValues != null && argValues.length>1) {
            for (int i = 1; i < argValues.length; i++) {
                params.append(" ").append(argNames[i]).append(": ").append(argValues[i]);
            }
        }else {
            params.append("无参数");
        }
        // 描述
        if (log != null) {
            log.setDescription(aopLog.value());
        }
        //类型 0-后台 1-APP
        log.setType(aopLog.type());
        if (uid != null) {
            log.setUserId(uid);
        }
        assert log != null;
        log.setRequestIp(ip);

        String loginPath = "login";
        if (loginPath.equals(signature.getName())) {
            try {
                assert argValues != null;
                username = new JSONObject(argValues[0]).get("username").toString();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        log.setAddress(StringUtils.getCityInfo(log.getRequestIp()));
        log.setMethod(methodName);
        log.setUsername(username);
        log.setParams(params.toString() + " }");
        Long maxId = pkSequenceService.getMaxIdByTableName("log");
        log.setId(maxId);
        log.setChangedate(new Date());
        log.setCreatedate(new Date());
        log.setChangeuser(username);
        log.setCreateuser(username);
        log.setIsDel(0);
        logMapper.save(log);
    }

    @Override
    public MessageBean operateLog(HttpServletRequest httpServletRequest, Map<String, Object> map) {
        MessageBean result = new MessageBean();
        SecurityUserDetails loginUser = UserUtil.getLoginUser(httpServletRequest);
        try {
            long count = logMapper.count(map);
            List<LogDO> list = logMapper.list(map);
            if (!CollectionUtils.isEmpty(list)){
                list.forEach(x->{
                    if (x.getType()==0){
                        Admin admin = adminMapper.selectByPrimaryKey(x.getUserId());
                        x.setRealName(admin.getRealName());
                        x.setUsername(admin.getMobile());
                    }else {
                        Baseuser baseuser = baseuserMapper.selectByPrimaryKey(x.getUserId());
                        x.setRealName(baseuser.getNickname());
                        x.setUsername(baseuser.getMobile());
                    }
                });
            }
            result.setData(list);
            result.setTotal(count);
            result.setToken(loginUser.getToken());
        }catch (Exception e){
            logger.error(ErrorInfoUtil.getErrorInfo(e));
            throw ExceptionFormatUtil.formatException(e, ErrorEnum.GETINFO_ERROR);
        }
        return result;
    }
}

4.在接口上使用定义的注解

在这里插入图片描述

5.表结构

在这里插入图片描述

CREATE TABLE `log` (
  `id` bigint(20) NOT NULL COMMENT 'id',
  `user_id` bigint(20) DEFAULT NULL COMMENT '用户id',
  `description` varchar(255) DEFAULT NULL COMMENT '描述',
  `exception_detail` text COMMENT '异常详细',
  `log_type` varchar(255) DEFAULT '' COMMENT '日志类型',
  `method` varchar(255) DEFAULT NULL COMMENT '方法名',
  `params` text COMMENT '参数',
  `request_ip` varchar(255) DEFAULT NULL COMMENT '请求ip',
  `time` bigint(20) DEFAULT NULL COMMENT '请求耗时',
  `username` varchar(255) DEFAULT NULL COMMENT '用户名',
  `address` varchar(255) DEFAULT NULL COMMENT '地址',
  `browser` varchar(255) DEFAULT NULL COMMENT '浏览器',
  `type` smallint(6) DEFAULT '0',
  `is_del` smallint(1) DEFAULT '0' COMMENT '是否删除',
  `createdate` datetime NOT NULL,
  `createuser` varchar(100) NOT NULL,
  `changedate` datetime NOT NULL,
  `changeuser` varchar(100) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

查看操作日志
在这里插入图片描述
查看异常日志
在这里插入图片描述
查看报错信息
在这里插入图片描述

李逍遙️
关注
自定义注解鉴权，保存日志（类上，方法上，属性上）
qq_45700984的博客
09-07 189
自定义注解的使用场景很多，我们在造轮子写框架的过程经常会使用到。在我们平时的项目场景中，也可以随处可以看到自定义注解可以发挥作用的场景，例如：​ 1）全局日志的打印​ 2）用户权限的校验​ 3）登录的校验​ 4）数据脱敏等等场景。元注解@Retention annotation指定标记注释的存储方式：RetentionPolicy.SOURCE - 标记的注释仅保留在源级别中，并由编译器忽略。
java 自定义注解实现某个功能
没伞的孩子努力奔跑
07-20 311
java 实现自定义注解实现某些功能
spring aop 自定义注解保存操作日志到mysql数据库 源码
11-25
一、适合人群 1、具备一定Java编程基础，初级开发者 2、对springboot，mybatis，mysql有基本认识 3、对spring aop认识模糊的，不清楚如何实现Java 自定义注解的 4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 （需要知道原理的请看spring aop源码，此处不做赘述） 3、可在现有源码上快速进行功能扩展 4、spring boot，mybatis，druid，spring aop的使用
自定义注解-aop实现日志记录
niceyoo的博客
05-22 810
自定义注解-aop实现日志记录 关于注解，平时接触的可不少，像是 @Controller、@Service、@Autowried 等等，不知道你是否有过这种疑惑，使用 @Service 注解的类成为我们的业务类，使用 @Controller 注解的类就成了请求的控制器，使用 @Autowried 注解的类就会帮我们实现自动注入… 以前，我们只...
自定义日志注解，保存信息到数据库
最新发布
weixin_33247358的博客
08-06 50
定义日志注解登录后复制 import java.lang.annotation.*; /** * @author wzw * @version 1.0 * @Date 2023-2-17 17:31:19 */ @Target({ElementType.METHOD}) @Retention(Retention...
自定义注解实现日志操作
newstudent_的博客
10-14 1321
aop实现操作日志，并利用事件监听实现异步操作日志，保存到数据库
自定义注解 实现用户操作日志
qq_29021049的博客
12-14 675
背景：最近做了一个关于中台to b的商品项目，原本下游各个系统的商品信息全部到我们项目中处理。其他下游没有入口对商品进行修改和新增。目前整个项目的用户基本有人要就给开了，这就出现一个非常大的隐患，如果某个人把商品误操作了，锅都找不到，还没法复原。因此记录操作商品有关的记录就显得很重要了。   方案：大概做法有两种：           1.首先很好想的就是在每个接口中，进行入库操作。实现很简...
自定义注解-操作日志记录
青春年少不知疼的博客
11-22 280
七、TestDemoLogServceImpl实现类。六、ITestDemoLogServce 接口。三、service接口。四、service实现。
自定义注解实现伪动态传参的小demo
09-13
自定义注解是扩展Java功能的强大工具，可以用于实现各种目的，如代码生成、编译时检查、运行时处理等。在这个“自定义注解实现伪动态传参的小demo”中，我们将探讨如何创建一个自定义注解，以允许在注解中传递类似于...
使用kafka进行自定义注解日志存储，日志存储使用的是influxDB数据库
11-22
本篇文章将详细讲解如何利用Kafka进行自定义注解的日志存储，并结合InfluxDB数据库实现高效且灵活的日志管理系统。 首先，让我们深入了解一下Kafka。Kafka是一个高吞吐量的分布式发布订阅消息系统，由LinkedIn开发...
SpringBoot 使用自定义注解（基于AOP） 实现操作日志管理
最近学习目标：MySQL，Redis
11-10 1924
操作日志的记录 因为我们不光要记录代码的运行，如（logback log4j），而且还应该记录用户的行为（Controller 请求日志），这叫做业务运行日志。 业务运行日志的作用 记录用户的行为 用于后续的分析 记录用户的所有的操作 日志实现的思路 1.我们需要记录哪些数据（谁在什么时间干了什么事情，结果如何）？ 数据要存入到哪里（存储到数据库表，推送到指定日志存储服务，打印到日志文件等）？ 2.在项目中什么位置记录（一般在Controller请求，进行around 环绕增强） 如何实现记录
SpringMVC利用AOP实现自定义注解记录日志
10-14
SpringMVC利用AOP实现自定义注解记录日志
自定义注解+Spring AOP实现记录用户操作日志-附件资源
03-02
自定义注解+Spring AOP实现记录用户操作日志-附件资源
自定义注解，记录操作日志
04-18 171
Spring的配置文件 <aop:aspectj-autoproxy /> 日志拦截器 package com.vem.interceptor; import org.aspectj.lang.ProceedingJoinPoint; import org.aspect...
自定义注解实现操作日志记录
w1028556865的博客
04-13 570
自定义注解实现操作日志记录 通过环绕通知，记录操作记录以及返回结果 代码如下： OpLog.java package com.snail.redisMemory.annotaion; import com.snail.redisMemory.operation.OpType; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.Retenti
自定义注解之用户操作日志记录
回忆的证据
12-21 569
简介 我在使用spring完成项目的时候需要完成记录日志，我开始以为Spring 的AOP功能，就可以轻松解决，半个小时都不用，可是经过一番了解过后，发现一般的日志记录，只能记录一些简单的操作，例如表名、表名称等记录不到。 这个时侯就用到了自定义注解，把想要记录的内容放在注解中，通过切入点来获取到注解参数，然后将参数插入数据库记录。 |Spring AOP 对于Spring Aop的基本介绍大家可以看看： https://blog.csdn.net/yjt520557/article/deta.
JAVA自定义注解记录操作日志
m0_52767002的博客
10-12 2687
JAVA自定义注解记录操作日志
【功能】自定义记录日志注解
ruisasaki的博客
03-16 215
【功能】自定义记录日志注解。
Spring AOP自定义注解日志管理实战教程
本文档主要介绍了如何使用Spring AOP (Aspect Oriented Programming) 自定义注解的方式来实现日志管理的实例。在Spring框架中，AOP提供了一种面向切面编程的解决方案，使得我们可以将关注点（如日志记录）与业务逻辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值