关于注解:自定义注解的魅力你到底懂不懂

65次阅读

共计 13144 个字符，预计需要花费 33 分钟才能阅读完成。

前言

你晓得自定义注解的魅力所在吗？

你晓得自定义注解该怎么应用吗？

本文一开始的这两个问题，须要您认真思考下，而后联合这两个问题来浏览上面的内容；如果您在浏览完文章后对这两个问题有了比拟清晰的，请动动您发财的小手，点赞留言呀！

本文主线：

  • 注解是什么；
  • 实现一个自定义注解；
  • 自定义注解的实战利用场景；

留神：本文在介绍自定义注解实战利用场景时，须要联合拦截器、AOP 进行应用，所以本文也会简略聊下 AOP 相干知识点，如果对于 AOP 的相干内容不太分明的能够参考此 细说 Spring——AOP 详解 文章进行理解。

注解

注解是什么？

①、援用自维基百科的内容：

Java 注解又称 Java 标注，是 JDK5.0 版本开始反对退出源代码的非凡语法 元数据 。

Java 语言中的类、办法、变量、参数和包等都能够被标注。和 Javadoc 不同，Java 标注能够通过反射获取标注内容。在编译器生成类文件时，标注能够被嵌入到字节码中。Java 虚拟机能够保留标注内容，在运行时能够获取到标注内容。当然它也反对自定义 Java 标注。

②、援用自网络的内容：

Java 注解是在 JDK5 时引入的新个性，注解（也被称为 元数据 ）为咱们在代码中增加信息提供了一种形式化的办法，使咱们能够在稍后某个时刻十分不便地应用这些数据。

元注解是什么？

元注解 的作用就是负责注解其余注解。Java5.0 定义了 4 个规范的 meta-annotation（元注解）类型，它们被用来提供对其它 annotation 类型作阐明。

规范的元注解：
  • @Target
  • @Retention
  • @Documented
  • @Inherited

在具体说这四个元数据的含意之前，先来看一个在工作中会常常应用到的 @Autowired 注解，进入这个注解外面瞧瞧：此注解中应用到了 @Target、@Retention、@Documented 这三个元注解。

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {boolean required() default true;
}
@Target 元注解：

@Target 注解，是专门用来限定某个自定义注解可能被利用在哪些 Java 元素下面的，表明作用范畴；取值在 java.lang.annotation.ElementType 进行定义的。

public enum ElementType {
    /** 类，接口（包含注解类型）或枚举的申明 */
    TYPE,

    /** 属性的申明 */
    FIELD,

    /** 办法的申明 */
    METHOD,

    /** 办法形式参数申明 */
    PARAMETER,

    /** 构造方法的申明 */
    CONSTRUCTOR,

    /** 局部变量申明 */
    LOCAL_VARIABLE,

    /** 注解类型申明 */
    ANNOTATION_TYPE,

    /** 包的申明 */
    PACKAGE
}

依据此处能够晓得 @Autowired 注解的作用范畴：

// 能够作用在 构造方法、办法、办法形参、属性、注解类型 上
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention 元注解：

@Retention 注解，翻译为持久力、放弃力。即用来润饰自定义注解的生命周期。

注解的生命周期有三个阶段：

  • Java 源文件阶段；
  • 编译到 class 文件阶段；
  • 运行期阶段；

同样应用了 RetentionPolicy 枚举类型对这三个阶段进行了定义：

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     *（注解将被编译器疏忽掉）*/
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     *（注解将被编译器记录在 class 文件中，但在运行时不会被虚拟机保留，这是一个默认的行为）*/
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *（注解将被编译器记录在 class 文件中，而且在运行时会被虚拟机保留，因而它们能通过反射被读取到）* @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

再详细描述下这三个阶段：

①、如果被定义为 RetentionPolicy.SOURCE，则它将被限定在 Java 源文件中，那么这个注解即不会参加编译也不会在运行期起任何作用，这个注解就和一个正文是一样的成果，只能被浏览 Java 文件的人看到；

②、如果被定义为 RetentionPolicy.CLASS，则它将被编译到 Class 文件中，那么编译器能够在编译时依据注解做一些解决动作，然而运行时 JVM（Java 虚拟机）会疏忽它，并且在运行期也不能读取到；

③、如果被定义为 RetentionPolicy.RUNTIME，那么这个注解能够在运行期的加载阶段被加载到 Class 对象中。那么在程序运行阶段，能够通过反射失去这个注解，并通过判断是否有这个注解或这个注解中属性的值，从而执行不同的程序代码段。

留神：理论开发中的自定义注解简直都是应用的 RetentionPolicy.RUNTIME。

@Documented 元注解：

@Documented 注解，是被用来指定自定义注解是否能随着被定义的 java 文件生成到 JavaDoc 文档当中。

@Inherited 元注解：

@Inherited 注解，是指定某个自定义注解如果写在了父类的申明局部，那么子类的申明局部也能主动领有该注解。

@Inherited 注解只对那些 @Target 被定义为 ElementType.TYPE 的自定义注解起作用。

自定义注解实现：

在理解了下面的内容后，咱们来尝试实现一个自定义注解：

依据下面自定义注解中应用到的元注解得悉：

①、此注解的作用范畴，能够应用在类（接口、枚举）、办法上；

②、此注解的生命周期，被编译器保留在 class 文件中，而且在运行时会被 JVM 保留，能够通过反射读取；

自定义注解的简略应用：

下面曾经创立了一个自定义的注解，那该怎么应用呢？上面首先形容下它简略的用法，前面将会应用其联合拦截器和 AOP 切面编程进行实战利用；

利用场景实现

在理解了下面注解的常识后，咱们乘胜追击，看看它的理论利用场景是肿么样的，以此加深下咱们的了解；

实现的 Demo 我的项目是以 SpringBoot 实现的，我的项目工程结构图如下：

场景一：自定义注解 + 拦截器 = 实现接口响应的包装

应用自定义注解 联合 拦截器 优雅的实现对 API 接口响应的包装。

在介绍自定义实现的形式之前，先简略介绍下广泛的实现形式，通过两者的比照，能力更加显著的发现谁最优雅。

一般的接口响应包装形式：

当初我的项目绝大部分都采纳的前后端拆散形式，所以须要前端和后端通过接口进行交互；目前在接口交互中应用最多的数据格式是 json，而后后端返回给前端的最为常见的响应格局如下：

{
    #返回状态码
    code:integer,       
    #返回信息形容
    message:string,
    #返回数据值
    data:object
}

我的项目中常常应用枚举类定义状态码和音讯，代码如下：

/**
 * @author【木子雷】公众号
 * @Title: ResponseCode
 * @Description: 应用枚举类封装好的响应状态码及对应的响应音讯
 * @date: 2019 年 8 月 23 日 下午 7:12:50
 */
public enum ResponseCode {SUCCESS(1200, "申请胜利"),

    ERROR(1400, "申请失败");


    private Integer code;

    private String message;

    private ResponseCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer code() {return this.code;}

    public String message() {return this.message;}

}

同时我的项目中也会设计一个返回响应包装类，代码如下：

import com.alibaba.fastjson.JSONObject;
import java.io.Serializable;

/**
 * @author【木子雷】公众号
 * @Title: Response
 * @Description: 封装的对立的响应返回类
 * @date: 2019 年 8 月 23 日 下午 7:07:13
 */
@SuppressWarnings("serial")
public class Response<T> implements Serializable {

    /**
     * 响应数据
     */
    private T date;

    /**
     * 响应状态码
     */
    private Integer code;

    /**
     * 响应形容信息
     */
    private String message;

    public Response(T date, Integer code, String message) {super();
        this.date = date;
        this.code = code;
        this.message = message;
    }


    public T getDate() {return date;}

    public void setDate(T date) {this.date = date;}

    public Integer getCode() {return code;}

    public void setCode(Integer code) {this.code = code;}

    public String getMessage() {return message;}

    public void setMessage(String message) {this.message = message;}


    @Override
    public String toString() {return JSONObject.toJSONString(this);
    }
}

最初就是应用响应包装类和状态码枚举类 来实现返回响应的包装了：

@GetMapping("/user/findAllUser")
public Response<List<User>> findAllUser() {logger.info("开始查问所有数据...");

    List<User> findAllUser = new ArrayList<>();
    findAllUser.add(new User("木子雷", 26));
    findAllUser.add(new User("公众号", 28));

    // 返回响应进行包装
    Response response = new Response(findAllUser, ResponseCode.SUCCESS.code(), ResponseCode.SUCCESS.message());

    logger.info("response: {} \n", response.toString());
    return response;
}

在浏览器中输出网址：http://127.0.0.1:8080/v1/api/user/findAllUser 而后点击回车，失去如下数据：

{
    "code": 1200,
    "date": [
        {
            "age": 26,
            "name": "木子雷"
        },
        {
            "age": 28,
            "name": "公众号"
        }
    ],
    "message": "申请胜利"
}

通过看这中实现响应包装的形式，咱们能发现什么问题吗？

答：代码很冗余，须要在每个接口办法中都进行响应的包装；使得接口办法蕴含了很多非业务逻辑代码；

有没有版本进行优化下呢？en en 思考中。。。。。啊，自定义注解 + 拦截器能够实现呀！

自定义注解实现接口响应包装：

①、首先创立一个进行响应包装的自定义注解：

/**
 * @author【木子雷】公众号
 * @PACKAGE_NAME: com.lyl.annotation
 * @ClassName: ResponseResult
 * @Description: 标记办法返回值须要进行包装的 自定义注解
 * @Date: 2020-11-10 10:38
 **/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseResult {}

②、创立一个拦截器，实现对申请的拦挡，看看申请的办法或类上是否应用了自定义的注解：

/**
 * @author【木子雷】公众号
 * @PACKAGE_NAME: com.lyl.interceptor
 * @ClassName: ResponseResultInterceptor
 * @Description: 拦截器：拦挡申请，判断申请的办法或类上是否应用了自定义的 @ResponseResult 注解，*               并在申请内设置是否应用了自定义注解的标记位属性；* @Date: 2020-11-10 10:50
 **/
@Component
public class ResponseResultInterceptor implements HandlerInterceptor {

    /**
     * 标记位，标记申请的 controller 类或办法上应用了到了自定义注解，返回数据须要被包装
     */
    public static final String RESPONSE_ANNOTATION = "RESPONSE_ANNOTATION";

    /**
     * 申请预处理，判断是否应用了自定义注解
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 申请的接口办法
        if (handler instanceof HandlerMethod) {final HandlerMethod handlerMethod = (HandlerMethod) handler;
            final Class<?> clazz = handlerMethod.getBeanType();
            final Method method = handlerMethod.getMethod();
            // 判断是否在类对象上加了注解
            if (clazz.isAnnotationPresent(ResponseResult.class)) {
                // 在申请中设置须要进行响应包装的属性标记，在上面的 ResponseBodyAdvice 加强中进行解决
                request.setAttribute(RESPONSE_ANNOTATION, clazz.getAnnotation(ResponseResult.class));
            } else if (method.isAnnotationPresent(ResponseResult.class)) {
                // 在申请中设置须要进行响应包装的属性标记，在上面的 ResponseBodyAdvice 加强中进行解决
                request.setAttribute(RESPONSE_ANNOTATION, method.getAnnotation(ResponseResult.class));
            }
        }
        return true;
    }
}

③、创立一个加强 Controller，实现对返回响应进行包装的加强解决：

/**
 * @author【木子雷】公众号
 * @PACKAGE_NAME: com.lyl.interceptor
 * @ClassName: ResponseResultHandler
 * @Description: 对 返回响应 进行包装 的加强解决
 * @Date: 2020-11-10 13:49
 **/
@ControllerAdvice
public class ResponseResultHandler implements ResponseBodyAdvice<Object> {private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 标记位，标记申请的 controller 类或办法上应用了到了自定义注解，返回数据须要被包装
     */
    public static final String RESPONSE_ANNOTATION = "RESPONSE_ANNOTATION";

    /**
     * 申请中是否蕴含了 响应须要被包装的标记，如果没有，则间接返回，不须要重写返回体
     *
     * @param methodParameter
     * @param aClass
     * @return
     */
    @Override
    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {ServletRequestAttributes ra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest sr = (HttpServletRequest) ra.getRequest();
        // 查问是否须要进行响应包装的标记
        ResponseResult responseResult = (ResponseResult) sr.getAttribute(RESPONSE_ANNOTATION);
        return responseResult == null ? false : true;
    }


    /**
     * 对 响应体 进行包装; 除此之外还能够对响应体进行对立的加密、签名等
     *
     * @param responseBody  申请的接口办法执行后失去返回值 (返回响应)
     */
    @Override
    public Object beforeBodyWrite(Object responseBody, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {logger.info("返回响应 包装进行中。。。");
        Response response;
        // boolean 类型时判断一些数据库新增、更新、删除的操作是否胜利
        if (responseBody instanceof Boolean) {if ((Boolean) responseBody) {response = new Response(responseBody, ResponseCode.SUCCESS.code(), ResponseCode.SUCCESS.message());
            } else {response = new Response(responseBody, ResponseCode.ERROR.code(), ResponseCode.ERROR.message());
            }
        } else {
            // 判断像查问一些返回数据的状况，查问不到数据返回 null;
            if (null != responseBody) {response = new Response(responseBody, ResponseCode.SUCCESS.code(), ResponseCode.SUCCESS.message());
            } else {response = new Response(responseBody, ResponseCode.ERROR.code(), ResponseCode.ERROR.message());
            }
        }
        return response;
    }
}

④、最初在 Controller 中应用上咱们的自定义注解；在 Controller 类上或者 办法上应用 @ResponseResult 自定义注解即可；在浏览器中输出网址：http://127.0.0.1:8080/v1/api/user/findAllUserByAnnotation 进行查看：

// 自定义注解用在了办法上
@ResponseResult
@GetMapping("/user/findAllUserByAnnotation")
public List<User> findAllUserByAnnotation() {logger.info("开始查问所有数据...");

    List<User> findAllUser = new ArrayList<>();
    findAllUser.add(new User("木子雷", 26));
    findAllUser.add(new User("公众号", 28));

    logger.info("应用 @ResponseResult 自定义注解进行响应的包装，使 controller 代码更加简介");
    return findAllUser;
}

至此咱们的接口返回响应包装自定义注解实现设计实现，看看代码是不是又简洁，又优雅呢。

总结：本文针对此计划只是进行了简略的实现，如果有趣味的敌人能够进行更好的优化。

场景二：自定义注解 + AOP = 实现优雅的应用分布式锁

分布式锁的最常见的应用流程：

先看看最为常见的分布式锁应用形式的实现，而后再聊聊自定义注解怎么优雅的实现分布式锁的应用。

一般的分布式锁应用形式：

通过下面的代码能够失去一个信息：如果有很多办法中须要应用分布式锁，那么每个办法中都必须有获取分布式锁和开释分布式锁的代码，这样一来就会呈现代码冗余；

那有什么好的解决方案吗？自定义注解使代码变得更加简洁、优雅；

自定义注解优雅的应用分布式锁：

①、首先实现一个标记分布式锁应用的自定义注解：

/**
 * @author【木子雷】公众号
 * @PACKAGE_NAME: com.lyl.annotation
 * @ClassName: GetDistributedLock
 * @Description: 获取 redis 分布式锁 注解
 * @Date: 2020-11-10 16:24
 **/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GetDistributedLock {

    // 分布式锁 key
    String lockKey();

    // 分布式锁 value，默认为 lockValue
    String lockValue() default "lockValue";

    // 过期工夫，默认为 300 秒
    int expireTime() default 300;}

②、定义一个切面，在切面中对应用了 @GetDistributedLock 自定义注解的办法进行盘绕加强告诉：

/**
 * @author:【木子雷】公众号
 * @PACKAGE_NAME: com.lyl.aop
 * @ClassName: DistributedLockAspect
 * @Description: 自定义注解联合 AOP 切面编程优雅的应用分布式锁
 * @Date: 2020-11-10 16:52
 **/
@Component
@Aspect
public class DistributedLockAspect {private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    RedisService redisService;


    /**
     * Around 盘绕加强告诉
     *
     * @param joinPoint 连接点，所有办法都属于连接点；然而当某些办法上应用了 @GetDistributedLock 自定义注解时，*                  则其将连接点变为了切点；而后在切点上织入额定的加强解决；切点和其相应的加强解决形成了切面 Aspect。*/
    @Around(value = "@annotation(com.lyl.annotation.GetDistributedLock)")
    public Boolean handlerDistributedLock(ProceedingJoinPoint joinPoint) {
        // 通过反射获取自定义注解对象
        GetDistributedLock getDistributedLock = ((MethodSignature) joinPoint.getSignature())
                .getMethod().getAnnotation(GetDistributedLock.class);

        // 获取自定义注解对象中的属性值
        String lockKey = getDistributedLock.lockKey();
        String LockValue = getDistributedLock.lockValue();
        int expireTime = getDistributedLock.expireTime();

        if (redisService.tryGetDistributedLock(lockKey, LockValue, expireTime)) {
            // 获取分布式锁胜利后，继续执行业务逻辑
            try {return (boolean) joinPoint.proceed();} catch (Throwable throwable) {logger.error("业务逻辑执行失败。", throwable);
            } finally {
                // 最终保障分布式锁的开释
                redisService.releaseDistributedLock(lockKey, LockValue);
            }
        }
        return false;
    }

}

③、最初，在 Controller 中的办法上应用 @GetDistributedLock 自定义注解即可；当某个办法上应用了 自定义注解，那么这个办法就相当于一个切点，那么就会对这个办法做盘绕（办法执行前和办法执行后）加强解决；

在浏览器中输出网址：http://127.0.0.1:8080/v1/api/user/getDistributedLock 回车后触发办法执行：

// 自定义注解的应用
@GetDistributedLock(lockKey = "userLock")
@GetMapping("/user/getDistributedLock")
public boolean getUserDistributedLock() {logger.info("获取分布式锁...");
    // 写具体的业务逻辑

    return true;
}

通过自定义注解的形式，能够看到代码变得更加简洁、优雅。

场景三：自定义注解 + AOP = 实现日志的打印

先看看最为常见的日志打印的形式，而后再聊聊自定义注解怎么优雅的实现日志的打印。

一般日志的打印形式：

通过看下面的代码能够晓得，如果每个办法都须要打印下日志，那将会存在大量的冗余代码；

自定义注解实现日志打印：

①、首先创立一个标记日志打印的自定义注解：

/**
 * @Author:【木子雷】公众号
 * @PACKAGE_NAME: com.lyl.annotation
 * @ClassName: PrintLog
 * @Description: 自定义注解实现日志打印
 * @Date: 2020-11-10 18:05
 **/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PrintLog {}

②、定义一个切面，在切面中对应用了 @PrintLog 自定义注解的办法进行盘绕加强告诉：

/**
 * @author:【木子雷】公众号
 * @PACKAGE_NAME: com.lyl.aop
 * @ClassName: PrintLogAspect
 * @Description: 自定义注解联合 AOP 切面编程优雅的实现日志打印
 * @Date: 2020-11-10 18:11
 **/
@Component
@Aspect
public class PrintLogAspect {private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     *  Around 盘绕加强告诉
     *
     * @param joinPoint 连接点，所有办法都属于连接点；然而当某些办法上应用了 @PrintLog 自定义注解时，*                  则其将连接点变为了切点；而后在切点上织入额定的加强解决；切点和其相应的加强解决形成了切面 Aspect。*/
    @Around(value = "@annotation(com.lyl.annotation.PrintLog)")
    public Object handlerPrintLog(ProceedingJoinPoint joinPoint) {
        // 获取办法的名称
        String methodName = joinPoint.getSignature().getName();
        // 获取办法入参
        Object[] param = joinPoint.getArgs();

        StringBuilder sb = new StringBuilder();
        for (Object o : param) {sb.append(o + ";");
        }
        logger.info("进入《{}》办法, 参数为: {}", methodName, sb.toString());

        Object object = null;
        // 继续执行办法
        try {object = joinPoint.proceed();

        } catch (Throwable throwable) {logger.error("打印日志解决 error。。", throwable);
        }
        logger.info("{} 办法执行完结。。", methodName);
        return object;
    }

}

③、最初，在 Controller 中的办法上应用 @PrintLog 自定义注解即可；当某个办法上应用了 自定义注解，那么这个办法就相当于一个切点，那么就会对这个办法做盘绕（办法执行前和办法执行后）加强解决；

@PrintLog
@GetMapping(value = "/user/findUserNameById/{id}", produces = "application/json;charset=utf-8")
public String findUserNameById(@PathVariable("id") int id) {
    // 模仿依据 id 查问用户名
    String userName = "木子雷 公众号";
    return userName;
}

④、在浏览器中输出网址：http://127.0.0.1:8080/v1/api/user/findUserNameById/66 回车后触发办法执行，发现控制台打印了日志：

 进入《findUserNameById》办法, 参数为: 66; 
findUserNameById 办法执行完结。。

应用自定义注解实现是多优雅，代码看起来简介洁净，越瞅越喜爱；赶快去你的我的项目中应用吧，嘿嘿。。。

end。。。自定义注解介绍到这本文也就完结了，期待咱们的下次见面。

最初，想问下文章结尾的那两个问题大家心里是不是曾经有了答案呢！嘿嘿。。

❤ 关注 + 点赞 + 珍藏 + 评论 哟

如果本文对您有帮忙的话，请挥动下您爱发财的小手点下赞呀，您的反对就是我一直创作的能源；谢谢！

如果想要 Demo 源码的话，请您 VX 搜寻【木子雷】公众号，回复 “注解” 获取；再次感谢您浏览本文！

参考资料

①、自定义注解具体介绍

②、Java 自定义注解及应用场景

③、想本人写框架？不会写 Java 注解可不行

④、看看人家那后端 API 接口写得，那叫一个优雅！

正文完
注解
发表至： 注解
2020-11-15
 0
关于注解:深入理解Java注解类型
关于注解:面试官说说你对注解的理解
关于注解:注解入门
关于注解:SSMspringboot注解总结