Java注解-一文就懂

Posted 2021-07-17 李子捌

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、图解注解

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;";
    }
}