本文已参与 「掘力星计划」 ，赢取创作大礼包，挑战创作激励金。
highlight: a11y-dark
Java注解
1、概念
Annotation(注解)是Java提供的一种对元程序中元素关联信息和元数据(metadata)的途径和方法。Annotation(注解)是一个接口，程序可以通过反射来获取指定程序中元素的Annotation对象，然后通过该Annotation对象来获取注解中的元数据信息。
1// 定义一个简单测试注解
2@Target({ElementType.TYPE})
3@Retention(RetentionPolicy.RUNTIME)
4@Documented
5public @interface Limit {
6 String name() default "李子捌";
7}
jdk反编译注解
1## 执行命令
2javap Limit.class
3
4## 输出如下内容，可以发现注解其实就是一个接口，继承了Annotation
5public interface com.liziba.map.Limit extends java.lang.annotation.Annotation {
6 public abstract java.lang.String name();
7}
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 失败重试注解
定义注解
1/**
2 * <p>
3 * 失败重试
4 * </p>
5 * @Author: Liziba
6 */
7@Retention(RetentionPolicy.RUNTIME)
8@Target(ElementType.METHOD)
9@Documented
10@Component
11public @interface Retry {
12 /**
13 * 定义重试次数 默认一次
14 */
15 int value() default 1;
16 /**
17 * 定义重试间隔周期
18 */
19 int period() default 5000
20}
21
定义注解处理器 - 切面
1@Aspect
2@Component
3public class RetryAspect {
4
5 private final Logger logger = LoggerFactory.getLogger(this.getClass());
6
7 /**
8 * 针对com.liziba.web.controller下的方法抛出异常重试
9 * @param point
10 */
11 @AfterThrowing(pointcut=("execution(* com.liziba.web.service.impl.RetryHttpRequestClient.*(..)) && @annotation(com.liziba.web.annotation.Retry)"))
12 public void tryAgain(JoinPoint point) {
13 logger.info("------------开始重试------------");
14 try {
15 // 获取方法上定义的Retry注解
16 MethodSignature methodSignature = (MethodSignature) point.getSignature();
17 Retry retry = methodSignature.getMethod().getAnnotation(Retry.class);
18 // ThreadLocal做线程隔离 times记录已经重试的次数
19 Object object = point.getTarget();
20 Field field = object.getClass().getDeclaredField("threadLocal");
21 field.setAccessible(true);
22 ThreadLocal<Map<String, Object>> threadLocal = (ThreadLocal<Map<String, Object>>) field.get(object);
23 Map<String, Object> threadLocalMap = threadLocal.get();
24 AtomicInteger times = (AtomicInteger)threadLocalMap.get("times");
25 // 重试 -1一直循环
26 if (retry.value() == -1 || (times.intValue() < retry.value())) {
27 logger.info("开始重试第"+ index + "次");
28 int index = times.incrementAndGet();
29 MethodInvocationProceedingJoinPoint methodPoint = ((MethodInvocationProceedingJoinPoint) point);
30 methodPoint.proceed();
31 } else {
32 // 数据库服务异常捕获，防止异常中异常导致StackOverFlowError
33 try {
34 // ToDo
35 // 此处可以保存到数据库，做周期性失败重试，重试次数达到阈值后通过消息平台通知到运维及时处理异常任务
36 // 移除threadLocal，防止线程生命周期过长导致内存泄露
37 threadLocal.remove();
38 } catch (Exception e) {
39 e.printStackTrace();
40 }
41 }
42 } catch (Throwable throwable) {
43 logger.error(throwable.getMessage(),throwable);
44 // 失败后继续重试
45 tryAgain(point);
46 }
47 }
48}
4.2 日志记录注解
定义注解
1@Target(ElementType.METHOD)
2@Retention(RetentionPolicy.RUNTIME)
3public @interface Log {
4
5 String value() default "";
6
7 /**
8 * 是否启用
9 */
10 boolean enable() default true;
11
12 LogActionType type() default LogActionType.SELECT;
13}
日志类型
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;";
}
}
