Java注解-一文就懂

Java注解

1、概念

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

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 失败重试注解

定义注解

定义注解处理器 - 切面

@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 日志记录注解

定义注解处理器 - 切面

@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限流

注解定义

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

Java注解-一文就懂

4.2 日志记录注解

4.3 限流注解 - redis+lua限流

继续阅读

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

面试题解析：你接口测试是怎么做的？

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method