摘要：

大家都知道註解是實現了java.lang.annotation.Annotation介面，眼見為實，耳聽為虛，有時候眼見也不一定是真實的。

    /**
     * The common interface extended by all annotation types.  Note that an
     * interface that manually extends this one does <i>not</i> define
     * an annotation type.  Also note that this interface does not itself
     * define an annotation type.
     *
     * More information about annotation types can be found in section 9.6 of
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * The {@link java.lang.reflect.AnnotatedElement} interface discusses
     * compatibility concerns when evolving an annotation type from being
     * non-repeatable to being repeatable.
     *
     * @author  Josh Bloch
     * @since   1.5
     */
 

元註解:

元註解 一般用於指定某個註解生命週期以及作用目標等資訊。正如原始碼的註釋一樣，如果自定義的註解沒有新增元註解就和平常的註釋沒有多大的區別，有了元註解就會讓編譯器將資訊編譯進位元組碼檔案。

• @Target

  @Target用於指明被修飾的註解最終可以作用的目標

ElementType 是一個列舉型別

    ElementType.TYPE：類，介面（包括註釋型別）或列舉宣告
    ElementType.FIELD：欄位宣告（包括列舉常量）
    ElementType.METHOD：方法宣告
    ElementType.PARAMETER：正式引數宣告
    ElementType.CONSTRUCTOR：構造器宣告
    ElementType.LOCAL_VARIABLE：本地區域性變數宣告
    ElementType.ANNOTATION_TYPE：註解宣告
    ElementType.PACKAGE：包宣告
    ElementType.TYPE_PARAMETER：型別引數宣告  jdk1.8新增
    ElementType.TYPE_USE：使用一種型別   jdk1.8新增
 

• @Retention

@Retention用於指明當前註解的生命週期

RetentionPolicy是一個列舉型別

    RetentionPolicy.SOURCE：編譯器將丟棄註釋。
    RetentionPolicy.CLASS：註釋將由編譯器記錄在類檔案中，但在執行時不需要由VM保留。
    RetentionPolicy.RUNTIME：註釋將由編譯器記錄在類檔案中並且在執行時由VM保留，因此可以反射性地讀取它們。

• @Documented

@Documented 表示具有型別的註釋將由javadoc記錄和預設的類似工具。 這種型別應該用來註釋註解影響註解使用的型別的宣告客戶的元素。 如果使用註解型別宣告記錄，其註解成為公共API的一部分註釋元素。

• @Inherited

@Inherited 表示自動繼承註解型別。 如果註解型別上存在繼承的元註解宣告，使用者查詢類的註解型別宣告，類宣告沒有此型別的註解，然後將自動查詢該類的超類註解型別。 將重複此過程，直到為此註解找到型別，或類層次結構的頂部（物件）到達了。 如果沒有超類具有此型別的註解，那麼查詢將指示有問題的類沒有這樣的註解。請注意，如果帶註解，則此元註解型別無效type用於註解除類之外的任何內容。 另請注意這個元註解只會導致註解被繼承來自超類; 已實現的介面上的註解沒有效果。

註解實現

• 如何自定義註解？

      package com.github.dqqzj.springboot.annotation;
      
      import org.springframework.core.annotation.AliasFor;
      import org.springframework.stereotype.Component;
      import org.springframework.stereotype.Service;
      
      import java.lang.annotation.ElementType;
      import java.lang.annotation.Retention;
      import java.lang.annotation.RetentionPolicy;
      import java.lang.annotation.Target;
      
      /**
       * @author qinzhongjian
       * @date created in 2019-07-28 07:54
       * @description: TODO
       * @since JDK 1.8.0_212-b10
       */
      @Target(value = {ElementType.TYPE})
      @Retention(value = RetentionPolicy.RUNTIME)
      @Component
      public @interface Hello {
          @AliasFor(
                  annotation = Component.class
          )
          String value() default "hi" ;
      }

• 如何獲取註解元素資訊？

  

如上圖所示註解其實也是使用了代理，而且是JDK代理的。

註解原理分析

既然是執行時生成的代理類，我們就可以在啟動類上新增System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles","true")或者

我們來分析一下生成的代理類

    package com.sun.proxy;
    
    import com.github.dqqzj.springboot.annotation.Hello;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    
    public final class $Proxy1 extends Proxy implements Hello {
        private static Method m1;
        private static Method m2;
        private static Method m4;
        private static Method m0;
        private static Method m3;
    
        public $Proxy1(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 String toString() throws  {
            try {
                return (String)super.h.invoke(this, m2, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        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 int hashCode() throws  {
            try {
                return (Integer)super.h.invoke(this, m0, (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.github.dqqzj.springboot.annotation.Hello").getMethod("annotationType");
                m0 = Class.forName("java.lang.Object").getMethod("hashCode");
                m3 = Class.forName("com.github.dqqzj.springboot.annotation.Hello").getMethod("value");
            } catch (NoSuchMethodException var2) {
                throw new NoSuchMethodError(var2.getMessage());
            } catch (ClassNotFoundException var3) {
                throw new NoClassDefFoundError(var3.getMessage());
            }
        }
    }

這裡的InvocationHandler實際上是我們的AnnotationInvocationHandler，這裡有一個memberValues，它是一個Map 鍵值對，鍵是我們註解屬性名稱，值就是該屬性當初被賦上的值。接下來我除錯程式碼給大家分享一下奧祕。

Hello hello = TestAnnotation.class.getAnnotation(Hello.class)這個部分的除錯程式碼我會忽略直接除錯

AnnotationInvocationHandler的相關方法。

註解奧祕的準備工作

• 反編譯註解檔案，發現註解確實是實現了Annotation介面的

熟悉jdk規範的就會發現最底部的s#7RuntimeVisibleAnnotations這個是執行時可訪問的註解資訊，可供我們反射獲取。

虛擬機器規範定義了一系列和註解相關的屬性表，無論是欄位、方法或是類本身，如果被註解修飾了，就可以被寫進位元組碼檔案。屬性表有以下幾種：

RuntimeVisibleAnnotations：執行時可見的註解
RuntimeInVisibleAnnotations：執行時不可見的註解
RuntimeVisibleParameterAnnotations：執行時可見的方法引數註解
RuntimeInVisibleParameterAnnotations：執行時不可見的方法引數註解
AnnotationDefault：註解類元素的預設值`

註解奧祕除錯

說明: 明明只有一個@Hello註解為什麼左側會出現2個代理類的原因就在這個地方，會多出一個代理類

    public final class $Proxy0 extends Proxy implements Retention {
       //省略無關程式碼.......
    }

反射註解工作原理：

1. 我們通過鍵值對的形式可以為註解屬性賦值，像這樣：@Hello（value = "hi"）
2. 用註解修飾某個元素，編譯器將在編譯期掃描每個類或者方法上的註解，會做一個基本的檢查，你的這個註解是否允許作用在當前位置，最後會將註解資訊寫入元素的屬性表
3. 虛擬機器把生命週期在 RUNTIME的註解取出並通過動態代理機制生成一個實現註解介面的代理類

如何動態修改代理值？

我們已經知道了註解的值是存放在Map<String, Object> memberValues中的，那麼我們就可以使用反射獲取並重新賦值。

相關推薦