?概述
注解想必大家在項(xiàng)目中經(jīng)常使用，比如Spring框架中常用的一些注解：@Controller、@Service、@RequestMapping等等，它是JDK1.5及以后版本引入的一個(gè)特性。它可以聲明在包、類、字段、方法、局部變量、方法參數(shù)等的前面，用來對(duì)這些元素進(jìn)行說明，注釋。那么你知道JDK什么是元注解嗎？注解有哪些分類嗎？以及注解在Java中最本質(zhì)究竟是什么東西，是如何實(shí)現(xiàn)的呢？
注解的分類
根據(jù)注解的使用場景，主要分為三類，元注解、內(nèi)置注解和自定義注解。
元注解
用于定義注解的注解，通常用于注解的定義上，標(biāo)明該注解的使用范圍、生效范圍等。簡而言之，元注解是用來修飾注解的。
@Retention
指定注解信息保留到哪個(gè)階段，分別為源代碼階段、編譯Class階段、運(yùn)行階段。
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
/**
* Returns the retention policy.
* @return the retention policy
*/
RetentionPolicy value();
}
- SOURCE: 保留在源代碼java中，被編譯器丟棄，也就是說在class文件中不包含注解信息，通常用來標(biāo)記源碼，引起大家的注意，比如自定義一個(gè)注解例如@ThreadSafe，用來標(biāo)識(shí)一個(gè)類時(shí)線程安全的。
- CLASS： 編譯后的class文件中包含注解信息，但是會(huì)被jvm丟棄
- RUNTIME: 注解信息在運(yùn)行期(JVM)保留（.class也有），可以通過反射機(jī)制讀取注解的信息
@Target
指定注解的使用范圍，如類、方法、屬性、局部屬性、參數(shù)等, 可以多選。
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
/**
* Returns an array of the kinds of elements an annotation type
* can be applied to.
* @return an array of the kinds of elements an annotation type
* can be applied to
*/
ElementType[] value();
}
具體可選的枚舉如下：
public enum ElementType {
/** 適用范圍：類、接口、注解類型，枚舉類型enum */
TYPE,
/** 作用于類屬性 (includes enum constants) */
FIELD,
/** 作用于方法 */
METHOD,
/** 作用于參數(shù)聲明 */
PARAMETER,
/** 作用于構(gòu)造函數(shù)聲明 */
CONSTRUCTOR,
/** 作用于局部變量聲明 */
LOCAL_VARIABLE,
/** 作用于注解聲明 */
ANNOTATION_TYPE,
/** 作用于包聲明 */
PACKAGE,
/** 作用于類型參數(shù)（泛型參數(shù)）聲明 */
TYPE_PARAMETER,
/** 作用于使用類型的任意語句(不包括class) */
TYPE_USE
}@Inherited
加上該注解的注解，表示可以被標(biāo)注的類子類繼承，比如A上標(biāo)記了帶有@Inherited的注解，那么類B繼承了A, 那么B也會(huì)有這個(gè)注解，默認(rèn)情況下注解是不支持繼承的。
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}
@Document
將此注解包含在 javadoc 中 ，它代表著此注解會(huì)被javadoc工具提取成文檔。
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}
@Repeatable
1.8中加入的元注解，用來標(biāo)記是否可以重復(fù)標(biāo)記。
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {
/**
* Indicates the <em>containing annotation type</em> for the
* repeatable annotation type.
* @return the containing annotation type
*/
Class<? extends Annotation> value();
}
內(nèi)置注解
java提供了一些內(nèi)置注解，可以配合編譯器來檢查代碼的正確性, 我們可以關(guān)注他們的元注解。
@Override
標(biāo)記當(dāng)前方法是覆寫父類的方法。
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
@Deprecated
標(biāo)記一個(gè)元素為已過期，不要在使用了
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
@SuppressWarnings
用來關(guān)閉編譯器輸出的警告信息
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
String[] value();
}@FunctionalInterface
java8中引入，標(biāo)記是一個(gè)函數(shù)式接口，也就是說有且只有一個(gè)抽象方法的接口
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}
自定義注解
注解遵循的格式一般如下：
//元注解部分 xxxx
@Retention(xxxx)
@Target(xxxx)
public @interface 注解名 {
返回值 屬性名() 默認(rèn)值;
返回值 屬性名() 默認(rèn)值;
}
- 返回值支持的類型如下：java的8種基礎(chǔ)類型（不支持包裝類型）、String、Class、Enum、Annotation、以及上面類型的數(shù)組。
- 默認(rèn)值可選，非必有。
舉個(gè)項(xiàng)目中自定義的栗子：
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataAuthorize {
/**
* 資產(chǎn)ID
* @return
*/
String assetId();
/**
* 資產(chǎn)類型
* @return
*/
String assetType();
/**
* 權(quán)限代碼
* @return
*/
String authCode() default "";
/**
* 使用的類型
* @return
*/
Class[] useType();
}使用反射操作注解
大部分情況下，我們的項(xiàng)目或者開源框架中都定義了大量的注解，而且都是@Retention(RetentionPolicy.RUNTIME)運(yùn)行時(shí)階段，我們可以通過反射獲取注解中的信息，所以整體遵循下面的一個(gè)范式。
- 自定義注解
- 掃描注解
- 通過反射獲取注解的信息，執(zhí)行相應(yīng)的邏輯。
下面我們重點(diǎn)使用下如何用反射來獲取注解的信息。
- 定義target是注解的注解
@Inherited
@Retention( value = RetentionPolicy.RUNTIME)
@Target(value = {ElementType.ANNOTATION_TYPE})
public @interface AnnoTest {
String value() default "anno";
}
- 定義一個(gè)幾乎全量信息的注解
@AnnoTest("alvinAnno")
@Inherited
@Retention( value = RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE_USE,ElementType.PACKAGE,ElementType.FIELD,
ElementType.TYPE_PARAMETER,ElementType.CONSTRUCTOR,ElementType.LOCAL_VARIABLE})
@Documented
public @interface FullAnnoTest {
String value() default "FullAnnoTest";
}- 定義測試類和反射代碼
@FullAnnoTest("package")
package com.alvin.java.core.anno;
public class ParentObj {
}
@FullAnnoTest("testAnnoReflect")
public class TestAnnoReflect<@FullAnnoTest("parameter") T > extends @FullAnnoTest("parent")ParentObj {
@FullAnnoTest("constructor")
TestAnnoReflect() {
}
//注解字段域
private @FullAnnoTest("name") String name;
//注解泛型字段域
private @FullAnnoTest("value") T value;
//注解通配符
private @FullAnnoTest("list") List<@FullAnnoTest("generic") ?> list;
//注解方法
@FullAnnoTest("method") //注解方法參數(shù)
public String hello(@FullAnnoTest("methodParameter") String name)
throws @FullAnnoTest("Exception") Exception { // 注解拋出異常
//注解局部變量,現(xiàn)在運(yùn)行時(shí)暫時(shí)無法獲取（忽略）
@FullAnnoTest("result") String result;
result = "siting";
System.out.println(name);
return result;
}
public static void main(String[] args) throws Exception {
TestAnnoReflect<String> TestAnnoReflect = new TestAnnoReflect<> ();
Class<TestAnnoReflect<Object>> clazz = (Class<TestAnnoReflect<Object>>) TestAnnoReflect.getClass();
//class的注解
Annotation[] annotations = clazz.getAnnotations();
FullAnnoTest testTmp = (FullAnnoTest) annotations[0];
System.out.println("修飾TestAnnoReflect.class注解value: "+testTmp.value());
//構(gòu)造器的注解
Constructor<TestAnnoReflect<Object>> constructor = (Constructor<TestAnnoReflect<Object>>) clazz.getDeclaredConstructors()[0];
testTmp = constructor.getAnnotation(FullAnnoTest.class);
System.out.println("修飾構(gòu)造器的注解value: "+testTmp.value());
//繼承父類的注解
AnnotatedType annotatedType = clazz.getAnnotatedSuperclass();
testTmp = annotatedType.getAnnotation(FullAnnoTest.class);
System.out.println("修飾繼承父類的注解value: "+testTmp.value());
//注解的注解
AnnoTest AnnoTest = testTmp.annotationType().getAnnotation(AnnoTest.class);
System.out.println("修飾注解的注解AnnoTest-value: "+AnnoTest.value());
//泛型參數(shù) T 的注解
TypeVariable<Class<TestAnnoReflect<Object>>> variable = clazz.getTypeParameters()[0];
testTmp = variable.getAnnotation(FullAnnoTest.class);
System.out.println("修飾泛型參數(shù)T注解value: "+testTmp.value());
//普通字段域 的注解
Field[] fields = clazz.getDeclaredFields();
Field nameField = fields[0];
testTmp = nameField.getAnnotation(FullAnnoTest.class);
System.out.println("修飾普通字段域name注解value: "+testTmp.value());
//泛型字段域 的注解
Field valueField = fields[1];
testTmp = valueField.getAnnotation(FullAnnoTest.class);
System.out.println("修飾泛型字段T注解value: "+testTmp.value());
//通配符字段域 的注解
Field listField = fields[2];
AnnotatedParameterizedType annotatedPType = (AnnotatedParameterizedType)listField.getAnnotatedType();
testTmp = annotatedPType.getAnnotation(FullAnnoTest.class);
System.out.println("修飾泛型注解value: "+testTmp.value());
//通配符注解 的注解
AnnotatedType[] annotatedTypes = annotatedPType.getAnnotatedActualTypeArguments();
AnnotatedWildcardType annotatedWildcardType = (AnnotatedWildcardType) annotatedTypes[0];
testTmp = annotatedWildcardType.getAnnotation(FullAnnoTest.class);
System.out.println("修飾通配符注解value: "+testTmp.value());
//方法的注解
Method method = clazz.getDeclaredMethod("hello", String.class);
annotatedType = method.getAnnotatedReturnType();
testTmp = annotatedType.getAnnotation(FullAnnoTest.class);
System.out.println("修飾方法的注解value: "+testTmp.value());
//異常的注解
annotatedTypes = method.getAnnotatedExceptionTypes();
testTmp = annotatedTypes[0].getAnnotation(FullAnnoTest.class);
System.out.println("修飾方法拋出錯(cuò)誤的注解value: "+testTmp.value());
//方法參數(shù)的注解
annotatedTypes = method.getAnnotatedParameterTypes();
testTmp = annotatedTypes[0].getAnnotation(FullAnnoTest.class);
System.out.println("修飾方法參數(shù)注解value: "+testTmp.value());
//包的注解
Package p = Package.getPackage("com.alvin.java.core.anno");
testTmp = p.getAnnotation(FullAnnoTest.class);
System.out.println("修飾package注解value: "+testTmp.value());
TestAnnoReflect.hello("hello");
}
}- 查看對(duì)應(yīng)的執(zhí)行結(jié)果
修飾TestAnnoReflect.class注解value: testAnnoReflect
修飾構(gòu)造器的注解value: constructor
修飾繼承父類的注解value: parent
修飾注解的注解AnnoTest-value: alvinAnno
修飾泛型參數(shù)T注解value: parameter
修飾普通字段域name注解value: name
修飾泛型字段T注解value: value
修飾泛型注解value: list
修飾通配符注解value: generic
修飾方法的注解value: method
修飾方法拋出錯(cuò)誤的注解value: Exception
修飾方法參數(shù)注解value: methodParameter
修飾package注解value: package
hello
注解的本質(zhì)和底層實(shí)現(xiàn)
大家有沒有想過注解的本質(zhì)是什么？
我們先通過反編譯查看注解生成的字節(jié)碼，可以通過javap -v FullAnnoTest.class查看如下：
可以看到，我們的注解是繼承自Annotation接口。
public interface Annotation {
boolean equals(Object obj);
int hashCode();
String toString();
/**
* Returns the annotation type of this annotation.
* @return the annotation type of this annotation
*/
Class<? extends Annotation> annotationType();
}所以注解相當(dāng)于一個(gè)語法糖一樣，可以方便我們使用，本質(zhì)上它是繼承自Annotation的一個(gè)接口。
那大家有沒有想過它的實(shí)現(xiàn)類在哪里？比如下面的代碼，獲取到注解，按照上面的解釋，它是一個(gè)接口，那調(diào)用value()方法時(shí)，它具體調(diào)用的哪個(gè)實(shí)現(xiàn)類呢？我們并沒有寫實(shí)現(xiàn)類啊.....
答案當(dāng)然就是動(dòng)態(tài)代理生成的實(shí)現(xiàn)類。
AnnoTest annoTest = testTmp.annotationType().getAnnotation(AnnoTest.class);
System.out.println("修飾注解的注解AnnoTest-value: "+annoTest.value());
我們可以在啟動(dòng)參數(shù)添加如下命令可以查看生成的代理類：-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true
執(zhí)行后，生成代理類如下，
代理大致的代碼如下：
public final class $Proxy2 extends Proxy implements FullAnnoTest {
private static Method m1;
private static Method m2;
private static Method m4;
private static Method m0;
private static Method m3;
public $Proxy2(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 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 String value() throws {
try {
return (String)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.alvin.java.core.anno.FullAnnoTest").getMethod("annotationType");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
m3 = Class.forName("com.alvin.java.core.anno.FullAnnoTest").getMethod("value");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}我們看value()?方法，這里調(diào)用了super.h對(duì)象，也就是InvocationHandler?對(duì)象，而我們注解用的是AnnotationInvocationHandler這個(gè)子類，我們?cè)趇nvoke方法中打個(gè)斷點(diǎn)，就明白了~~
