@Auto-Annotation自定义注解——日志记录篇

已于 2023-07-09 00:20:33 修改
阅读量229 收藏
点赞数
分类专栏： 自定义注解集 文章标签： 开发语言 java spring boot spring cloud
于 2023-07-09 00:18:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45019350/article/details/131596845
版权

@Auto-Annotation自定义注解——日志记录篇

自定义通用注解连更系列—连载中…

首页介绍：点这里

前言

​ 平时开发中，我们经常需要通过日志或者数据库来记录系统中一些重要的操作，如删除、修改和新增等。但每次在这些方法里手动打印日志或者记录到数据库太过繁琐，并且在代码中看到好多日志打印语句一点都不优雅。

​ 通过自定义注解统一收集日志的方式来实现，则不需要在代码中考虑日志打印的问题，只需要在接口上打一个注解即可。

所需依赖

spring-boot-starter-web中关联了spring-expression表达式，可直接引用

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
</dependency>
<dependency>
	<groupId>cn.hutool</groupId>
  <artifactId>hutool-all</artifactId>
  <version>5.8.10</version>
</dependency>

操作日志注解集@OperateLogs

​ 考虑到操作日志会存在需要打印多个的情况，所以我采用注解集的方式，支持在接口上打印多个相同注解。

并且支持在注解参数中配置SPEL表达式，动态提取接口参数中的数据。

/** 操作日志注解集
 * @Author： 清峰
 * @Description： May there be no bug in the world！
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OperateLogs {

    OperateLog[] value();
}


/** 操作日志注解
 * @Author： 清峰
 * @Description： May there be no bug in the world！
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(OperateLogs.class)
public @interface OperateLog {

    /**
     * 业务id
     */
    String bid();
    /**
     * 日志标签
     */
    String tag();
    /**
     * 操作类型
     */
    OperateTypeEnum operateType();
    /**
     * 日志消息
     */
    String message() default "";
    /**
     * 操作人员
     */
    String operatorId() default "";
    /**
     * 是否记录结果值
     */
    boolean recordResult() default false;
    /**
     * 结果值
     */
    String result() default "";
    /**
     * 是否在方法执行后记录（默认方法执行前记录）
     */
    boolean after() default false;

}

操作日志DTO数据传输对象

/** 操作日志DTO类
 * @Author： 清峰
 * @Description： May there be no bug in the world！
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OperateLogDTO {

    /**
     * 业务id
     */
    private String bid;
    /**
     * 操作类型
     */
    private OperateTypeEnum operateType;
    /**
     * 日志消息
     */
    private String message;
    /**
     * 日志标签
     */
    private String tag;
    /**
     * 操作人员
     */
    private String operatorId;
    /**
     * 是否记录结果值
     */
    private Boolean recordResult;
    /**
     * 结果值
     */
    private String result;
    /**
     * 执行是否成功
     */
    private Boolean success = Boolean.FALSE;

    /**
     * 异常信息
     */
    private String exception;
}

日志记录切面类

​ 日志收集的核心在于这个环绕通知的切面类，该通知类主要逻辑在于方法执行前后各自通过SPEL表达式对参数进行解析，获取参数数据，收集起来统一处理。

​ 这里重点强调一个上下文的概念，当参数发生改变，响应信息并为输出时，提供了一个OperateLogContext.setContext("参数名", “参数值”);的方法可在代码中手动赋值参数到上下文对象，这样在方法执行完后便可获取到最新的参数数据。

/** 应用上下文对象
 * @Author： 清峰
 * @Description： May there be no bug in the world！
 */
public class OperateLogContext {

    private static final ThreadLocal<StandardEvaluationContext> THREAD_LOCAL = new NamedThreadLocal<>("ThreadLocal-StandardEvaluationContext");

    public static final String RESULT = "result";

    public static StandardEvaluationContext getContext() {
        return THREAD_LOCAL.get() == null ? new StandardEvaluationContext() : THREAD_LOCAL.get();
    }

    public static void setContext(String key, Object value) {
        StandardEvaluationContext context = getContext();
        context.setVariable(key, value);
        THREAD_LOCAL.set(context);
    }

    public static ThreadLocal<StandardEvaluationContext> getThreadLocal() {
        return THREAD_LOCAL;
    }

    public static void clearContext() {
        THREAD_LOCAL.remove();
    }
}

/**
 * @Author： 清峰
 * @Description： May there be no bug in the world！
 */
@Slf4j
@Aspect
@Configuration
public class OperateLogAspect {

    private final SpelExpressionParser parser = new SpelExpressionParser();

    @Resource
    private IOperateLogOutput operateLogOutput;

    @Around("@annotation(cn.auto.annotation.OperateLogs) || @annotation(cn.auto.annotation.OperateLog)")
    public Object around(ProceedingJoinPoint jp) throws Throwable {
        List<OperateLogDTO> operateLogList = new ArrayList<>();
        Object result;
        OperateLog[] annotations;
        MethodSignature signature = (MethodSignature) jp.getSignature();
        Method method = signature.getMethod();
        try {
            //拦截注解
            annotations = method.getAnnotationsByType(OperateLog.class);

            //方法执行前解析参数
            annotationResoleExpression(Boolean.FALSE, jp, operateLogList, null, annotations, signature);

            //方法执行
            result = jp.proceed();

            //方法执行后解析参数
            annotationResoleExpression(Boolean.TRUE, jp, operateLogList, result, annotations, signature);

        } catch (Throwable throwable) {
            //捕获到jp.proceed()方法执行异常，补齐记录方法执行后日志信息（方法未成功执行，后置日志可不收集）
//            annotationResoleExpression(jp, operateLogList, result, annotations, signature);

            operateLogList.forEach(x -> x.setException(throwable.getMessage()));

            throw new ServerException("方法执行异常", throwable);

        } finally {
            //输出记录日志信息
            operateLogOutput.outPut(operateLogList);
        }
        return result;
    }


    private void annotationResoleExpression(Boolean isAfter, ProceedingJoinPoint jp, List<OperateLogDTO> operateLogList,
                                            Object result, OperateLog[] annotations, MethodSignature signature) {
        String errorStr = "初始化方法执行前后异常内容";
        try {
            for (OperateLog annotation : annotations) {
                if (Boolean.FALSE.equals(isAfter) && !annotation.after()) {
                    errorStr = "方法执行前解析参数异常";
                } else if (Boolean.TRUE.equals(isAfter) && annotation.after()) {
                    errorStr = "方法执行后解析参数异常";
                } else {
                    continue;
                }
                setLogContextParam(jp, signature, result);
                OperateLogDTO operateLogDTO = resoleExpression(annotation);
                operateLogList.add(operateLogDTO);
            }
        } catch (Exception e) {
            log.error(errorStr, e);
        }
    }


    private void setLogContextParam(ProceedingJoinPoint jp, MethodSignature signature, Object result) {
        //插入入参
        String[] parameterNames = signature.getParameterNames();
        Object[] args = jp.getArgs();
        for (int i = 0; i < parameterNames.length; i++) {
            OperateLogContext.setContext(parameterNames[i], args[i]);
        }
        //插入结果
        if (!ObjectUtils.isEmpty(result)) {
            OperateLogContext.setContext(OperateLogContext.RESULT, result);
        }
    }

    private OperateLogDTO resoleExpression(OperateLog annotation) {
        StandardEvaluationContext context = OperateLogContext.getContext();
        OperateLogDTO operateLogDTO = OperateLogDTO.builder().build();
        //解析注解el
        String bid = annotation.bid();
        if (StringUtils.hasText(bid)) {
            Expression expression = parser.parseExpression(bid);
            String bidValue = expression.getValue(context, String.class);
            operateLogDTO.setBid(bidValue);
        }

        operateLogDTO.setOperateType(annotation.operateType());

        String message = annotation.message();
        if (StringUtils.hasText(message)) {
            Expression expression = parser.parseExpression(message);
            String messageValue = expression.getValue(context, String.class);
            operateLogDTO.setMessage(messageValue);
        }

        String tag = annotation.tag();
        if (StringUtils.hasText(tag)) {
            Expression expression = parser.parseExpression(tag);
            String tagValue = expression.getValue(context, String.class);
            operateLogDTO.setTag(tagValue);
        }

        String operatorId = annotation.operatorId();
        if (StringUtils.hasText(operatorId)) {
            Expression expression = parser.parseExpression(operatorId);
            String operatorIdValue = expression.getValue(context, String.class);
            operateLogDTO.setOperatorId(operatorIdValue);
        }

        if (annotation.recordResult()) {
            operateLogDTO.setRecordResult(Boolean.TRUE);
            Object resultValue = context.lookupVariable(OperateLogContext.RESULT);
            operateLogDTO.setResult(JSON.toJSONString(resultValue));
        }
        operateLogDTO.setSuccess(Boolean.TRUE);
        //清理上下文
        OperateLogContext.clearContext();

        return operateLogDTO;
    }
}

日志输出接口

​ 最终收集到的日志信息可以统一发送给日志输出接口，进行存储或清洗处理

/** 日志输出接口
 * @Author： 清峰
 * @Description： May there be no bug in the world！
 */
public interface IOperateLogOutput {

    /**
     * 输出日志信息
     * @param operateLogDTOList 日志集
     */
    void outPut(List<OperateLogDTO> operateLogDTOList);
}

默认提供一个输出操作日志实现类

  • 如想自定义一个输出操作日志实现类，请实现IOperateLogOutput接口，并在类上加上该注解@Primary
  • 使用 @Primary 注解：在后一个新写的实现类上添加 @Primary 注解，使其成为首选的实现类。
/**
 * 默认输出操作日志实现类
 * @Author： 清峰
 * @Description： May there be no bug in the world！
 */
@Component
public class OperateLogOutputAction implements IOperateLogOutput{

    @Override
    public void outPut(List<OperateLogDTO> operateLogDTOList) {
        // 自定义输出操作日志实现逻辑...
    }
}

标记日志记录接口

    @OperateLogs({
            @OperateLog(bid = "#user.id",tag = "保存用户信息逻辑",operateType = OperateTypeEnum.UPDATE,message = "'保存用户信息前，名称为：'+#user.name"),
            @OperateLog(bid = "#user.id",tag = "保存用户信息逻辑",operateType = OperateTypeEnum.UPDATE,message = "'保存用户信息前，年龄为：'+#user.age",recordResult = true,after = true)
    })
    @PostMapping("saveUser")
    private void saveUser(User user){
        System.out.println("保存用户信息逻辑...");
    }

总结

​ 通过自定义日志注解的方式，可以通过很优雅的方式对日志信息进行统一收集处理，便捷了开发者的编码效率，同时也可以很方便的统计接口调用情况，异常情况，数据更改情况等。

〆清峰ㄟ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自定义日志注解（可获取方法名、参数等）
mail_liuxing的专栏
11-11 3327
自定义注解记录日志，可以获取方法名、参数名、参数值等；
java之数据映射框架
12-09
在日常的开发工作中，我们经常面临着繁琐的数据组装任务：根据一个对象的某个属性值，获取相关联的数据，并将其映射到另一个对象的属性中。这种需求经常涉及到字典项、配置项、枚举常量，甚至需要进行关联数据库表的查询。这样的数据填充任务往往耗费大量时间和精力，而且容易产生重复的样板代码，让人感到心烦。 crane4j 旨在为了解决这种烦恼而生，它是一套注解驱动的数据填充框架。通过简单的注解配置，crane4j 可以优雅高效地完成不同数据源、不同类型、不同命名的字段填充任务，让你专注于核心业务逻辑而不再被繁琐的数据组装工作所困扰
springboot 自定义注解 ，aop切面@Around； 为接口实现日志插入【强行喂饭版】
北海_南风
07-26 2577
思路：aop切面使用`@Around`来控制目标方法的执行。 既然是日志表的话，那么需要 `获取方法（接口）的参数`，`方法名`，`方法执行结果`，`方法执行时间`，`调用者的ip`，根据ip地址查询位置信息
自定义日志注解
灼烧的疯狂
03-11 1382
AOP日志的使用、自定义日志注解
自定义注解实现日志操作
newstudent_的博客
10-14 1272
aop实现操作日志，并利用事件监听实现异步操作日志，保存到数据库
Java注解Annotation与自定义注解详解
08-27
Java注解Annotation与自定义注解详解 Java注解（Annotation）是一种元数据，提供了关于程序元素（如类、方法、字段等）的补充信息，能够被Java虚拟机（JVM）和其他Java工具读取。Java注解可以分为两类：预定义注解...
自定义注解annotation及用法
01-03
例如，定义一个简单的日志注解： ```java public @interface Loggable { String value() default ""; } ``` 在这个例子中，`value`是注解的一个元素，它默认为空字符串。 ### 2. 注解元素的类型 注解元素的类型...
基于Java注解(Annotation)的自定义注解入门介绍
09-05
在Java编程中，注解(Annotation)是一种强大的工具，它允许程序员向源代码中添加元数据，这些元数据可以被编译器或运行时环境用于各种目的，如代码分析、验证、生成代码等。自定义注解是Java注解机制的一个重要方面，...
aixos-ts-encapsulation_自定义注解_
10-03
而在JavaScript的世界，特别是TypeScript中，自定义注解（Custom Annotation）也有类似的用途，虽然其机制和Java有所不同。 标题"aixos-ts-encapsulation_自定义注解_"可能指的是一个TypeScript项目，该项目专注于...
php-annotation:注解PHP
03-22
在PHP世界中，注解（Annotation）是一种元编程机制，它允许程序员在代码中嵌入特殊格式的注释，这些注释可以被解析器、IDE或其他工具读取，以实现额外的功能或提供编译时的元数据。"php-annotation"项目就是这样一个...
springboot 自定义注解+Aop切面实现收集日志与统计耗时1
健康平安的活着的专栏
07-19 531
通过自定义注解和AOP的组合使用，可以实现一些通用能力的抽象 ，可以实现登录权限拦截、日志收集、方法统计耗时等。避免在每个方法都写一份同样的功能，代码的重复冗余。 使用AOP同时结合自定义注解实现接口的切面编程，在需要进行通用逻辑处理的接口或者类中增加对应的注解即可。
JAVA自定义注解记录操作日志
m0_52767002的博客
10-12 2100
JAVA自定义注解记录操作日志
SpringBoot+AOP+自定义注解，优雅实现日志记录
热门推荐
小学生波波
12-21 1万+
AOP切面编程+自定义注解，优雅记录系统日志
注释自动切换中文，编码自动切换英文的插件
baidu_36682406的博客
09-26 540
而且，他会智能判断你当前可能需要切换的输入法；例如，你在写返回汉字的时候，中途插入文字，他也会给你自动判断切换。有没有一款在IDE编码时，注释的时候能自动切换中文，编写代码的时候自动切换英文的插件呢？设置输入法（如果你用的就是微软自带输入法，那没事了，重启IDE就可以使用啦）第一步：Setting(设置)--Plugins(插件)找到已经安装的插件。选择好你自己的输入法之后，重启IDE就可以使用啦。当你编码的时候自动切换到英文，不用自己手动切换拉。当你注释的时候，自动切换到中文输入法。
SpringBoot自定义注解实现接口日志记录
最新发布
Clozzz的博客
03-29 558
springboot aop注解实现项目日志记录
SpringBoot实战（六）自定义注解 + AOP 记录接口访问日志
ACGkaka的博客
04-01 3356
目录一、AOP的简单介绍1. AOP是什么2. AOP能做什么3. 切面执行顺序4. AOP注解二、实战代码1. 依赖引入2. AOP示例3. 定义接口，进行测试4. 源码地址 一、AOP的简单介绍 1. AOP是什么 AOP（Aspect Oriented Programming）–面向切面编程 通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。 实现方式：JDK动态代理、CGLIB代理。前者基于接口，后者基于子类。 2. AOP能做什么 统计接口
学习笔记（五）：自定义日志注解
qq_49111986的博客
05-16 344
自定义注解
Java小程序开发实例！docker和tomcat的区别
m0_57285455的博客
07-23 528
第1部分：基础篇 第2部分：开发篇 第3部分：优化篇 第4部分：管理维护篇 感受： 其实我投简历的时候，都不太敢投递阿里。因为在阿里一面前已经过了字节的三次面试，投阿里的简历一直没被捞，所以以为简历就挂了。 特别感谢一面的面试官捞了我，给了我机会，同时也认可我的努力和态度。对比我的面经和其他大佬的面经，自己真的是运气好。别人8成实力，我可能8成运气。所以对我而言，我要继续加倍努力，弥补自己技术上的不足，以及与科班大佬们基础上的差距。希望自己能继续保持学习的热情，继续努力走下去。 也祝愿各位
SpringBoot自定义注解实现操作日志（适用于毕设）
lslxgg的博客
02-10 2297
在目录中，有一个annotation文件夹，这里面放的就是日志的注解。String value() default "未命名日志";在aop文件夹中，存放改注解的切面@Aspect@Order@Component//这里操作人姓名暂时设置未知，具体操作的人，需要通过其他方法获取，这里仅对日志以及自定义注解的使用做简单介绍。String userName = "未知";// 异步记录日志。
java annotation自定义注解
10-12
Java中的注解是一种元数据，它提供了关于程序代码的额外信息。Java中有许多内置的注解，例如@Override和@Deprecated。除此之外，我们还可以自定义注解。 自定义注解需要使用@interface关键字，它类似于定义一个接口。注解可以包含元素，这些元素可以在使用注解时进行设置。下面是一个自定义注解的示例： ``` public @interface MyAnnotation { String value(); } ``` 在上面的示例中，我们定义了一个名为MyAnnotation的注解，并且它包含一个名为value的元素。我们可以在使用注解时设置这个元素的值。 下面是一个使用自定义注解的示例： ``` @MyAnnotation(value = "Hello World") public class MyClass { // ... } ``` 在上面的示例中，我们使用了我们刚刚定义的MyAnnotation注解，并且设置了它的value元素的值为"Hello World"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值