前言
你晓得自定义注解的魅力所在吗？你晓得自定义注解该怎么应用吗？
本文一开始的这两个问题，须要您认真思考下，而后联合这两个问题来浏览上面的内容；如果您在浏览完文章后对这两个问题有了比拟清晰的，请动动您发财的小手，点赞留言呀！
本文主线：
- 注解是什么；
- 实现一个自定义注解；
- 自定义注解的实战利用场景；
留神：本文在介绍自定义注解实战利用场景时，须要联合拦截器、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)@Documentedpublic @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)@Documentedpublic @interface ResponseResult {}②、创立一个拦截器，实现对申请的拦挡，看看申请的办法或类上是否应用了自定义的注解：
/** * @author 【 木子雷 】 公众号 * @PACKAGE_NAME: com.lyl.interceptor * @ClassName: ResponseResultInterceptor * @Description: 拦截器：拦挡申请，判断申请的办法或类上是否应用了自定义的@ResponseResult注解， * 并在申请内设置是否应用了自定义注解的标记位属性； * @Date: 2020-11-10 10:50 **/@Componentpublic 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 **/@ControllerAdvicepublic 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)@Documentedpublic @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@Aspectpublic 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)@Documentedpublic @interface PrintLog {}②、定义一个切面，在切面中对应用了 @PrintLog 自定义注解的办法进行盘绕加强告诉：
/** * @author: 【 木子雷 】 公众号 * @PACKAGE_NAME: com.lyl.aop * @ClassName: PrintLogAspect * @Description: 自定义注解联合AOP切面编程优雅的实现日志打印 * @Date: 2020-11-10 18:11 **/@Component@Aspectpublic 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 接口写得，那叫一个优雅！