Java 注解 - 一文就懂，mysql 注入攻击原理
=====================================================================
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();
}
元注解的作用是负责注解其他注解。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 的子类
如果没有用来读取注解的方法和工作，那么注解也就不会比注释更有用处了。使用注解的过程中，很重要一部分就是创建用于使用注解的处理器。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 "";
}
}
}
评论