Spring boot自定义注解方式实现日志记录

最新推荐文章于 2024-02-10 20:03:15 发布

weixin_33770878

最新推荐文章于 2024-02-10 20:03:15 发布

阅读量153

点赞数 1

文章标签： java runtime python

原文链接：https://my.oschina.net/lienson/blog/3029289

版权

2019独角兽企业重金招聘Python工程师标准>>>

Annontation是Java5开始引入的新特性，中文名称叫注解。

一、常见注解

1.1 JDK自带注解

@Override：表示覆盖或重写父类的方法。
@Deprecated：表示该方法已经过时了。
@suppressWarnings：表示忽略指定警告。

1.2 第三方注解

比如Spring

@Component：组件，没有明确的角色。
@Service 在业务逻辑层（service层）使用。
@Autowired 自动装配。

Spring、Mybatis使用了大量的注解，这些注解能够让人读懂别人写的代码，特别是框架相关的代码；同时让编程更加简洁，代码更加清晰；也让别人高看一眼。

既然自定义注解有这么多好处，那我们如何去自定义注解？什么时候用自定义注解？

二、自定义注解

2.1 使用场景

比如公司有个后台管理系统，每个接口都要去记录它的操作日志，如果按照以前的思维我们就每个接口里面去写相应的操作日志记录代码。这种方式肯定不好，这时我们想到了spring的aop。其实自定义注解的实现本质上是spring aop对自定义注解的支持。

那么在了解自定义注解之前，我们先了解下元注解，即注解的注解。

2.2 元注解

以Log.java为例：

@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {

    /**
     * 模块
     * @return
     */
    String title() default "";

    /**
     * 功能
     * @return
     */
    String action() default "";

}

使用@interface关键字定义注解。
成员以无参无异常方式声明，可以用default为成员指定一个默认值。
类上面的代码称之为元注解。

下面我们分别介绍下元注解：

@Target 是注解的作用域 ：表示该注解可以用于一个类中的那些属性及方法上，如果作用域类型有多个用英文逗号分隔。

public enum ElementType {
    /** 用于描述类、接口(包括注解类型) 或enum声明 */
    TYPE,

    /** 成员变量、对象、属性（包括enum实例）  */
    FIELD,

    /** 用于描述方法 */
    METHOD,

    /** 用于描述参数 */
    PARAMETER,

    /** 用于描述构造器 */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

@Retention：表示该注解的生命周期。

public enum RetentionPolicy {
    /**
     * 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。
     */
    SOURCE,

    /**
     * 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式
     */
    CLASS,

    /**
     * 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。 
     */
    RUNTIME
}

@Inherited：此注解是标识性的元注解，表示当前注解可以由子注解来继承。

@Documented：表示生成javadoc的时候会包含注解。

三、实现日志记录功能

3.1 添加依赖

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

3.2 使用自定义注解

@Log(title = "测试", action = "获取")

@RestController
@RequestMapping(value = "/v1/demo")
public class DemoController {

    @Log(title = "测试", action = "获取")
    @GetMapping(value = "/{id}")
    public BaseResponse selectCouponById(@PathVariable("id") Long id) {
        System.out.println("controller");
        return ResultResponse.success(StatusResultEnum.SUCCESS, id);
    }

}

3.3 注解类切面

这个是最主要的类,可以使用自定义注解或针对包名实现AOP增强。

1)这里实现了对自定义注解的环绕增强切点，对使用了自定义注解的方法进行AOP切面处理；

2)对方法运行时间进行监控；

3)对方法名，参数名，参数值，对日志描述的优化处理；

在方法上增加@Aspect 注解声明切面,使用@Pointcut 注解定义切点，标记方法。

使用切点增强的时机注解:@Before,@Around,@AfterReturning,@AfterThrowing,@After

@Aspect
作用是把当前类标识为一个切面供容器读取

@Pointcut
定义一个切点

@Before
标识一个前置增强方法，相当于BeforeAdvice的功能

@After
final增强，不管是抛出异常或者正常退出都会执行

@component
把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/>

package com.lian.demo.aop;

import com.alibaba.fastjson.JSONObject;
import com.lian.demo.common.annotation.Log;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 操作日志记录处理
 */
@Aspect
@Component
@Slf4j
public class LogAspect {

    /**
     * 配置织入点
     */
    @Pointcut("@annotation(com.lian.demo.common.annotation.Log)")
    public void logPointCut() {
    }

    /**
     * 环绕增强，相当于MethodInterceptor
     */
    @Around("logPointCut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("Around==========");

        Object res = null;
        long time = System.currentTimeMillis();
        try {
            res =  joinPoint.proceed();
            time = System.currentTimeMillis() - time;
            log.info("res=========={}", JSONObject.toJSONString(res));
            return res;
        } catch (Throwable e) {
            log.error("LogAspect 操作失败：", e.getMessage());
            e.printStackTrace();
        }
    }

    @Before("logPointCut()")
    public void before(JoinPoint joinPoint) {
        Log logBean = this.getAnnotationLog(joinPoint);
        log.info("打印: {} 开始前", logBean.title());
    }

    /**
     * 后置最终通知,final增强，不管是抛出异常或者正常退出都会执行
     */
    @After("logPointCut()")
    public void after(JoinPoint jp){
        log.info("方法最后执行");
    }

    /**
     * 处理完请求，返回内容
     * @param ret
     */
    @AfterReturning(returning = "ret", pointcut = "logPointCut()")
    public void doAfterReturning(Object ret) {
        log.info("方法的返回值 : {}", ret);
        // TODO 业务代码
//        addOperationLog(joinPoint,res,time);
    }

    /**
     * 后置异常通知
     * 
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(value = "logPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e) {
        log.error("方法异常时执行 : {}", e);
    }

    /**
     * 是否存在注解，如果存在就获取
     */
    private Log getAnnotationLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();

        if (method != null) {
            return method.getAnnotation(Log.class);
        }

        return null;
    }

}

3.4 题外话

通过反射获取注解信息

public class Test {

    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("com.lian.demo.controller.DemoController");
            // 获取所有的方法
            Method[] method = clazz.getMethods();
            for(Method m : method) {
                // 判断方法上是否使用了自定义注解Log
                boolean isExist = m.isAnnotationPresent(Log.class);
                if (isExist) {
                    Log log = m.getAnnotation(Log.class);
                    System.out.println(log.title());
                }
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

参考

https://www.cnblogs.com/wenjunwei/p/9639909.html

https://blog.csdn.net/u013825231/article/details/80468167

https://www.cnblogs.com/Qian123/p/5256084.html#_label2

转载于:https://my.oschina.net/lienson/blog/3029289