一、前言
上一篇我们说了注解、元注解以及自定义注解,请戳:https://xie.infoq.cn/article/47b6fb6463a41907f3dd190c3
注解的声明如下:
{InterfaceModifier} @interface Identifier AnnotationTypeBody 接口修饰符 @interface 注解标识符 注解类型的内容
其中:
二、注解的底层实现
我们来自定义一个流控 RateLimit 注解,如下:
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target(ElementType.TYPE)
public @interface RateLimit {
int value() default 0;
}
复制代码
我们用反射获取 RateLimit 注解,然后断点调试观察下反射究竟是怎么样的魔力。
@RateLimit(value = 666)
public class RateLimitMain {
public static void main(String[] args) {
RateLimit rateLimit = RateLimitMain.class.getAnnotation(RateLimit.class);
System.out.println(rateLimit.value());
}
}
复制代码
断点调试 @RateLimit 过程中,发现它是一个代理类。
为了验证这一点我们使用 JDK 的反编译命令查看 @RateLimit 的字节码:
javap -c -v RateLimit.class
复制代码
@RateLimit 反编译后的字节码如下:
Classfile /Users/Riemann/Code/spring-boot-demo/target/classes/com/riemann/springbootdemo/annotation/RateLimit.class
Last modified 2021-3-23; size 495 bytes
MD5 checksum 1ce59bd6cc4c7297e8d3f032320b04d3
Compiled from "RateLimit.java"
public interface com.riemann.springbootdemo.annotation.RateLimit extends java.lang.annotation.Annotation
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_INTERFACE, ACC_ABSTRACT, ACC_ANNOTATION
Constant pool:
#1 = Class #18 // com/riemann/springbootdemo/annotation/RateLimit
#2 = Class #19 // java/lang/Object
#3 = Class #20 // java/lang/annotation/Annotation
#4 = Utf8 value
#5 = Utf8 ()I
#6 = Utf8 AnnotationDefault
#7 = Integer 0
#8 = Utf8 SourceFile
#9 = Utf8 RateLimit.java
#10 = Utf8 RuntimeVisibleAnnotations
#11 = Utf8 Ljava/lang/annotation/Retention;
#12 = Utf8 Ljava/lang/annotation/RetentionPolicy;
#13 = Utf8 RUNTIME
#14 = Utf8 Ljava/lang/annotation/Documented;
#15 = Utf8 Ljava/lang/annotation/Target;
#16 = Utf8 Ljava/lang/annotation/ElementType;
#17 = Utf8 TYPE
#18 = Utf8 com/riemann/springbootdemo/annotation/RateLimit
#19 = Utf8 java/lang/Object
#20 = Utf8 java/lang/annotation/Annotation
{
public abstract int value();
descriptor: ()I
flags: ACC_PUBLIC, ACC_ABSTRACT
AnnotationDefault:
default_value: I#7}
SourceFile: "RateLimit.java"
RuntimeVisibleAnnotations:
0: #11(#4=e#12.#13)
1: #14()
2: #15(#4=[e#16.#17])
复制代码
从上述字节码可以看出:
既然注解最后转化为一个接口,注解中定义的注解成员属性会转化为抽象方法,那么最后这些注解成员属性怎么进行赋值的呢?
答案就是:为注解对应的接口生成一个实现该接口的动态代理类。
直接点就是:Java 通过动态代理的方式生成了一个实现了"注解对应接口"的实例,该代理类实例实现了"注解成员属性对应的方法",这个步骤类似于"注解成员属性"的赋值过程,这样子就可以在程序运行的时候通过反射获取到注解的成员属性(这里注解必须是运行时可见的,也就是使用了 @Retention(RetentionPolicy.RUNTIME),另外动态代理相关知识这里就不展开讲,留在下一篇讲)。
到这里就解决了上一篇的疑问了,注解的值是如何获取到的,现在恍然大悟。
本着科学严谨的态度,我们还是来瞅一瞅那个代理类是如何获取到注解上的值的。
三、揭秘注解背后的代理类
注解的最底层实现就是一个 JDK 的动态代理类,而这个动态代理类的生成过程在 Debug 面前一览无余。
JDK 中是通过 AnnotatedElement(package java.lang.reflect)接口实现对注解的解析,我们的 Class 类实现了 AnnotatedElement 接口。
public final class Class<T> implements java.io.Serializable,
GenericDeclaration,
Type,
AnnotatedElement {
...
}
复制代码
AnnotatedElement 代码:
AnnotatedElement 的注释:
Represents an annotated element of the program currently running in this VM. This interface allows annotations to be read reflectively.
翻译过来就是:
AnnotatedElement 代表了 jvm 中一个正在运行的被注解元素,这个接口允许通过反射的方式读取注解。
可以看下 Class 类中对于 AnnotatedElement 接口都是如何实现的:
我们这就跟着 Debug 来看下 getAnnotation 方法
根据注解的 class 实例从类的注解缓存数据中获取匹配的注解类型
RateLimit 是注解类型,RateLimit.getClass() 获取到的就是 Class 实例
1、Class<?>#getAnnotation(Class<A> annotationClass)
,通过类型获取注解实例。
public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
Objects.requireNonNull(annotationClass);
return (A) annotationData().annotations.get(annotationClass);
}
复制代码
2、代码中 annotationData().annotations
是一个 Map(key 为注解的 Class 实例,value 为注解类型)。
// annotation data that might get invalidated when JVM TI RedefineClasses() is called
private static class AnnotationData {
final Map<Class<? extends Annotation>, Annotation> annotations;
final Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
// Value of classRedefinedCount when we created this AnnotationData instance
final int redefinedCount;
AnnotationData(Map<Class<? extends Annotation>, Annotation> annotations,
Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
int redefinedCount) {
this.annotations = annotations;
this.declaredAnnotations = declaredAnnotations;
this.redefinedCount = redefinedCount;
}
}
复制代码
3、Class<?>#annotationData()
,获取注解的数据。
private AnnotationData annotationData() {
while (true) { // retry loop
AnnotationData annotationData = this.annotationData;
int classRedefinedCount = this.classRedefinedCount;
if (annotationData != null &&
annotationData.redefinedCount == classRedefinedCount) {
return annotationData;
}
// null or stale annotationData -> optimistically create new instance
AnnotationData newAnnotationData = createAnnotationData(classRedefinedCount);
// try to install it
if (Atomic.casAnnotationData(this, annotationData, newAnnotationData)) {
// successfully installed new AnnotationData
return newAnnotationData;
}
}
}
复制代码
核心的逻辑是:当 this.annotationData 为空,解析类中的 annotationData 并写入 this.annotationData,最后都会返回 this.annotationData。
4、其中 Atomic.casAnnotationData(this, annotationData, newAnnotationData)
的作用便是将解析到的 annotationData 写入 this.annotationData 。
static <T> boolean casAnnotationData(Class<?> clazz,
AnnotationData oldData,
AnnotationData newData) {
return unsafe.compareAndSwapObject(clazz, annotationDataOffset, oldData, newData);
}
复制代码
其中 unsafe.compareAndSwapObject 是一个 native 方法
5、createAnnotationData(classRedefinedCount)
的作用是解析类中用到的 annotationData
private AnnotationData createAnnotationData(int classRedefinedCount) {
Map<Class<? extends Annotation>, Annotation> declaredAnnotations =
AnnotationParser.parseAnnotations(getRawAnnotations(), getConstantPool(), this);
Class<?> superClass = getSuperclass();
Map<Class<? extends Annotation>, Annotation> annotations = null;
if (superClass != null) {
Map<Class<? extends Annotation>, Annotation> superAnnotations =
superClass.annotationData().annotations;
for (Map.Entry<Class<? extends Annotation>, Annotation> e : superAnnotations.entrySet()) {
Class<? extends Annotation> annotationClass = e.getKey();
if (AnnotationType.getInstance(annotationClass).isInherited()) {
if (annotations == null) { // lazy construction
annotations = new LinkedHashMap<>((Math.max(
declaredAnnotations.size(),
Math.min(12, declaredAnnotations.size() + superAnnotations.size())
) * 4 + 2) / 3
);
}
annotations.put(annotationClass, e.getValue());
}
}
}
if (annotations == null) {
// no inherited annotations -> share the Map with declaredAnnotations
annotations = declaredAnnotations;
} else {
// at least one inherited annotation -> declared may override inherited
annotations.putAll(declaredAnnotations);
}
return new AnnotationData(annotations, declaredAnnotations, classRedefinedCount);
}
复制代码
整个的处理逻辑是:
6、AnnotationParser#parseAnnotations(byte[] var0, ConstantPool var1, Class<?> var2)
这里已经是 sun 包下的类,这个方法用于解析注解,这一步使用到字节码中常量池的索引解析,常量解析完毕会生成一个成员属性键值对作为下一个环节的入参,常量池的解析可以看AnnotationParser#parseMemberValue
方法。
public static Object parseMemberValue(Class<?> var0, ByteBuffer var1, ConstantPool var2, Class<?> var3) {
Object var4 = null;
byte var5 = var1.get();
switch(var5) {
case 64:
var4 = parseAnnotation(var1, var2, var3, true);
break;
case 91:
return parseArray(var0, var1, var2, var3);
case 99:
var4 = parseClassValue(var1, var2, var3);
break;
case 101:
return parseEnumValue(var0, var1, var2, var3);
default:
var4 = parseConst(var5, var1, var2);
}
if (!(var4 instanceof ExceptionProxy) && !var0.isInstance(var4)) {
var4 = new AnnotationTypeMismatchExceptionProxy(var4.getClass() + "[" + var4 + "]");
}
return var4;
}
复制代码
7、AnnotationParser#annotationForMap(final Class<? extends Annotation> var0, final Map<String, Object> var1)
同样是sun.reflect.annotation.AnnotationParser
中的方法,用于生成注解的动态代理类。
public static Annotation annotationForMap(final Class<? extends Annotation> var0, final Map<String, Object> var1) {
return (Annotation)AccessController.doPrivileged(new PrivilegedAction<Annotation>() {
public Annotation run() {
return (Annotation)Proxy.newProxyInstance(var0.getClassLoader(), new Class[]{var0}, new AnnotationInvocationHandler(var0, var1));
}
});
}
复制代码
熟悉 JDK 动态代理的这里的代码应该看起来很简单,就是生成一个标准的 JDK 动态代理,而 InvocationHandler 的实例是 AnnotationInvocationHandler,可以看它的成员变量、构造方法和实现 InvocationHandler 接口的 invoke 方法:
class AnnotationInvocationHandler implements InvocationHandler, Serializable {
private static final long serialVersionUID = 6182022883658399397L;
// 保存了当前注解的类型
private final Class<? extends Annotation> type;
// 保存了注解的成员属性的名称和值的映射,注解成员属性的名称实际上就对应着接口中抽象方法的名称
private final Map<String, Object> memberValues;
private transient volatile Method[] memberMethods = null;
AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
Class[] var3 = var1.getInterfaces();
if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class) {
this.type = var1;
this.memberValues = var2;
} else {
throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
}
}
public Object invoke(Object var1, Method var2, Object[] var3) {
// 获取当前执行的方法名称
String var4 = var2.getName();
Class[] var5 = var2.getParameterTypes();
if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
return this.equalsImpl(var3[0]);
} else if (var5.length != 0) {
throw new AssertionError("Too many parameters for an annotation method");
} else {
byte var7 = -1;
switch(var4.hashCode()) {
case -1776922004:
if (var4.equals("toString")) {
var7 = 0;
}
break;
case 147696667:
if (var4.equals("hashCode")) {
var7 = 1;
}
break;
case 1444986633:
if (var4.equals("annotationType")) {
var7 = 2;
}
}
switch(var7) {
case 0:
return this.toStringImpl();
case 1:
return this.hashCodeImpl();
case 2:
return this.type;
default:
// 利用方法名称从memberValues获取成员属性的赋值
Object var6 = this.memberValues.get(var4);
if (var6 == null) {
throw new IncompleteAnnotationException(this.type, var4);
} else if (var6 instanceof ExceptionProxy) {
throw ((ExceptionProxy)var6).generateException();
} else {
// 这一步就是注解成员属性返回值获取的实际逻辑
// 需要判断是否是数组,如果是数组需要克隆一个数组
// 不是数组直接返回
if (var6.getClass().isArray() && Array.getLength(var6) != 0) {
var6 = this.cloneArray(var6);
}
return var6;
}
}
}
}
...
}
复制代码
既然知道了注解底层使用了 JDK 原生的 Proxy,那么我们可以直接输出代理类到指定目录去分析代理类的源码,有两种方式可以输出 Proxy 类的源码:
通过 Java 系统属性设置:System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
。
通过 -D 参数指定,参数是:-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true
。
这里使用方式 1,修改一下上面用到的 RateLimitMain 方法:
@RateLimit(value = 666)
public class RateLimitMain {
public static void main(String[] args) {
System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
RateLimit rateLimit = RateLimitMain.class.getAnnotation(RateLimit.class);
System.out.println(rateLimit.value());
}
}
复制代码
执行完毕之后,项目中多了一个目录:
其中 $Proxy0
是 @Retention 注解对应的动态代理类,而 $Proxy1
才是我们的 @RateLimit 对应的动态代理类,当然如果有更多的注解,那么有可能生成 $ProxyN
。接着我们直接看 $Proxy1
的源码:
public final class $Proxy1 extends Proxy implements RateLimit {
private static Method m1;
private static Method m2;
private static Method m4;
private static Method m0;
private static Method m3;
public $Proxy1(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final Class annotationType() throws {
try {
return (Class)super.h.invoke(this, m4, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int value() throws {
try {
return (Integer)super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m4 = Class.forName("com.riemann.springbootdemo.annotation.RateLimit").getMethod("annotationType");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
m3 = Class.forName("com.riemann.springbootdemo.annotation.RateLimit").getMethod("value");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
复制代码
显然,$Proxy1
实现了 RateLimit 接口,它在代码的最后部分使用了静态代码块实例化了成员方法的 Method 实例,在前面的代码对这些 Method 进行了缓存,在调用成员方法的时候都是直接委托到 InvocationHandler(AnnotationInvocationHandler) 实例完成调用。我们在分析 AnnotationInvocationHandler 的时候看到,它只用到了 Method 的名称从 Map 从匹配出成员方法的结果,因此调用过程并不是反射调用,反而是直接的调用,效率类似于通过 Key 从 Map 实例中获取 Value 一样,是十分高效的。
好了,这一篇显然解决了上一篇“注解是如何通过反射获取值的呢?”的疑问,下一篇来说一下“AOP 切面织入底层是如何实现的呢?”的这个疑问,敬请期待~
评论