close
X

Android註解快速入門和實用解析


首先什麼是註解[email protected]就是註解,它的作用是:

1、體現在於:檢查子類重寫方法名與引數型別是否正確;檢查方法private/final/static等不能被重寫。實際上@Override對於應用程式並沒有實際影響,從它的原始碼中可以出來。

2、主要是表現出程式碼的可讀性。





作為Android開發中熟知的註解,Override只是註解的一種體現,更多時候,註解還有以下作用:

  • 降低專案的耦合度。
  • 自動完成一些規律性的程式碼
  • 自動生成java程式碼,減輕開發者的工作量。

一、註解基礎快讀

1、元註解

註解是由java提供的基礎註解,負責註解其它註解,如上圖Override被@Target和@Retention修飾,它們用來說明解釋其它註解,位於sdk/sources/android-25/java/lang/annotation路徑下。





註解有:

  • @Retention:註解保留的生命週期
  • @Target:註解對象的作用範圍。
  • @Inherited:@Inherited標明所修飾的註解,在所作用的類上,是否可以被繼承。
  • @Documented:如其名,javadoc的工具文件化,一般不關心。

@Retention

Retention說標明瞭註解被生命週期,對應RetentionPolicy的列舉,表示註解在何時生效:

  • SOURCE:只在原始碼中有效,編譯時拋棄,如上面的@Override。
  • CLASS:編譯class檔案時生效。
  • RUNTIME:執行時才生效。

如下圖X1,com.android.support:support-annotations中的Nullable註解,會在編譯期判斷,被註解引數是否會空,具體後續分析。

@Target

Target標明瞭註解的適用範圍,對應ElementType列舉,明確了註解的有效範圍。

  • TYPE:類、介面、列舉、註解型別。
  • FIELD:類成員(構造方法方法、成員變數)。
  • METHOD:方法
  • PARAMETER:引數
  • CONSTRUCTOR:構造器。
  • LOCAL_VARIABLE:區域性變數。
  • ANNOTATION_TYPE:註解
  • PACKAGE:包宣告。
  • TYPE_PARAMETER:型別引數
  • TYPE_USE:型別使用宣告。

如上圖X1所示,@Nullable可用於註解方法引數,類成員,註解,包宣告中,常用例子如下所示:

  1. /** 
  2.   * Nullable表明 
  3.   * bind方法引數target和返回值Data可以為null 
  4.   */ 
  5.  @Nullable  
  6.  public static Data bind(@Nullable Context target) { 
  7.    //do someThing and return 
  8.    return bindXXX(target); 
  9.  } 

@Inherited

註解所作用的類,在繼承時預設無法繼承父類的註解。除非註解宣告瞭 @Inherited。同時Inherited宣告出來的注,只對類有效,對方法/屬性無效。

如下方程式碼註解類@AInherited宣告瞭Inherited ,而註解BNotInherited 沒有,所在在它們的修飾下:

  • 類Child繼承了父類Parent的@AInherited,不繼承@BNotInherited;
  • 重寫方法testOverride()不繼承Parent的任何註解;
  • testNotOverride()因為沒有被重寫,所以註解依然生效。
  1. @Retention(RetentionPolicy.RUNTIME)   
  2. @Inherited   
  3. public @interface AInherited {   
  4.     String value();   
  5. }   
  6. @Retention(RetentionPolicy.RUNTIME)   
  7. public @interface BNotInherited {   
  8.     String value();   
  9. }   
  10.  
  11. @AInherited("Inherited")   
  12. @BNotInherited("沒Inherited")   
  13. public class Parent {   
  14.  
  15.     @AInherited("Inherited")   
  16.     @BNotInherited("沒Inherited")   
  17.     public void testOverride(){   
  18.  
  19.     }   
  20.     @AInherited("Inherited")   
  21.     @BNotInherited("沒Inherited")   
  22.     public void testNotOverride(){ 
  23.     } 
  24. }   
  25.  
  26. /** 
  27.   * Child繼承了Parent的AInherited註解 
  28.   * BNotInherited因為沒有@Inherited宣告,不能被繼承 
  29.   */ 
  30. public class Child extends Parent {   
  31.  
  32.   /** 
  33.    * 重寫的testOverride不繼承任何註解 
  34.    * 因為Inherited不作用在方法上 
  35.    */ 
  36.     @Override   
  37.     public void testOverride() {   
  38.     }   
  39.  
  40.   /** 
  41.    * testNotOverride沒有被重寫 
  42.    * 所以註解AInherited和BNotInherited依然生效。 
  43.    */ 

2、自定義註解

2.1 執行時註解

瞭解了元註解後,看看如何實現和使用自定義註解。這裡我們簡單介紹下執行時註解RUNTIME,編譯時註解CLASS留著後面分析。

首先,建立一個註解遵循: public @interface 註解名 {方法引數},如下方@getViewTo註解

  1. @Target({ElementType.FIELD}) 
  2. @Retention(RetentionPolicy.RUNTIME) 
  3. public @interface getViewTo { 
  4.     int value() default  -1; 

然後如下方所示,我們將註解描述在Activity的成員變數mTv和mBtn中,在App執行時,通過反射將findViewbyId得到的控制元件,注入到mTv和mBtn中。

是不是很熟悉,有點ButterKnife的味道?當然,ButterKnife比這個高級多,畢竟反射多了影響效率,不過我們明白了,可以通過註解來注入和建立對象,這樣可以在一定程度節省程式碼量。

  1. public class MainActivity extends AppCompatActivity { 
  2.  
  3.     @getViewTo(R.id.textview) 
  4.     private TextView mTv; 
  5.  
  6.     @getViewTo(R.id.button) 
  7.     private Button mBtn; 
  8.  
  9.     @Override 
  10.     protected void onCreate(Bundle savedInstanceState) { 
  11.         super.onCreate(savedInstanceState); 
  12.         setContentView(R.layout.activity_main); 
  13.  
  14.         //通過註解生成View; 
  15.         getAllAnnotationView(); 
  16.     } 
  17.  
  18.     /** 
  19.      * 解析註解,獲取控制元件 
  20.      */ 
  21.     private void getAllAnnotationView() { 
  22.         //獲得成員變數 
  23.         Field[] fields = this.getClass().getDeclaredFields(); 
  24.  
  25.         for (Field field : fields) { 
  26.           try { 
  27.             //判斷註解 
  28.             if (field.getAnnotations() != null) { 
  29.               //確定註解型別 
  30.               if (field.isAnnotationPresent(GetViewTo.class)) { 
  31.                 //允許修改反射屬性 
  32.                 field.setAccessible(true); 
  33.                 GetViewTo getViewTo = field.getAnnotation(GetViewTo.class); 
  34.                 //findViewById將註解的id,找到View注入成員變數中 
  35.                 field.set(this, findViewById(getViewTo.value())); 
  36.               } 
  37.             } 
  38.           } catch (Exception e) { 
  39.           } 
  40.         } 
  41.       } 
  42.  

2.2 編譯時註解

執行時註解RUNTIME如上2.1所示,大多數時候實在執行時使用反射來實現所需效果,這很大程度上影響效率,如果BufferKnife的每個View注入不可能如何實現。實際上,ButterKnife使用的是編譯時註解CLASS,如下圖X2.2,是ButterKnife的@BindView註解,它是一個編譯時註解,在編譯時生成對應java程式碼,實現注入。

說到編譯時註解,就不得不說註解處理器 AbstractProcessor,如果你有注意,一般第三方註解相關的類庫,如bufferKnike、ARouter,都有一個Compiler命名的Module,如下圖X2.3,這裡面一般都是註解處理器,用於編譯時處理對應的註解

註解處理器(Annotation Processor)是javac的一個工具,它用來在編譯時掃描和處理註解(Annotation)。你可以對自定義註解,並註冊相應的註解處理器,用於處理你的註解邏輯。

如下所示,實現一個自定義註解處理器,至少重寫四個方法,並且註冊你的自定義Processor,詳細可參考下方程式碼CustomProcessor。

  • @AutoService(Processor.class),Google提供的自動註冊註解,為你生成註冊Processor所需要的格式檔案(com.谷歌.auto相關包)。
  • init(ProcessingEnvironment env),初始化處理器,一般在這裡獲取我們需要的工具類。
  • getSupportedAnnotationTypes(),指定註解處理器是註冊給哪個註解的,返回指定支持的註解類集合。
  • getSupportedSourceVersion() ,指定java版本。
  • process(),處理器實際處理邏輯入口。
  1. @AutoService(Processor.class) 
  2. public class CustomProcessor extends AbstractProcessor { 
  3.  
  4.     /** 
  5.      * 註解處理器的初始化 
  6.      * 一般在這裡獲取我們需要的工具類 
  7.      * @param processingEnvironment 提供工具類Elements, Types和Filer 
  8.      */ 
  9.     @Override 
  10.     public synchronized void init(ProcessingEnvironment env){  
  11.         super.init(env); 
  12.         //Element代表程式的元素,例如包、類、方法。 
  13.         mElementUtils = env.getElementUtils(); 
  14.  
  15.         //處理TypeMirror的工具類,用於取類資訊 
  16.         mTypeUtils = env.getTypeUtils(); 
  17.  
  18.          //Filer可以建立檔案 
  19.         mFiler = env.getFiler(); 
  20.  
  21.         //錯誤處理工具 
  22.         mMessages = env.getMessager(); 
  23.     } 
  24.  
  25.     /** 
  26.      * 處理器實際處理邏輯入口 
  27.      * @param set 
  28.      * @param roundEnvironment 所有註解的集合 
  29.      * @return  
  30.      */ 
  31.     @Override 
  32.     public boolean process(Set<? extends TypeElement> annoations,  
  33.       RoundEnvironment env) { 
  34.         //do someThing 
  35.     } 
  36.  
  37.     //指定註解處理器是註冊給哪個註解的,返回指定支持的註解類集合。 
  38.     @Override 
  39.     public Set<String> getSupportedAnnotationTypes() {  
  40.           Set<String> sets = new LinkedHashSet<String>(); 
  41.  
  42.           //大部分class而已getName、getCanonicalNam這兩個方法沒有什麼不同的。 
  43.           //但是對於array或內部類等就不一樣了。 
  44.           //getName返回的是[[Ljava.lang.String之類的表現形式, 
  45.           //getCanonicalName返回的就是跟我們宣告類似的形式。 
  46.           sets(BindView.class.getCanonicalName()); 
  47.  
  48.           return sets; 
  49.     } 
  50.  
  51.     //指定Java版本,一般返回最新版本即可 
  52.     @Override 
  53.     public SourceVersion getSupportedSourceVersion() { 
  54.         return SourceVersion.latestSupported(); 
  55.     } 
  56.  

首先,我們梳理下一般處理器處理邏輯:

  1. 遍歷得到原始碼中,需要解析的元素列表。
  2. 判斷元素是否可見和符合要求。
  3. 組織資料結構得到輸出類引數
  4. 輸入生成java檔案。
  5. 錯誤處理。

然後,讓我們理解一個概念:Element,因為它是我們獲取註解的基礎。

Processor處理過程中,會掃描全部Java原始碼,程式碼的每一個部分都是一個特定型別的Element,它們像是XML一層的層級機構,比如類、變數、方法等,每個Element代表一個靜態的、語言級別的構件,如下方程式碼所示。

  1. package android.demo; // PackageElement  
  2. // TypeElement 
  3. public class DemoClass {  
  4.     // VariableElement 
  5.     private boolean mVariableType;  
  6.     // VariableElement 
  7.     private VariableClassE m VariableClassE;  
  8.     // ExecuteableElement 
  9.     public DemoClass () { 
  10.     }  
  11.     // ExecuteableElement 
  12.     public void resolveData (Demo data   //TypeElement ) { 
  13.     } 

其中,Element代表的是原始碼,而TypeElement代表的是原始碼中的型別元素,例如類。然而,TypeElement並不包含類本身的資訊。你可以從TypeElement中獲取類的名字,但是你獲取不到類的資訊,例如它的父類。這種資訊需要通過TypeMirror獲取。你可以通過呼叫elements.asType()獲取元素的TypeMirror。

1、知道了Element,我們就可以通過process 中的RoundEnvironment去獲取,掃描到的所有元素,如下圖X2.4,通過env.getElementsAnnotatedWith,我們可以獲取被@BindView註解的元素的列表,其中validateElement校驗元素是否可用。

2、因為env.getElementsAnnotatedWith返回的,是所有被註解了@ BindView的元素的列表。所以有時候我們還需要走一些額外的判斷,比如,檢查這些Element是否是一個類:

  1. @Override 
  2.   public boolean process(Set<? extends TypeElement> an, RoundEnvironment env) { 
  3.     for (Element e : env.getElementsAnnotatedWith(BindView.class)) { 
  4.       // 檢查元素是否是一個類 
  5.       if (ae.getKind() != ElementKind.CLASS) { 
  6.             ... 
  7.       } 
  8.    } 
  9.    ... 

3、javapoet (com.squareup:javapoet)是一個根據指定引數,生成java檔案的開源庫,有興趣瞭解javapoet的可以看下javapoet——讓你從重複無聊的程式碼中解放出來,在處理器中,按照引數建立出 JavaFile之後,通Filer利用javaFile.writeTo(filer);就可以生成你需要的java檔案。

4、錯誤處理,在處理器中,我們不能直接丟擲一個異常,因為在process()中丟擲一個異常,會導致執行註解處理器的JVM崩潰,導致跟蹤棧資訊十分混亂。因此,註解處理器就有一個Messager類,一般通過messager.printMessage( Diagnostic.Kind.ERROR, StringMessage, element)即可正常輸出錯誤資訊。

至此,你的註解處理器完成了所有的邏輯。可以看出,編譯時註解實在編譯時生成java檔案,然後將生產的java檔案注入到原始碼中,在執行時並不會像執行時註解一樣,影響效率和資源。

總結

我們就利用ButterKnife的流程,簡單舉例做個總結吧。

  1. @BindView在編譯時,根據Acitvity生產了XXXActivity$$ViewBinder.java。
  2. Activity中呼叫的ButterKnife.bind(this);,通過this的類名字,加$$ViewBinder,反射得到了ViewBinder,和編譯處理器生產的java檔案關聯起來了,並將其存在map中快取,然後呼叫ViewBinder.bind()。
  3. 在ViewBinder的bind方法中,通過id,利用ButterKnife的butterknife.internal.Utils工具類中的封裝方法,將findViewById()控制元件注入到Activity的引數中。

好了,通過上面的流程,是不是把編譯時註解的生成和使用連線起來了呢?有問題還請各位留言談論。

  1. 給Android開發者的31個Pro 版進階小貼士
  2. Google公佈I/O 2017 for Android的原始碼
  3. Android字型修改,所有的細節都在這裡 | 開篇
  4. Android中以粗暴的方式替換全域性字型
  5. Android 如何用 Vim 提高開發效率





分享是一種美德,喜歡就幫我們讚一下支持吧~

為你推薦