1.概念講解
(轉載自：https://www.cnblogs.com/lyy-2016/p/6288535.html)
元注解是指注解的注解，包括@Retention @Target @Document @Inherited四種。
[email protected]: 定義注解的保留政策@Retention(RetentionPolicy.SOURCE) //注解僅存在于源碼中，在class位元組碼檔案中不包含@Retention(RetentionPolicy.CLASS) // 預設的保留政策，注解會在class位元組碼檔案中存在，但運作時無法獲得，@Retention(RetentionPolicy.RUNTIME) // 注解會在class位元組碼檔案中存在，在運作時可以通過反射擷取到首 先要明确生命周期長度 SOURCE < CLASS < RUNTIME ，是以前者能作用的地方後者一定也能作用。一般如果需要在運作時去動态擷取注解資訊，那隻能用 RUNTIME 注解；如果要在編譯時進行一些預處理操作，比如生成一些輔助代碼(如 ButterKnife)，就用 CLASS注解；如果隻是做一些檢查性的操作，比如 @Override 和 @SuppressWarnings，則可選用 SOURCE 注解。
[email protected]：定義注解的作用目标源碼為：@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Target { ElementType[] value(); } @Target(ElementType.TYPE) //接口、類、枚舉、注解@Target(ElementType.FIELD) //字段、枚舉的常量@Target(ElementType.METHOD) //方法@Target(ElementType.PARAMETER) //方法參數@Target(ElementType.CONSTRUCTOR) //構造函數@Target(ElementType.LOCAL_VARIABLE)//局部變量@Target(ElementType.ANNOTATION_TYPE)//注解@Target(ElementType.PACKAGE) ///包 [email protected]：說明該注解将被包含在javadoc中[email protected]：說明子類可以繼承父類中的該注解
2.反射擷取注解
舉例：
// 适用類、接口(包括注解類型)或枚舉
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ClassInfo {
String value();
}
// 适用field屬性，也包括enum常量
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface FieldInfo {
int[] value();
}
// 适用方法
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodInfo {
String name() default "long";
String data();
int age() default 27;
}
這3個注解分别适用于不同的元素，并都帶有不同的屬性，在使用注解是需要設定這些屬性值。再定義一個測試類來使用這些注解：
@ClassInfo("Test Class")
public class TestRuntimeAnnotation {
@FieldInfo(value = {1, 2})
public String fieldInfo = "FiledInfo";
@FieldInfo(value = {10086})
public int i = 100;
@MethodInfo(name = "BlueBird", data = "Big")
public static String getMethodInfo() {
return TestRuntimeAnnotation.class.getSimpleName();
}
}
在代碼中擷取注解資訊：
private void _testRuntimeAnnotation() {
StringBuffer sb = new StringBuffer();
Class> cls = TestRuntimeAnnotation.class;
Constructor>[] constructors = cls.getConstructors();
// 擷取指定類型的注解
sb.append("Class注解：").append("\n");
ClassInfo classInfo = cls.getAnnotation(ClassInfo.class);
if (classInfo != null) {
sb.append(Modifier.toString(cls.getModifiers())).append(" ")
.append(cls.getSimpleName()).append("\n");
sb.append("注解值: ").append(classInfo.value()).append("\n\n");
}
sb.append("Field注解：").append("\n");
Field[] fields = cls.getDeclaredFields();
for (Field field : fields) {
FieldInfo fieldInfo = field.getAnnotation(FieldInfo.class);
if (fieldInfo != null) {
sb.append(Modifier.toString(field.getModifiers())).append(" ")
.append(field.getType().getSimpleName()).append(" ")
.append(field.getName()).append("\n");
sb.append("注解值: ").append(Arrays.toString(fieldInfo.value())).append("\n\n");
}
}
sb.append("Method注解：").append("\n");
Method[] methods = cls.getDeclaredMethods();
for (Method method : methods) {
MethodInfo methodInfo = method.getAnnotation(MethodInfo.class);
if (methodInfo != null) {
sb.append(Modifier.toString(method.getModifiers())).append(" ")
.append(method.getReturnType().getSimpleName()).append(" ")
.append(method.getName()).append("\n");
sb.append("注解值: ").append("\n");
sb.append("name: ").append(methodInfo.name()).append("\n");
sb.append("data: ").append(methodInfo.data()).append("\n");
sb.append("age: ").append(methodInfo.age()).append("\n");
}
}
System.out.print(sb.toString());
}
3.Java源代碼如何處理注解
(轉載自：https://www.jianshu.com/p/e9329c8a59c2 作者：測試你個頭)
jdk中是通過AnnotatedElement(package java.lang.reflect)接口實作對注解的解析，我們的Class類實作了AnnotatedElement接口
public final class Class 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接口都是如何實作的：
@SuppressWarnings("unchecked")
public A getAnnotation(Class annotationClass) {
Objects.requireNonNull(annotationClass);
return (A) annotationData().annotations.get(annotationClass);
}
@Override
public boolean isAnnotationPresent(Class extends Annotation> annotationClass) {
return GenericDeclaration.super.isAnnotationPresent(annotationClass);
}
@Override
public A[] getAnnotationsByType(Class annotationClass) {
Objects.requireNonNull(annotationClass);
AnnotationData annotationData = annotationData();
return AnnotationSupport.getAssociatedAnnotations(annotationData.declaredAnnotations,
this,
annotationClass);
}
public Annotation[] getAnnotations() {
return AnnotationParser.toArray(annotationData().annotations);
}
@Override
@SuppressWarnings("unchecked")
public A getDeclaredAnnotation(Class annotationClass) {
Objects.requireNonNull(annotationClass);
return (A) annotationData().declaredAnnotations.get(annotationClass);
}
@Override
public A[] getDeclaredAnnotationsByType(Class annotationClass) {
Objects.requireNonNull(annotationClass);
return AnnotationSupport.getDirectlyAndIndirectlyPresent(annotationData().declaredAnnotations,
annotationClass);
}
public Annotation[] getDeclaredAnnotations() {
return AnnotationParser.toArray(annotationData().declaredAnnotations);
}
上面的接口實作中，大緻的原理都是一緻的，我們挑選其中的getAnnotation方法來講解：
getAnnotation
根據注解的class執行個體從類的注解緩存資料中擷取比對的注解類型
Controller是注解類型，Controller.getClass()擷取到的就是Class執行個體
1、代碼中annotationData().annotations是一個Map(key為注解的Class執行個體，value為注解類型)，源碼為：
// annotation data that might get invalidated when JVM TI RedefineClasses() is called
private static class AnnotationData {
final Map, Annotation> annotations;
final Map, Annotation> declaredAnnotations;
// Value of classRedefinedCount when we created this AnnotationData instance
final int redefinedCount;
AnnotationData(Map, Annotation> annotations,
Map, Annotation> declaredAnnotations,
int redefinedCount) {
this.annotations = annotations;
this.declaredAnnotations = declaredAnnotations;
this.redefinedCount = redefinedCount;
}
}
2、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
3、其中Atomic.casAnnotationData(this, annotationData, newAnnotationData)的作用便是将解析到的annotationData寫入this.annotationData：
static boolean casAnnotationData(Class> clazz,
AnnotationData oldData,
AnnotationData newData) {
return unsafe.compareAndSwapObject(clazz, annotationDataOffset, oldData, newData);
}
其中unsafe.compareAndSwapObject是一個native方法
4、而createAnnotationData(classRedefinedCount)的作用是解析類中用到的annotationData
private AnnotationData createAnnotationData(int classRedefinedCount) {
Map, Annotation> declaredAnnotations =
AnnotationParser.parseAnnotations(getRawAnnotations(), getConstantPool(), this);
Class> superClass = getSuperclass();
Map, Annotation> annotations = null;
if (superClass != null) {
Map, Annotation> superAnnotations =
superClass.annotationData().annotations;
for (Map.Entry, 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);
}
整個的處理邏輯是：
1、擷取類本身的declaredAnnotations
2、擷取父類的annotations
3、将declaredAnnotations+annotations整合，傳回
Annotation解析的範例代碼：
@Component
public class SSHClient {
......
}
public class AnnotationHelper {
public static void main(String[] args) {
Annotation[] annotations = new Annotation[0];
annotations = SSHClient.class.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation.toString());
System.out.println(annotation.annotationType());
System.out.println(annotation.getClass().getName());
System.out.println(annotation.getClass().getTypeName());
System.out.println(annotation.getClass().toString());
}
if (SSHClient.class.isAnnotationPresent(Component.class)) {
System.out.println("find Component annotation");
}
Annotation annotation = SSHClient.class.getAnnotation(Component.class);
System.out.println(annotation.toString());
System.out.println(annotation.annotationType());
System.out.println(annotation.getClass().getName());
System.out.println(annotation.getClass().getTypeName());
System.out.println(annotation.getClass().toString());
}
}
執行結果:
可以看到，通過Annotation接口中定義的annotationType()可以擷取Annotation的類型
實際應用中，比如spring架構中對注解的解析有專門的工具類，但是都是基于AnnotatedElement中定義的方法來實作的
以上，就是整個元注解和注解解析相關的講解。