Java之道系列：Annotation实现浅析

今天来研究研究Java的注解是如何实现的。最简单的，先来看看注解的class文件是什么样的。

class文件支持

直接看栗子，

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Ann0tation {
    String attr();
}

javap一下， 

Classfile /home/blues/Projects/just4fun/out/production/just4fun/me/kisimple/just4fun/Ann0tation.class
  Last modified Feb 10, 2015; size 432 bytes
  MD5 checksum d87c1a02d469944f093b8a1815add76f
  Compiled from "Ann0tation.java"
public interface me.kisimple.just4fun.Ann0tation extends java.lang.annotation.Annotation
  SourceFile: "Ann0tation.java"
  RuntimeVisibleAnnotations:
    0: #9(#10:[e#11.#12])
    1: #13(#10:e#14.#15)
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_INTERFACE, ACC_ABSTRACT, ACC_ANNOTATION
Constant pool:
   #1 = Class              #16;           // me/kisimple/just4fun/Ann0tation
   #2 = Class              #17;           //  java/lang/Object
   #3 = Class              #18;           //  java/lang/annotation/Annotation
   #4 = Utf8               attr;
   #5 = Utf8               ()Ljava/lang/String;;
   #6 = Utf8               SourceFile;
   #7 = Utf8               Ann0tation.java;
   #8 = Utf8               RuntimeVisibleAnnotations;
   #9 = Utf8               Ljava/lang/annotation/Target;;
  #10 = Utf8               value;
  #11 = Utf8               Ljava/lang/annotation/ElementType;;
  #12 = Utf8               METHOD;
  #13 = Utf8               Ljava/lang/annotation/Retention;;
  #14 = Utf8               Ljava/lang/annotation/RetentionPolicy;;
  #15 = Utf8               RUNTIME;
  #16 = Utf8               me/kisimple/just4fun/Ann0tation;
  #17 = Utf8               java/lang/Object;
  #18 = Utf8               java/lang/annotation/Annotation;
{
  public abstract java.lang.String attr();
    flags: ACC_PUBLIC, ACC_ABSTRACT
}

可以看到，所有的注解都继承了java.lang.annotation.Annotation这个接口， 

public interface me.kisimple.just4fun.Ann0tation extends java.lang.annotation.Annotation

接下来看下使用了注解后的class文件， 

public class Main {

    @Ann0tation(attr = "hello main.")
    public static void main(String[] args) throws Exception {
        Method mm = Main.class.getMethod("main", String[].class);
        for (Annotation anno : mm.getDeclaredAnnotations()) {
            if(anno instanceof Ann0tation) {
                System.out.println(((Ann0tation)anno).attr());
            }
        }
    }

}
  public static void main(java.lang.String[]) throws java.lang.Exception;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=6, locals=6, args_size=1
         0: ldc_w         #2;                 // class me/kisimple/just4fun/Main
         3: ldc           #3;                 // String main
         5: iconst_1
         6: anewarray     #4;                 // class java/lang/Class
         9: dup
        10: iconst_0
        11: ldc_w         #5;                 // class "[Ljava/lang/String;"
        14: aastore
        15: invokevirtual #6;                 // Method java/lang/Class.getMethod:(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;
        18: astore_1
        19: aload_1
        20: invokevirtual #7;                 // Method java/lang/reflect/Method.getDeclaredAnnotations:()[Ljava/lang/annotation/Annotation;
        23: astore_2
        24: aload_2
        25: arraylength
        26: istore_3
        27: iconst_0
        28: istore        4
        30: iload         4
        32: iload_3
        33: if_icmpge     72
        36: aload_2
        37: iload         4
        39: aaload
        40: astore        5
        42: aload         5
        44: instanceof    #8;                 // class me/kisimple/just4fun/Ann0tation
        47: ifeq          66
        50: getstatic     #9;                 // Field java/lang/System.out:Ljava/io/PrintStream;
        53: aload         5
        55: checkcast     #8;                 // class me/kisimple/just4fun/Ann0tation
        58: invokeinterface #10,  1;          // InterfaceMethod me/kisimple/just4fun/Ann0tation.attr:()Ljava/lang/String;
        63: invokevirtual #11;                // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        66: iinc          4, 1
        69: goto          30
        72: return
      LineNumberTable:
        line 13: 0
        line 14: 19
        line 15: 42
        line 16: 50
        line 14: 66
        line 19: 72
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
              42      24     5  anno   Ljava/lang/annotation/Annotation;
              24      48     2  arr$   [Ljava/lang/annotation/Annotation;
              27      45     3  len$   I
              30      42     4    i$   I
               0      73     0  args   [Ljava/lang/String;
              19      54     1    mm   Ljava/lang/reflect/Method;
      StackMapTable: number_of_entries = 3
           frame_type = 255 /* full_frame */
          offset_delta = 30
          locals = [ class "[Ljava/lang/String;", class java/lang/reflect/Method, class "[Ljava/lang/annotation/Annotation;", int, int ]
          stack = []
           frame_type = 35 /* same */
           frame_type = 248 /* chop */
          offset_delta = 5

    Exceptions:
      throws java.lang.Exception
    RuntimeVisibleAnnotations:
      0: #39(#40:s#41)

会发现最后多出来了RuntimeVisibleAnnotations这么一个属性，而它的值就是我们给main方法添加的注解， 

  #39 = Utf8               Lme/kisimple/just4fun/Ann0tation;;
  #40 = Utf8               attr;
  #41 = Utf8               hello main.;

其实在上面Ann0tation的class文件里面就有这个属性了，因为Ann0tation使用了Target跟Retention注解。关于该属性可以参考虚拟机规范。 
这么看下来，注解的定义与普通的接口其实并没有什么两样，只是编译器会在使用了注解的地方去添加一个RuntimeVisibleAnnotations属性，保存下我们添加的注解。这样即使在运行时，我们还是可以通过class文件来拿到我们添加的注解。

反射注解实例

既然注解只是个普通的接口，那么当我们使用反射去拿到的注解的实例（看上面的栗子）又是个什么鬼？看看源码就知道了。 
上面我们所调用的Method#getDeclaredAnnotations，最后是会去调用 
sun.reflect.annotation.AnnotationParser#parseAnnotations，

   /**
     * Parses the annotations described by the specified byte array.
     * resolving constant references in the specified constant pool.
     * The array must contain an array of annotations as described
     * in the RuntimeVisibleAnnotations_attribute:
     *
     *   u2 num_annotations;
     *   annotation annotations[num_annotations];
     *
     * @throws AnnotationFormatError if an annotation is found to be
     *         malformed.
     */
    public static Map<Class<? extends Annotation>, Annotation> parseAnnotations(
                byte[] rawAnnotations,
                ConstantPool constPool,
                Class<?> container) {
        if (rawAnnotations == null)
            return Collections.emptyMap();

        try {
            return parseAnnotations2(rawAnnotations, constPool, container, null);
        } catch(BufferUnderflowException e) {
            throw new AnnotationFormatError("Unexpected end of annotations.");
        } catch(IllegalArgumentException e) {
            // Type mismatch in constant pool
            throw new AnnotationFormatError(e);
        }
    }

注解的解析其实就是去处理上面我们所说到的class文件中的RuntimeVisibleAnnotations属性相关的一些东东。继续往下看，最后会来到annotationForMap方法， 

   public static Annotation annotationForMap(
        Class<? extends Annotation> type, Map<String, Object> memberValues)
    {
        return (Annotation) Proxy.newProxyInstance(
            type.getClassLoader(), new Class[] { type },
            new AnnotationInvocationHandler(type, memberValues));
    }

原来是使用动态代理实例化了一个注解的接口返回，那我们可以使用SA中的ClassDump把这个动态代理类dump下来，再用jd反编译看看，结果如下， 

package com.sun.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import me.kisimple.just4fun.Ann0tation;

public final class $Proxy1 extends Proxy
  implements Ann0tation
{
  private static Method m1;
  private static Method m3;
  private static Method m0;
  private static Method m4;
  private static Method m2;

  public $Proxy1(InvocationHandler paramInvocationHandler)
  {
    super(paramInvocationHandler);
  }

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("me.kisimple.just4fun.Ann0tation").getMethod("attr", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m4 = Class.forName("me.kisimple.just4fun.Ann0tation").getMethod("annotationType", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }

  public final boolean equals(Object paramObject)
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final String toString()
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final int hashCode()
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final Class annotationType()
  {
    try
    {
      return (Class)this.h.invoke(this, m4, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final String attr()
  {
    try
    {
      return (String)this.h.invoke(this, m3, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
}

而AnnotationInvocationHandler做的事情很简单，举上面的栗子，当我们调用((Ann0tation)anno).attr()时，AnnotationInvocationHandler直接从memberValues这个map取出来并返回，而这个map就是通过解析RuntimeVisibleAnnotations得到并传给AnnotationInvocationHandler的。 
所以就像R大说的，注解就是接口+Map，然后通过动态代理将他们组合起来就OK了^_^

参考资料

时间： 2024-10-03 19:52:08

Java之道系列：Annotation实现浅析的相关文章

Java之道系列：WeakHashMap实现浅析

举个栗子 关于Reference对象,java.lang.ref包的文档说了一堆,跑起来看看才是王道, public class Foo { @Override protected void finalize() throws Throwable { System.out.println("finalize#" + this); super.finalize(); } } private static ReferenceQueue<Foo> queue = new Refe

Java之道系列：BigDecimal如何解决浮点数精度问题

如题,今天我们来看下java.math.BigDecimal是如何解决浮点数的精度问题的,在那之前当然得先了解下浮点数精度问题是什么问题了.下面我们先从IEEE 754说起. IEEE 754 IEEE二进制浮点数算术标准(IEEE 754)是20世纪80年代以来最广泛使用的浮点数运算标准,为许多CPU与浮点运算器所采用.这个标准定义了表示浮点数的格式(包括负零-0)与反常值(denormal number)),一些特殊数值(无穷(Inf)与非数值(NaN)),以及这些数值的"浮点数运算符&qu

JAVA/JSP学习系列之八(改写MySQL翻页例子)

js|mysql|翻页 一.前言 其实,改写后的JDBC Data-Source是运行在Servlet中的,通过JNDI去查找数据源.我用Orion试的,将本站<JAVA/JSP学习系列之六(MySQL翻页例子) > 简单改写了一下. 二.配置 (1)JDBC 需要将用到的JDBC驱动Copy到[ORION]/lib目录下 (2)data-source 在[ORION]/config/data-sources.xml文件中加入如下: 〈data-source class="com.e

Java中注解（Annotation）的基本概念

什么是注解(Annotation): Annotation(注解)就是Java提供了一种元程序中的元素关联 任何信息和着任何元数据(metadata)的途径和方法.Annotion(注解)是一个接口,程序可以通过反射 来获取指定程序元素的Annotion对象,然后通过Annotion对象来获取注解里面的元数据. Annotation(注解)是JDK5.0及以后版本引入的.它可以用于创建文档,跟踪代码中的依赖性, 甚至执行基本编译时检查.从某些方面看,annotation就像修饰符一样被使用,并应

Java入门教程系列 – 开发环境搭建

原文http://go-learning.com/2012/05/23/java-gettingstart-1/ Java入门教程系列 – 开发环境搭建 Posted on 2012 年 5 月 23 日 by Johnny 在使用任何的计算机语言进行编程之前,你都需要搭建一个开发环境.简单的说,这个过程就是要安装一些开发 用的软件和进行相关的一些配置.每种计算机语言所需要的软件是不一样的,对于Java语言来说,你最少需要安装一个JDK (这是一个专有名称,要死记),JDK的全称叫 – Java

Java入门教程系列 – 第一个程序 “hello, world”

原文Java入门教程系列 – 第一个程序 "hello, world" Posted on 2012 年 5 月 25 日 by Johnny "Hello, World"程序指的是指在计算机屏幕上输出"Hello, World!"(意为"世界,你好!")这行字符串的计算机程序.一般来说,这是每一种计算机编程语言中最基本.最简单的程序,亦通常是初学者所编写的第 一个程序.它还可以用来确定该语言的编译器.程序开发环境,以及运行环

深入理解java内存模型系列文章

深入理解java内存模型系列文章是本人在InfoQ发表的并发编程的连载文章. 深入理解java内存模型(一)--基础 深入理解java内存模型(二)--重排序 深入理解java内存模型(三)--顺序一致性 深入理解java内存模型(四)--volatile 深入理解java内存模型(五)--锁 深入理解java内存模型(六)--final 深入理解java内存模型(七)--总结 提纲 java线程之间的通信对程序员完全透明,内存可见性问题很容易困扰java程序员,本文试图揭开java内存模型神秘

JAVA/JSP学习系列之六(MySQL翻页例子)_JSP编程

一.运行前准备 下载了mysql的jdbc驱动(一个jar文件)并加载在CLASSPATH(方法见<JAVA/JSP学习系列之一(JDK安装) >) (如果找不到,请从本站下载) 建一个MySQL数据库test 数据库中有一个表:note,字段为:name(varchar) 二.下载,安装 <%@ page contentType="text/html;charset=gb2312" %> <% java.sql.Connection sqlCon; //

JAVA/JSP学习系列之八(改写MySQL翻页例子)_JSP编程

一.前言 其实,改写后的JDBC Data-Source是运行在Servlet中的,通过JNDI去查找数据源.我用Orion试的,将本站<JAVA/JSP学习系列之六(MySQL翻页例子) > 简单改写了一下. 二.配置 (1)JDBC 需要将用到的JDBC驱动Copy到[ORION]/lib目录下 (2)data-source 在[ORION]/config/data-sources.xml文件中加入如下: 〈data-source class="com.evermind.sql.