注解（Annotation）源码解析--简单实现（Hibernate，EJB，JPA）

注解提供了一种结构化的，并且具有类型检查能力的新途径，从而使程序员能够为代码加入元数据，而不会导致代码杂乱且难以理解。如：@Override 说明继承类或实现接口方法重载。

注解是在实际的源代码级别保存所有的信息，而不是某种注释性的文字。

在Hibernate，EJB，JPA中Column实现和应用程序案例：

Column.java

import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.METHOD,ElementType.FIELD}) // 目标可以指定的元素类型方法级别和域（属性）级别 @Retention(RetentionPolicy.RUNTIME) // 保留方针为运行时级别，注解可以在运行时通过反射获得 public @interface Column { String name() default ""; // default 关键字可以为name方法设置默认值 boolean unique() default false; boolean nullable() default true; boolean insertable() default true; boolean updateable() default true; String columnDefinition() default ""; String secondaryTable() default ""; int length() default 255; int precision() default 0; int scale() default 0; }

UseCase.java

import java.lang.reflect.Field; public class UseCase { @Column(name = "name", length = 20, unique = true) private String name; @Column(name = "description", length = 100) private String description; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public static void main(String[] args) { Field[] fields = UseCase.class.getDeclaredFields(); for (Field field : fields) { Column column = field.getAnnotation(Column.class); System.out.println(column.name() + " " + column.length() + " " + column.unique()); } } }

控制台显示的结果为：

name 20 true
description 100 false

应用程序简单应用源码解析：

1.Field[] fields = UseCase.class.getDeclaredFields();

通过反射，UseCase.class.getDeclaredFields()获得UseCase类的class对象的声明的域。

AnnotationParser.getDeclaredFields(...)方法

public Field[] getDeclaredFields() throws SecurityException { checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader()); // 检查类成员访问 return copyFields(privateGetDeclaredFields(false)); // 返回一份私有获得声明域的拷贝 }

2.for (Field field : fields) {...} // 遍历fields数组

3.Column column = field.getAnnotation(Column.class); // 获得域级别的注解Annotation @Column

AnnotationParser.getAnnotation(...)方法

public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { if (annotationClass == null) throw new NullPointerException(); return (T) declaredAnnotations().get(annotationClass);// 调用声明的注解方法，获得指定@Column类型的注解 }

AnnotationParser.declaredAnnotations(...)方法

private synchronized Map<Class, Annotation> declaredAnnotations() { if (declaredAnnotations == null) { declaredAnnotations = AnnotationParser.parseAnnotations( annotations, sun.misc.SharedSecrets.getJavaLangAccess(). getConstantPool(getDeclaringClass()), getDeclaringClass()); // 注解解析，annotations为byte[]，sun.misc.SharedSecrets.getJavaLangAccess(). // getConstantPool(getDeclaringClass()) 注入getDeclaringClass())即UseCase.class对象，获得Java语言访问的常量池 } return declaredAnnotations; }

AnnotationParser.parseAnnotations(...)方法

public static Map<Class, Annotation> parseAnnotations(byte[] paramArrayOfByte, ConstantPool paramConstantPool, Class paramClass) { // {code...} return parseAnnotations2(paramArrayOfByte, paramConstantPool, paramClass);// 调用parseAnnotations2方法 // {code...} }

AnnotationParser.parseAnnotations2(...)方法

private static Map<Class, Annotation> parseAnnotations2(byte[] paramArrayOfByte, ConstantPool paramConstantPool, Class paramClass) { LinkedHashMap localLinkedHashMap = new LinkedHashMap();// 声明一个链表的HashMap ByteBuffer localByteBuffer = ByteBuffer.wrap(paramArrayOfByte);// 将字节数组装入ByteBuffer中 int i = localByteBuffer.getShort() & 0xFFFF;// 获得localByteBuffer的大小 for (int j = 0; j < i; ++j) { Annotation localAnnotation = parseAnnotation(localByteBuffer, paramConstantPool, paramClass, false); //解析Annotation if (localAnnotation != null) { Class localClass = localAnnotation.annotationType(); AnnotationType localAnnotationType = AnnotationType.getInstance(localClass); // AnnotationType获得注解类型 if ((localAnnotationType.retention() != RetentionPolicy.RUNTIME) || (localLinkedHashMap.put(localClass, localAnnotation) == null)) continue; // 说明注解@Column的保留方针必须为RUNTIME级别，并将注解类型和注解对象放入localLinkedHashMap中 throw new AnnotationFormatError("Duplicate annotation for class: " + localClass + ": " + localAnnotation); } } return localLinkedHashMap; }

AnnotationParser.parseAnnotation(...)方法

private static Annotation parseAnnotation(ByteBuffer paramByteBuffer, ConstantPool paramConstantPool, Class paramClass, boolean paramBoolean) { int i = paramByteBuffer.getShort() & 0xFFFF; Class localClass1 = null; String str1 = paramConstantPool.getUTF8At(i);//获得Column localClass1 = parseSig(str1, paramClass);// 通过UseCase和Column解析得到@Column接口class对象 //{code...} AnnotationType localAnnotationType = AnnotationType.getInstance(localClass1);//获得注解类型@Column Map localMap = localAnnotationType.memberTypes();// 获得注解@Column的成员类型 LinkedHashMap localLinkedHashMap = new LinkedHashMap(localAnnotationType.memberDefaults()); //@Column的成员类型的默认值放入localLinkedHashMap int j = paramByteBuffer.getShort() & 0xFFFF; for (int k = 0; k < j; ++k) { int l = paramByteBuffer.getShort() & 0xFFFF; String str2 = paramConstantPool.getUTF8At(l);// 获得成员类型的名称如name Class localClass2 = (Class)localMap.get(str2); Object localObject = parseMemberValue(localClass2, paramByteBuffer, paramConstantPool, paramClass); //获得成员的值如name的值为"name" localLinkedHashMap.put(str2, localObject); //{code...} } return annotationForMap(localClass1, localLinkedHashMap); // 通过@Column.class对象和localLinkedHashMap创建@Column对象 }

AnnotationParser.annotationForMap(...)方法

public static Annotation annotationForMap(Class paramClass, Map<String, Object> paramMap) { return (Annotation)Proxy.newProxyInstance(paramClass.getClassLoader(), new Class[] { paramClass }, new AnnotationInvocationHandler(paramClass, paramMap)); // 创建@Column对象 }

看过源码实现之后，其实就是通过Java的反射机制和代理类来创建指定域（方法或者类）的注解接口对象以及他的属性。

其实，在Java中这些个东西好似很难实现（对‘自己’来说），但是你看看源代码，看看他的设计理念，也许也会有自己的一番见解和学习，了解Java的API的实现，这需要有耐心，要耐得住寂寞。