文档章节

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

Lienson
 Lienson
发布于 03/28 16:20
字数 1456
阅读 18
收藏 6

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

© 著作权归作者所有

Lienson
粉丝 15
博文 107
码字总数 97577
作品 0
福州
程序员
私信 提问
SpringBoot(四)之优雅地日志处理

一、简介 日志功能在j2ee项目中是一个相当常见的功能,在一个小项目中或许你可以在一个个方法中,使用日志表的Mapper生成一条条的日志记录,但这无非是最烂的做法之一,因为这种做法会让日志...

郑加威
2018/12/23
0
0
Spring Boot整合MyBatis学习总结

公司的很多项目都陆陆续续引入了Spring Boot,通过对Spring Boot的接触了解发现其真的是大大地简化了开发、简化了依赖配置,很多功能注解一下就可以实现,真的是太方便了。下面记录了一个Spr...

zhuwensheng
2018/06/29
0
0
springboot项目基础面试题(一)

springboot项目基础面试题(一) 1.springboot与spring的区别. 2.springboot的核心功能与使用优点. 核心功能: 1.1: springboot项目为独立运行的spring项目,java -jar xx.jar即可运行. 1.2: 内嵌...

DemonsI
05/16
0
0
SpringBoot(二)之核心

Spring Boot的核心 在上篇中我们成功运行了一个简单的web应用,其中有一个注解被轻易的带过了,但它在Spring Boot中是最重要的注解,没有之一,它就是@SpringBootApplication,本篇将对它与S...

郑加威
2018/12/23
0
0
220.详细整理学习spring boot

1.springboot是什么? 有什么用? 1.1 是什么 一个整合常用第三方框架,简化xml配置,完全采用注解形式,内置tomcat容器,帮助开发者快速实现项目搭建,spring boot 的web组件默认集成的是spr...

Lucky_Me
04/23
0
1

没有更多内容

加载失败,请刷新页面

加载更多

redis 消息队列实现

方式一:通过list的阻塞读取命令,blpop或者brpop 消费者 public class Consumer extends DemoApplicationTests{ @Test public void consume(){ int timeout = 0;//永不超......

小海bug
15分钟前
0
0
如何把微信语音汇总成一个MP3文件?

本篇以苹果手机为例,安卓手机也可类似。 第一步,安装同步助手 同步助手是一款在电脑上安装,可以保存手机上的内容的软件。支持把微信的聊天历史内容导出。甚至支持筛选语音文件按顺序导出—...

吴伟祥
21分钟前
1
0
用ffsend使用Firefox Send

导读 ffsend 是 Firefox Send 的命令行客户端。本文将展示 Firefox Send 和 ffsend 如何工作。还会详细介绍如何在 Fedora 中安装和使用它。 ffsend 是 Firefox Send 的命令行客户端。本文将展...

问题终结者
22分钟前
0
0
用ffsend使用Firefox Send

ffsend 是 Firefox Send 的命令行客户端。本文将展示 Firefox Send 和 ffsend 如何工作。还会详细介绍如何在 Fedora 中安装和使用它。 ffsend 是 Firefox Send 的命令行客户端。本文将展示 ...

Linux就该这么学
34分钟前
0
0
分布式Session的实现方式

JWT Token 使用 JWT Token 储存用户身份,然后再从数据库或者 cache 中获取其他的信息。这样无论请求分配到哪个服务器都无所谓。 Tomcat + Redis 在 tomcat 的配置文件中配置: <Valve class...

禅明
40分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部