Java注解-一文就懂

我就是我 2021-07-24 18:29 420阅读 0赞

# Java注解 #

## 1、概念 ##

> Annotation(注解)是Java提供的一种对元程序中元素关联信息和元数据(metadata)的途径和方法。**Annotation(注解)是一个接口**，程序可以通过反射来获取指定程序中元素的Annotation对象，然后通过该Annotation对象来获取注解中的元数据信息。

// 定义一个简单测试注解
    @Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Limit { 
        String name() default "李子捌";
    }

> **jdk反编译注解**

## 执行命令
    javap Limit.class
    
    ## 输出如下内容，可以发现注解其实就是一个接口，继承了Annotation
    public interface com.liziba.map.Limit extends java.lang.annotation.Annotation { 
      public abstract java.lang.String name();
    }

## 2、4种标准元注解 ##

> **元注解的作用是负责注解其他注解**。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它annotation类型作说明。

**1、@Target**修饰的**对象范围**

> @Target说明了Annotation所修饰的对象范围：Annotation可被用于packages、types(类、接口、枚举、Annotation类型)、类成员(方法、构造方法、成员变量、枚举值)、方法参数和本地变量(如循环变量、catch参数)。在Annotation类型的声明中使用了@Target可更加明晰其修饰的目标

**2、@Retention**定义被**保留的时间**长短

> @Retention定义了该Annotation被保留的时间长短：表示需要在什么级别保留注解信息，用于描述注解的生命周期(即：被描述的注解在什么范围内有效)，取值(RetentionPolicy):
> 
>  *  SOURCE： 在源文件中有效
>  *  CLASS：在class文件中有效
>  *  RUNTIME：在运行时有效

**3、@Documented**描述-**javadoc**

> @Documented用于描述其他类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类工具文档化

**4、@Inherited**阐述了某个被标注的类型是被**继承**的

> @Inherited元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类

## 3、图解注解 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center]

## 4、注解处理器 ##

> 如果没有用来读取注解的方法和工作，那么注解也就不会比注释更有用处了。使用注解的过程中，很重要一部分就是创建用于使用注解的处理器。Java SE5扩展了反射机制API，以帮助程序员快速的构造自定义的注解处理器。下面简单写三种我在最近开发中的自定义注解应用

### 4.1 失败重试注解 ###

**定义注解**

/** * <p> * 失败重试 * </p> * @Author: Liziba */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @Documented
    @Component
    public @interface Retry { 
        /** * 定义重试次数 默认一次 */
        int value() default 1;
        /** * 定义重试间隔周期 */
        int period() default 5000
    }

**定义注解处理器** **- 切面**

@Aspect
    @Component
    public class RetryAspect { 
    
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        /** * 针对com.liziba.web.controller下的方法抛出异常重试 * @param point */
        @AfterThrowing(pointcut=("execution(* com.liziba.web.service.impl.RetryHttpRequestClient.*(..)) && @annotation(com.liziba.web.annotation.Retry)"))
        public void tryAgain(JoinPoint point) { 
            logger.info("------------开始重试------------");
            try { 
                // 获取方法上定义的Retry注解
                MethodSignature methodSignature = (MethodSignature) point.getSignature();
                Retry retry = methodSignature.getMethod().getAnnotation(Retry.class);
                // ThreadLocal做线程隔离 times记录已经重试的次数
                Object object = point.getTarget();
                Field field = object.getClass().getDeclaredField("threadLocal");
                field.setAccessible(true);
                ThreadLocal<Map<String, Object>> threadLocal = (ThreadLocal<Map<String, Object>>) field.get(object);
                Map<String, Object> threadLocalMap = threadLocal.get();
                AtomicInteger times = (AtomicInteger)threadLocalMap.get("times");
                // 重试 -1一直循环
                if (retry.value() == -1 || (times.intValue() < retry.value())) { 
                    logger.info("开始重试第"+ index + "次");
                    int index = times.incrementAndGet();
                    MethodInvocationProceedingJoinPoint methodPoint = ((MethodInvocationProceedingJoinPoint) point);
                    methodPoint.proceed();
                } else { 
                    // 数据库服务异常捕获，防止异常中异常导致StackOverFlowError
                    try { 
                        // ToDo
                        // 此处可以保存到数据库，做周期性失败重试，重试次数达到阈值后通过消息平台通知到运维及时处理异常任务
                        // 移除threadLocal，防止线程生命周期过长导致内存泄露
                        threadLocal.remove();
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                }
            } catch (Throwable throwable) { 
                logger.error(throwable.getMessage(),throwable);
                // 失败后继续重试
                tryAgain(point);
            }
        }
    }

### 4.2 日志记录注解 ###

**定义注解**

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Log { 
        
        String value() default "";
        
        /** * 是否启用 */
        boolean enable() default true;
    
        LogActionType type() default LogActionType.SELECT;
    }

**日志类型**

public enum LogActionType { 
      
        ADD("新增"),
        SELECT("查询"),
        UPDATE("更新"),
        DELETE("删除");
        private String value;
    
        LogActionType(String value) { 
            this.value = value;
        }
    
        public String getValue() { 
            return value;
        }
    
        public void setValue(String value) { 
            this.value = value;
        }
    }

**定义注解处理器** **- 切面**

@Component
    @Aspect
    @Slf4j
    public class LogAspect { 
    
        // 保存日志信息服务
        private final LogService logService;
    
        // 线程隔离，用于计算每个方法的执行时间
        ThreadLocal<Long> currentTime = new ThreadLocal<>();
    
        public LogAspect(LogService logService) { 
            this.logService = logService;
        }
    
        /** * 配置切入点 * 该方法无方法体,主要为了让同类中其他方法使用此切入点 */
        @Pointcut("@annotation(com.liziba.annotation.Log)")
        public void logPointcut() { 
        }
    
        /** * 配置环绕通知,使用在方法logPointcut()上注册的切入点 * * @param joinPoint join point for advice */
        @Around("logPointcut()")
        public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable { 
            Object result;
            // 计算方法操作时间
            currentTime.set(System.currentTimeMillis());
            result = joinPoint.proceed();
            Log log = new Log("INFO",System.currentTimeMillis() - currentTime.get());
            currentTime.remove();
            HttpServletRequest request = RequestHolder.getHttpServletRequest();
            // 记录用户名、浏览器信息、ip地址、切入点、日志信息
            logService.save(getUsername(), StringUtils.getBrowser(request), StringUtils.getIp(request),joinPoint, log);
            return result;
        }
    
        /** * 配置异常通知 * * @param joinPoint join point for advice * @param e exception */
        @AfterThrowing(pointcut = "logPointcut()", throwing = "e")
        public void logAfterThrowing(JoinPoint joinPoint, Throwable e) { 
            Log log = new Log("ERROR",System.currentTimeMillis() - currentTime.get());
            currentTime.remove();
            // 获取日志堆栈信息，并设值
            log.setExceptionDetail(ThrowableUtil.getStackTrace(e).getBytes());
            HttpServletRequest request = RequestHolder.getHttpServletRequest();
             // 记录用户名、浏览器信息、ip地址、切入点、日志信息
            logService.save(getUsername(), StringUtils.getBrowser(request), StringUtils.getIp(request), (ProceedingJoinPoint)joinPoint, log);
        }
    
        /** * 获取用户名信息 */
        public String getUsername() { 
            try { 
                return SecurityUtils.getCurrentUsername();
            }catch (Exception e){ 
                return "";
            }
        }
    }

### 4.3 限流注解 - redis+lua限流 ###

**注解定义**

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Limit { 
    
        // 资源名称，用于描述接口功能
        String name() default "";
    
        // 资源 key
        String key() default "";
    
        // key prefix
        String prefix() default "";
    
        // 时间的，单位秒
        int period();
    
        // 限制访问次数
        int count();
    
        // 限制类型
        LimitType limitType() default LimitType.CUSTOMER;
    }

**注解类型**

public enum LimitType { 
        // 默认
        CUSTOMER,
        // IP限流
        IP
    }

**定义注解处理器** **- 切面**

@Aspect
    @Component
    public class LimitAspect { 
    	
        // redis用于执行lua脚本
        private final RedisTemplate<Object,Object> redisTemplate;
        private static final Logger logger = LoggerFactory.getLogger(LimitAspect.class);
    
        public LimitAspect(RedisTemplate<Object,Object> redisTemplate) { 
            this.redisTemplate = redisTemplate;
        }
    
        /** * 配置切入点 * 该方法无方法体,主要为了让同类中其他方法使用此切入点 */
        @Pointcut("@annotation(com.liziba.annotation.Limit)")
        public void pointcut() { 
        }
    
        @Around("pointcut()")
        public Object around(ProceedingJoinPoint joinPoint) throws Throwable { 
            
            HttpServletRequest request = RequestHolder.getHttpServletRequest();
            // 获取方法的Limit注解
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method signatureMethod = signature.getMethod();
            Limit limit = signatureMethod.getAnnotation(Limit.class);
            LimitType limitType = limit.limitType();
            String key = limit.key();
            if (StringUtils.isEmpty(key)) { 
                if (limitType == LimitType.IP) { 
                    key = StringUtils.getIp(request);
                } else { 
                    key = signatureMethod.getName();
                }
            }
    		// 通过方法或者ip 结合资源请求路径定义限流key
            ImmutableList<Object> keys = ImmutableList.of(StringUtils.join(limit.prefix(), "_", key, "_", request.getRequestURI().replaceAll("/","_")));
    		// Lua限流脚本
            String luaScript = buildLuaScript();
            RedisScript<Number> redisScript = new DefaultRedisScript<>(luaScript, Number.class);
            // Redis执行Lua脚本
            Number count = redisTemplate.execute(redisScript, keys, limit.count(), limit.period());
            // 判断是否超过访问次数
            if (null != count && count.intValue() <= limit.count()) { 
                logger.info("第{}次访问key为 {}，描述为 [{}] 的接口", count, keys, limit.name());
                return joinPoint.proceed();
            } else { 
                throw new BadRequestException("访问次数受限制");
            }
        }
    
        /** * Lua限流脚本 */
        private String buildLuaScript() { 
            return "local c" +
                    "\nc = redis.call('get',KEYS[1])" +
                    "\nif c and tonumber(c) > tonumber(ARGV[1]) then" +
                    "\nreturn c;" +
                    "\nend" +
                    "\nc = redis.call('incr',KEYS[1])" +
                    "\nif tonumber(c) == 1 then" +
                    "\nredis.call('expire',KEYS[1],ARGV[2])" +
                    "\nend" +
                    "\nreturn c;";
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center]: /images/20210724/71962ddae3db47c699612ab354acf2b3.png