认识 Java 注解

注解是 Java 1.5 版本加入的新特性。所有 Java 注解首先是一个接口。从定义注解的角度我们可以看出, 有关键字interface ，还有方法定义 String[] value()。default 字段 后面紧跟返回的默认常量。都实现了
java.lang.annotation.Annotation 接口 Class annotationType() 返回的是 注解的接口类型 Class。 我在研究反射的时候意外发现他其实就是接口的事实，之前我还以为 Java 1.5 只是引入了一个新概念，其实就是一个类而已。通过原有的技术实现。也可以把这种接口叫做 Annotation Interface 举例：

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
public @interface Component {

  /**
   * The value may indicate a suggestion for a logical component name, to be
   * turned into a bean in case of an autodetected component.
   *
   * @return the suggested component name, if any (or empty String otherwise)
   */
  String[] value() default {};
}

注解是接口的事实

我可以直接实现 Component 这个接口，覆盖实现接口方法。

public final class DefaultComponent implements Component {
  private String[] value = Constant.EMPTY_STRING_ARRAY;

  @Override
  public Class annotationType() {
    return Component.class;
  }

  @Override
  public String[] value() {
    return value;
  }
  // ......
}

Eclipse 提示不建议这样做。但不表示不行。上面直接证明了它就是接口。拥有类的所有特性。到这里它的原理也不难想到。肯定用来什么技术实现了这个注解接口。下文实现原理着重讲解。这个结论很重要，我认为对理解该特性（注解）有很大帮助。下文大多讨论都是基于该结论。

注解使用方法

用上文提到的注解 @Component 做例子。

@Component(value = { "userService" })
public class DefaultUserService implements UserService {
    final private UserDao userDao;

    @Autowired
    public DefaultUserService(UserDao userDao) {
        this.userDao = userDao;
    }
	// ……
}

上面的例子展示了将我们自定义的注解标注到了类上面，同时我们指定了 value 的值 userService。当然这个值是个数组。因为 String[] value() 返回值是数组。 上面的写法是标准写法还可以简写成：@Component("userService")。解释：Java 规定当这个方法名是 value 的时候括号里可以省略不写 value = , 仅仅填入值。如果方法返回值是数组且值只有一个，大括号 {} 也可以省略。 还有可以从上面的例子看出 @Autowired 注解标注在构造器上，看到这里我觉得它还可以使用在方法上，属性上（成员变量），甚至是局部变量上。是不是每个注解都可以随便标注在任何地方呢？这个说法不正确。应该是每个注解都具有这样的能力，但是要取决于 Java 的机制，Java规定使用 @
java.lang.annotation.Target 标注注解的使用范围。上面的例子中 Component 被 @Target({ ElementType.TYPE, ElementType.METHOD }) 标注。实际上还可以定义其他位置: 取决于 枚举类ElementType :

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,
    /** Field declaration (includes enum constants) */
    FIELD,
    /** Method declaration */
    METHOD,
    /** Formal parameter declaration */
    PARAMETER,
    /** Constructor declaration */
    CONSTRUCTOR,
    /** Local variable declaration */
    LOCAL_VARIABLE,
    /** Annotation type declaration */
    ANNOTATION_TYPE,
    /** Package declaration */
    PACKAGE,
    /**
     * Type parameter declaration
     */
    TYPE_PARAMETER,
    /**
     * Use of a type
     */
    TYPE_USE,
    /**
     * Module declaration.
     */
    MODULE
}

超出了指定的范围编译器在编译期间就会报错。注意 ElementType 不能重复。

Component 还有一个 @Retention 注解它表明了这个注解存在的范围, 取决于设置的
java.lang.annotation.RetentionPolicy枚举类。RetentionPolicy 枚举类有 3 个值 SOURCE,CLASS,RUNTIME。

• SOURCE 注解元数据只存在 Java 源文件，生成的字节码文件（.class文件）没有。
• CLASS 注解元数据不仅存在源文件还存在字节码文件，只是运行时读取不到。
• RUNTIME 在 CLASS 基础上能在运行时通过反射获取。 一个正常的注解不能少了上面的两个注解 @Target, @Retention

读取注解

读取之前我们不得不提到一个接口
java.lang.reflect.AnnotatedElement 该接口提供了访问注解的能力。凡是实现了该接口的实现类都可以访问对应注解实例。

从上图我们可以看到可以从类，方法，构造器，属性等地方获取注解。所以我可以在上面的例子中获取 @Component 实例。当然也可以说成：获取注解接口Component 的实现类实例对象。

public static void main(String[] args) {
  final Component component = DefaultUserService.class.getAnnotation(Component.class);
  final String[] values = component.value(); // 方法调用
  final String value = values[0];  // value 就是 userService
}

当然只要得到了对应的 AnnotatedElement 实例对象就可以得到对应位置的注解。

实现原理

注解获取本身就是得到类信息，这种在运行时获取类信息的就是反射技术。Java 默认实现了一套反射机制，放在 java.lang.reflect 包下。一个 Java 程序，反射技术贯穿整个应用。在第一次加载类到虚拟机的时候就用 ClassLoader 生成了 Class 对象。动态代理 java.lang.reflect.Proxy 用字节码技术动态生成接口子类使用InvocationHandler 处理方法调用。刚好在实现注解的功能的时候就用到了 Java 自己的动态代理， 用
sun.reflect.annotation.AnnotationInvocationHandler 处理注解里面的方法调用。返回对应的元数据。

AnnotationParser 注解解析器

Java 通过 AnnotationParser 在运行时解析字节码文件（.class文件）

public static Map<Class, 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);
  }
}

AnnotationInvocationHandler

最重要的来了,使用动态代理实现 Map memberValues 到注解对象的转换。

/**
 * Returns an annotation of the given type backed by the given
 * member {@literal ->} value map.
 */
public static Annotation annotationForMap(final Class type,
										  final Map memberValues)
{
	return AccessController.doPrivileged(new PrivilegedAction() {
		public Annotation run() {
			return (Annotation) Proxy.newProxyInstance(
				type.getClassLoader(), new Class[] { type },
				new AnnotationInvocationHandler(type, memberValues));
		}});
}