写点什么

一文读懂注解的底层原理

作者:老周聊架构
  • 2023-04-14
    广东
  • 本文字数:8815 字

    阅读完需:约 29 分钟

一、前言

上一篇我们说了注解、元注解以及自定义注解,请戳:https://xie.infoq.cn/article/47b6fb6463a41907f3dd190c3


注解的声明如下:


{InterfaceModifier} @interface Identifier AnnotationTypeBody 接口修饰符 @interface 注解标识符 注解类型的内容


其中:


  • 注解类型声明中的标识符指定了注解类型的名称。

  • 如果注解类型与它的任何封闭类或接口具有相同的简单名称,则编译时会出现错误。

  • 每个注解类型的直接父接口都是 java.lang.annotation.Annotation。

二、注解的底层实现

我们来自定义一个流控 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_ANNOTATIONConstant 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.lang.annotation.Annotation 父接口。

  • @RateLimit 自身定义了一个抽象方法 public abstract int value(); 。


既然注解最后转化为一个接口,注解中定义的注解成员属性会转化为抽象方法,那么最后这些注解成员属性怎么进行赋值的呢?


答案就是:为注解对应的接口生成一个实现该接口的动态代理类。


直接点就是: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 calledprivate 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);}
复制代码


整个的处理逻辑是:


  • 获取类本身的 declaredAnnotations

  • 获取父类的 annotations

  • 将 declaredAnnotations+annotations 整合,返回


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 切面织入底层是如何实现的呢?”的这个疑问,敬请期待~


发布于: 刚刚阅读数: 4
用户头像

🏆 InfoQ写作平台-签约作者 🏆 2019-03-07 加入

微信公众号:老周聊架构

评论

发布
暂无评论
一文读懂注解的底层原理_三周年连更_老周聊架构_InfoQ写作社区