annotationProcessor實戰,了解ButterKinfe過程

注解的簡介

簡介

Annotations, a form of metadata, provide data about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate.

注釋是元數據的一種形式，為程序的元素（類、方法、變量）提供一些說明，但是不會對程序本身造成影響。

  • Annotation 類似一種修飾符，用于修飾包、類型、構造方法、方法、成語變量、參數的聲明語句。
  • Annotation 是一個接口。通過反射來訪問annotation信息。根據獲取的信息來決定如何使用注解信息來做一些事情。
  • Annotation 不會對程序造成影響。
  • Java預言解析器在工作的時候默認是忽略這些annotation，所以在JVM中"不起作用"，只有通過配套的工具才能對這些注解進行訪問和處理。

Annotation的使用

  • Annotation的聲明需要通過@interface這個關鍵字。會繼承Annotation接口。
  • Annotation的方法必須聲明為無參數、無異常。方法名代表成員變量名，方法的返回值代表了成員變量的類型。而且返回值類型必須為基本數據類型、Class類型、枚舉類型、String類型、Annotation類型或者由前面任意一種類型組成的一維數組。方法后面可以使用default和一個默認數值來聲明一個成員變量的默認值，null不能作為成員變量的默認值。
  • 注解中如果只有一個默認屬性，可以直接使用value()函數，一個屬性也沒有的則表示該Annotation為Mark Annotation。
    例如：
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
    String value();
}

直接使用@Test("demo")，等同于@Test(value="demo")
添加默認值：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestDefault {
    public String description() default "demo";
}

Annotation的作用

很多使用作為一種輔助途徑，應用在軟件框架或工具中。這些工具類可以根據不同的Annotation心采取不同的處理，具有"讓編譯器進行編譯檢查的功能"

具體可分為以下三種作用：

  1. 標記，告訴編譯器一些信息(RetentionPolicy.SOURCE)
  2. 運行時動態處理，如通過反射的信息獲取注解信息進行操作(RetentionPolicy.RUNTIME)
  3. 編譯時動態處理，如生成代碼或XML(RetentionPolicy.CLASS)

分類

標準的Annotation
從1.5開始就自帶三張標準的Annotation類型：

  • Override
    它是一種marker類型的Annotation，用來標注方法，說明被它標注的方法是重載了父類中的方法。如果我們使用了該注解到一個沒有覆蓋父類方法的方法時，編譯器就會提示一個編譯錯誤的警告。
  • Deprecated
    它也是一種marker類型的Annotation。當方法或者變量使用該注解時，編譯器就會提示該方法已經廢棄。
  • SuppressWarnings
    它不是marker類型的Annotation。用戶告訴編譯器不要再對該類、方法或者成員變量進行警告提示。
    元Annotation
    元Annotation是指用來定義Annotation的Annotation
  • @Retention
    保留時間，可為RetentionPolicy.SOURCE(源碼時)、RetentionPolicy.CLASS(編譯時)、RetentionPolicy.RUNTIME(運行時)，默認為CLASS。如果值為RetentionPolicy.SOURCE那大多都是Mark Annotation，例如:Override、Deprecated。SOURCE表示僅存在于源碼中，在class文件中不會包含。CLASS表示會在class文件中存在，但是運行時無法獲取。RUNTIME表示會在class文件中存在，并且在運行時可以通過反射獲取。
  • @Target
    用來標記可進行修飾哪些元素，例如ElementType.TYPE、ElementType.METHOD、ElementType.CONSTRUCTOR、ElementType.FIELD、ElementType.PARAMETER等，如果未指定則默認為可修飾所有。
  • @Inherited
    子類是否可以繼承父類中的該注解。它所標注的Annotation將具有繼承性。
  • @Documented
    是否會保存到javadoc文檔中。

自定義Annotation

在Android的獲取控件中都需要findViewById()來獲取，通過注解的來獲取到Id的值進行綁定例如：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject{
    int viewId();
}

注解聲明完后，可以定義一些控件來使用：

@ViewInject(viewId = R.id.test)
    private TextView test;

Annotation解析

  • 當Java源代碼被編譯時，編譯器的一個插件annotation處理器則會處理這些annotation。
    處理器可以產生報告信息，或者創建附加的Java源文件或資源。
    如果annotation本身被加上了RententionPolicy的運行時類，
    則Java編譯器則會將annotation的元數據存儲到class文件中。然后Java虛擬機或其他的程序可以查找這些元數據并做相應的處理。
  • 除了annotation處理器可以處理annotation外，我們也可以使用反射來處理annotation。Java SE 5有一個名為AnnotatedElement的接口，
    Java的反射對象類Class,Constructor,Field,Method以及Package都實現了這個接口。
    這個接口用來表示當前運行在Java虛擬機中的被加上了annotation的程序元素。
    通過這個接口可以使用反射讀取annotation。AnnotatedElement接口可以訪問被加上RUNTIME標記的annotation，
    相應的方法有getAnnotation,getAnnotations,isAnnotationPresent。
    由于Annotation類型被編譯和存儲在二進制文件中就像class一樣，
    所以可以像查詢普通的Java對象一樣查詢這些方法返回的Annotation。

運行時Annotation解析

該類是指@Retention為RUNTIME的Annotation。
該類型的解析其實本質的使用反射。反射執行的效率是很低的
如果不是必要，應當盡量減少反射的使用，因為它會大大拖累你應用的執行效率。
例如：

public static void viewInject(Activity activity){
        Class<? extends Activity> obj=activity.getClass();
        Field[] fields=obj.getDeclaredFields();//獲取聲明的字段
        for (Field field :fields){
            ViewInject viewInject=field.getAnnotation(ViewInject.class);
            if(viewInject!=null){
                int viewId=viewInject.viewId();
                if(viewId!=-1){
                    try {
                        Method method=obj.getMethod("findViewById",int.class);
                        Object view=method.invoke(activity,viewId);
                        field.setAccessible(true);//設置屬性可以訪問
                        field.set(activity,view);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

在Android的開發中使用ButterKnife他也是使用到了注解

//聲明的保留時期為編譯時期
@Retention(CLASS) @Target(FIELD)
public @interface BindView {
  /** View ID to which the field will be bound. */
  @IdRes int value();
}

使用的是編譯類型的注解，這樣就不會通過反射來獲取數值，不會影響性能。

編譯類型注解的過程：

編譯類型注解的解析

  • 該類型注解值是@Retention為CLASS的Annotation，由APT(Annotaion Processing Tool)自動進行解析。是在編譯時注入，所以不會像反射一樣影響效率問題。
  • 根據sun官方的解釋，APT（annotation processing tool）是一個命令行工具，
    它對源代碼文件進行檢測找出其中的annotation后，使用annotation processors來處理annotation。
    而annotation processors使用了一套反射API并具備對JSR175規范的支持。
  • annotation processors處理annotation的基本過程如下：
  1. APT運行annotation processors根據提供的源文件中的annotation生成源代碼文件和其它的文件（文件具體內容由annotation processors的編寫者決定）
  2. 接著APT將生成的源代碼文件和提供的源文件進行編譯生成類文件。
  • APT在編譯時自動查找所有繼承自AbstractProcessor的類，然后調用他們的process方法去處理，這樣就擁有了在編譯過程中執行代碼的能力
  • 所以我們需要完成的工作：
  1. 自定義類繼承AbstractProcessor，重寫process方法。
  2. 注冊處理器，讓APT能夠檢測的到。
  • 但是在Android Studio死活提示找不到AbstractProcessor類，這是因為注解是javase中javax包里面的，android.jar默認是不包含的，所以會編譯報錯.
    解決方法就是新建一個Module，在選擇類型時將該Module的類型選為Java Library。
    然后在該Module中創建就好了Processor就好了，完美解決
  • Android Studio中創建一個Android工程。
  • 新建一個Module，然后選擇Java Library類型，并且讓app依賴該module
  • 在annotations的module中創建注解類
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
public @interface AnnotationTest {
    String value() default "";
}
  • 創建自定義的Processor類
@SupportedAnnotationTypes("com.example.AnnotationTest")
@SupportedSourceVersion(SourceVersion.RELEASE_7)
public class TestProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        System.out.println("process");
        for (TypeElement te : annotations) {
            for (Element element : roundEnv.getElementsAnnotatedWith(te)) {
                AnnotationTest annotation = element.getAnnotation(AnnotationTest.class);
                String value = annotation.value();
                System.out.println("type : " + value);
            }
        }
        return true;
    }
}

注意:@SupportedAnnotationTypes("com.charon.AnnotationTest")來指定要處理的注解類。
@SupportedSourceVersion(SourceVersion.RELEASE_7)指定編譯的版本。這種通過注解指定編譯版本和類型的方式是從Java 1.7才有的。
對于之前的版本都是通過重寫AbstractProcessor中的方法來指定的。

  • 注冊處理器
    我們自定義了Processor那如何才能讓其生效呢?就是在annotations的java同級目錄新建resources/META-INF/services/javax.annotation.processing.Processor文件
    然后在javax.annotation.processing.Processor文件中指定自定義的處理器，如:
    com.example.TestProcessor
  • 在app中進行使用
    進行Build會在控制臺看到輸出的信息。

上面只是一個簡單的例子，如果你想用編譯時注解去做一些更高級的事情，例如自動生成一些代碼，那你可能就會用到如下幾個類庫:

  • 以前使用android-apt，Gradle plugin 2.2提供annotationProcessor來代替了android-apt，還是建議使用官方的

As of the Android Gradle plugin version 2.2, all functionality that was previously provided by android-apt is now available in the Android plugin. This means that android-apt is officially obsolete
Here are the steps to migrate:
Make sure you are on the Android Gradle 2.2 plugin or newer.
Remove the android-apt plugin from your build scripts
Change all apt, androidTestApt and testApt dependencies to their new format:

dependencies {
    compile 'com.google.dagger:dagger:2.0'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.0'
}
  • Google Auto的作用：
    Google Auto的主要作用是注解Processor類，并對其生成META-INF的配置信息，
    可以讓你不用去寫META-INF這些配置文件，只要在自定義的Processor上面加上@AutoService(Processor.class)
  • Square javapoet的作用：
    javapoet:A Java API for generating .java source files.可以更方便的生成代碼，它可以幫助我們通過類調用的形式來生成代碼。

自定義編譯時注解

在自定義注解時，一般來說可能會建三個modules:

  • app module:寫一些使用注解的android應用邏輯。
  • api module:定義一些可以在app中使用的注解。它會被app以及compiler使用。
  • compiler module:定義Processor該module不會被包含到應用中，它只會在構建過程中被使用。在編譯的過程中它會生成一些java文件，而這些java文件會被打包進apk中。
    我們可以在該module中使用auto以及javapoet。
    開始進行配置：
  • compiler module中配置auto以及javapoet
dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    //Google Auto的主要作用是注解Processor類，并對其生成META-INF的配置信息，
    //可以讓你不用去寫META-INF這些配置文件，只要在自定義的Processor上面加上@AutoService(Processor.class)
    compile 'com.google.auto.service:auto-service:1.0-rc2'
    //可以更方便的生成代碼，它可以幫助我們通過類調用的形式來生成代碼。
    compile 'com.squareup:javapoet:1.7.0'
    compile project(':apimodule')
}
  • app module中gradle配置：
compile project(':compilermodule')
annotationProcessor project(':compilermodule')
  • 在api module 中創建一個注解
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)
public @interface Factory {
    String id();
    Class type();
}
  • 在compiler module中自定義一個Processor
@AutoService(Processor.class)
public class MyProcessor extends AbstractProcessor {
    //初始化操作的方法，RoundEnvironment會提供很多有用的工具類Elements、Types和Filer等。
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
    }
    //這相當于每個處理器的主函數main()。在該方法中去掃描、評估、處理以及生成Java文件。
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        System.out.println("Hello Wolrd,Custom Processor");
        return false;
    }
    //這里你必須指定，該注解器是注冊給哪個注解的
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return super.getSupportedAnnotationTypes();
    }
    //用來指定你使用的java版本。通常這里會直接放回SourceVersion.latestSupported()
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

}

從jdk 1.7開始，可以使用如下注解來代替getSupporedAnnotationTypes()和getSupportedSourceVersion()方法:

@SupportedSourceVersion(SourceVersion.latestSupported())
@SupportedAnnotationTypes({
   // 合法注解全名的集合
 })
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容