2. 程式人生 > >ButterKnife編譯時註解探祕

ButterKnife編譯時註解探祕

阿新 • • 發佈：2019-02-08

安卓中很多有名的開源框架都運用了編譯時註解，如ButterKnife，EventBus , Retrofit , GreenDao等。所以作為一個合格的安卓開發者，學會運用編譯時註解是非常有必要的。

下面就仿照ButterKnife的view的注入寫一個例子來走一遍編譯時註解的流程。

第一步新建module

1、建立一個module起名為annotation作為註解類的module 用來儲存我們寫的註解類
2、建立一個java module 起名為annotation-processor （注意一定是java modeule 因為這個類中需要繼承AbstractProcessor，AbstractProcessor是javax中的類正常的android sdk中是引用不到的

）

最後的工程目錄：

這裡寫圖片描述

在module的build.gradle中配置一下Java的使用版本

sourceCompatibility = JavaVersion.VERSION_1_7
targetCompatibility = JavaVersion.VERSION_1_7

這邊最好不要用1.8，因為只有android N支援java8，如果你寫1.8之後，強制要你使用buildToolsVersion為24.0.0

第二步編寫annotation中的程式碼

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)
public
 
 @interface MyAnnotation {
    int value();
}

@Retention 註解說明，表示這個註解可以保留到哪個階段 有三種
（1）RetentionPolicy.SOURCE —— 這種型別的Annotations只在原始碼級別保留,編譯時就會被忽略
（2）RetentionPolicy.CLASS —— 這種型別的Annotations編譯時被保留,在class檔案中存在,但JVM將會忽略
（3）RetentionPolicy.RUNTIME —— 這種型別的Annotations將被JVM保留,所以他們能在執行時被JVM或其他使用反射機制的程式碼所讀取和使用.
所以編譯時註解我們就選第二種啦，編譯的時候生成程式碼，以前的一些註解框架比如xutil中的view注入的註解使用的是第三種執行時註解，可以保留到app執行時中，使用的時候通過註解和反射來實現功能。由於執行的時候使用反射的效率不是很好，所以現在就流行編譯的時候做事情啦。
@Target

註解的作用目標 表示這個註解的作用域
@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) ///包

第三步編寫 processor

我們都知道編譯時註解的運用一般都是在編譯的時候生成我們需要的java檔案然後去引用，
如果要生成 .java 的檔案需要用到JavaPoet (square公司開源的用來生成java檔案)
需要在processor的build.gradle檔案中加上依賴

compile 'com.squareup:javapoet:1.9.0'

JavaPoet提供了(TypeSpec)用於建立類或者介面，(FieldSpec)用來建立欄位，(MethodSpec)用來建立方法和建構函式，(ParameterSpec)用來建立引數，(AnnotationSpec)用於建立註解。

如果要生成一個java檔案，首先我們要知道我們喲啊生成的java檔案是神馬樣的，用過ButterKnife的朋友應該都見過它生成的java檔案類似下面

public class MainActivity_ViewBinding {
  public MainActivity_ViewBinding(MainActivity target, View source) {
    target.mTextView = (android.widget.TextView)source.findViewById(2131427422);
  }
}

Ok 下面就通過JavaPoet 的api將上面的一個類拼接出來

 package com.example;

import com.chs.annotation.MyAnnotation;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.CodeBlock;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.ParameterizedTypeName;
import com.squareup.javapoet.TypeName;
import com.squareup.javapoet.TypeSpec;

import java.io.IOException;
import java.util.LinkedHashSet;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Filer;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;

public class MyProcessor extends AbstractProcessor{
    private Filer filer;
    //初始化處理器
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        // Filer是個介面，支援通過註解處理器建立新檔案
        filer = processingEnv.getFiler();
    }
    //處理器的主函式 處理註解
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
            //獲取最裡面的節點
            TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();
            String packageName = enclosingElement.getQualifiedName().toString();
            packageName =packageName .substring(0, packageName.lastIndexOf("."));
            String className = enclosingElement.getSimpleName().toString();
            String typeMirror = element.asType().toString();

            //註解的值
            int annotationValue = element.getAnnotation(MyAnnotation.class).value();
            String name = element.getSimpleName().toString();
            TypeName type = TypeName.get(enclosingElement.asType());//此元素定義的型別
            if (type instanceof ParameterizedTypeName) {
                type = ((ParameterizedTypeName) type).rawType;
            }

            System.out.println("typeMirror:"+typeMirror);//被註解的物件的型別
            System.out.println("packageName:"+packageName);//包名
            System.out.println("className:"+className);//類名
            System.out.println("annotationValue:"+annotationValue);//註解傳過來的引數
            System.out.println("name:"+name);//被註解的物件的名字
            System.out.println("type:"+type);//當前被註解物件所在類的完整路徑

            ClassName bindingClassName = ClassName.get(packageName, className + "_ViewBinding");
              //建立程式碼塊
            CodeBlock.Builder builder = CodeBlock.builder()
                    .add("target.$L = ", name);//$L是佔位符，會把後面的name引數拼接大$L所在的地方
                builder.add("($L)source.findViewById($L)", typeMirror , annotationValue);

                // 建立main方法
              MethodSpec methodSpec = MethodSpec.constructorBuilder()
                      .addModifiers(Modifier.PUBLIC)
                      .addParameter(type,"target")
                      .addParameter(ClassName.get("android.view", "View"),"source")
                      .addStatement("$L", builder.build())
                      .build();

                // 建立類
                TypeSpec helloWorld = TypeSpec.classBuilder(bindingClassName.simpleName())
                        .addModifiers(Modifier.PUBLIC)
                        .addMethod(methodSpec)
                        .build();

                try {
                    // 生成檔案
                    JavaFile javaFile = JavaFile.builder("com.chs.annotationtest", helloWorld)
                            .build();
                    //　將檔案寫出
                    javaFile.writeTo(System.out);
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
        return true;
    }
    //指定處理器處理哪個註解
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> annotataions = new LinkedHashSet<String>();
        annotataions.add(MyAnnotation.class.getCanonicalName());
        return annotataions;
    }
    //指定使用的java的版本
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

}

AbstractProcessor是編譯時註解處理器的主要類，我們需要自定義自己的MyProcessor 整合AbstractProcessor，重寫它裡面的方法。

上面的類中的

init 方法是初始化註解處理器

process 方法是最重要的一個方法，裡面是程式碼生成的主要邏輯 ，拼接程式碼的邏輯上面註釋很清楚啦！不過這裡只實現了一個物件的註解，正常的專案中不可能只有一個物件，知道了一個物件的使用多個物件按同樣的方法迴圈拼接出來就好啦

getSupportedAnnotationTypes 方法是 指定處理器處理哪個註解

getSupportedSourceVersion 方法是 指定java的相容版本

第四步

服務註冊檔案(META-INF/services/javax.annotation.processing.Processor)

1、在module annotation-processor 中main資料夾下建立resources資料夾
2、在resources資原始檔夾下建立META-INF資料夾
3、然後在META-INF資料夾中建立services資料夾
4、然後在services資料夾下建立名為javax.annotation.processing.Processor的檔案
5、在javax.annotation.processing.Processor檔案中配置我們自己的處理器的完整引用 比如com.example.MyProcessor
這裡寫圖片描述

到這裡我們就可以在主檔案中試驗一下啦
首先把註解的module和註解器的module的依賴新增到主專案中的build.gradle中

    compile project(':annotation')
    compile project(':annotation-processor')

MainActivity中使用註解

public class MainActivity extends AppCompatActivity {
    @MyAnnotation(R.id.tv_hello)
    TextView mTextView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

上面註解處理器的MyProcessor 類中的process方法的最後輸出現在是輸出到控制檯System.out

javaFile.writeTo(System.out);

所以現在我們編譯一下專案就可以在控制檯中看到列印了注意不是在logCat中看是在studio 右下角的Gradle Console中看

結果如下：

typeMirror:android.widget.TextView
packageName:com.chs.annotationtest
className:MainActivity
annotationValue:2131427422
name:mTextView
type:com.chs.annotationtest.MainActivity
package com.chs.annotationtest;

import android.view.View;

public class MainActivity_ViewBinding {
  public MainActivity_ViewBinding(MainActivity target, View source) {
    target.mTextView = (android.widget.TextView)source.findViewById(2131427422);
  }
}

上面的log資訊包括MyProcessor 類中的process方法中我們所寫的System.out.println所打印出來的 和最終的類。可以看到最終生成了我們想要的類。

第五步

Ok然後我們就可以去試一下這個類可不可以用啦。
（1）
首先我們得把這個類輸出成一個檔案，方法就是在MyProcessor 類中的init方法中找到Filer
Filer是個介面，支援通過註解處理器建立新檔案

  @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        // Filer是個介面，支援通過註解處理器建立新檔案
        filer = processingEnv.getFiler();
    }

（2）
然後在MyProcessor 類中的process方法中最後通過Filer輸出

                     //　將檔案寫出
                    javaFile.writeTo(filer);

然後重新編譯工程，就可以看到生成的檔案了。位置：
這裡寫圖片描述
開啟檔案可以看到內容：

package com.chs.annotationtest;

import android.view.View;

public class MainActivity_ViewBinding {
  public MainActivity_ViewBinding(MainActivity target, View source) {
    target.mTextView = (android.widget.TextView)source.findViewById(2131427422);
  }
}

然後就是把主程式中的MainActivity跟我們生成的MainActivity_ViewBinding類關聯起來讓MainActivity_ViewBinding初始化MainActivity中的註解了的物件。

根據我們建立類的時候的規則可以找到我們建立的類的名字，然後通過反射執行裡面的方法。

public class MyAnnotationUtil {
    public static void bind(Activity activity) {
        //獲取activity的decorView(根view)
        View view = activity.getWindow().getDecorView();
        String qualifiedName = activity.getClass().getName();

        //找到該activity對應的Bind類的名字
        String generateClass = qualifiedName + "_ViewBinding";
            //然後呼叫Bind類的構造方法,從而完成activity裡view的初始化
        try {
            Class.forName(generateClass).getConstructor(activity.getClass(), View.class).newInstance(activity, view);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在MainActivity中呼叫


public class MainActivity extends AppCompatActivity {
    @MyAnnotation(R.id.tv_hello)
    TextView mTextView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MyAnnotationUtil.bind(this);
        mTextView.setText("哈哈哈哈");
    }
}

執行專案可以看到手機上

這裡寫圖片描述

成功啦！ButterKnife的工作原理是不是很清晰啦！

用過ButterKnife的朋友都知道我們引入依賴的時候是有兩句話的：下面是最新版的ButterKnife

dependencies {
  compile 'com.jakewharton:butterknife:8.8.1'
  annotationProcessor 'com.jakewharton:butterknife-compiler:8.8.1'
}

老版的ButterKnife 第二句話是

apt 'com.jakewharton:butterknife-compiler:8.4.0'

annotationProcessor 和 apt是神馬鬼。它們是Android Studio中處理註解處理的外掛 處理註解的工具
其實它倆的作用是一樣的作用如下：

可以自動的幫你為生成的程式碼建立目錄,使註解處理器生成的程式碼能被Android Studio正確的引用，讓生成的程式碼編譯到APK裡面去
重點：只在編譯的時候執行依賴的庫，但是庫最終不打包到apk中， 因為我們的annotation-processor module的作用就是生成java檔案，我們的App中用到的是它生成的java檔案，而對於它自身的程式碼當打包完的時候是沒什麼用的，所以不應該打包到apk中。

所以我們的主專案中的依賴就可以改為：

    compile project(':annotation')
    annotationProcessor project(':annotation-processor')

把控制器annotation-processor改為annotationProcessor 依賴，執行專案效果跟上面的一樣，而這次我們的apk中會少了annotation-processor中程式碼，這樣做無疑可以使apk得到了優化。

apt跟annotationProcessor 的作用是一樣的，只不過apt是個人自由開發，比annotationProcessor 出來的早，後來谷歌開發了annotationProcessor， Android Gradle 外掛 2.2 版本內建annotationProcessor比apt的使用比apt簡單。與時俱進嗎，所以apt怎麼用就不說啦。

註解處理器的簡化：

上面在寫完註解處理器MyProcessor 之後進行了註解處理器的註冊
服務註冊檔案(resources/META-INF/services/javax.annotation.processing.Processor)
這樣建立很多個資料夾是不是很麻煩呀，沒關係有個簡單的方法。

現在把我們建立的resources/META-INF/services/javax.annotation.processing.Processor全部刪掉，重新編譯專案可以看到我們想要的java檔案沒有生成

然後給module annotation-processor 新增依賴

compile 'com.google.auto.service:auto-service:1.0-rc3'

然後在MyProcessor 類上添加註解

@AutoService(Processor.class)
public class MyProcessor extends AbstractProcessor{}

然後在編譯專案可以看到我們想要的 MainActivity_ViewBing.java檔案又出來了，執行專案效果跟上面一樣。

好啦，到此為止是不是發現ButterKnife的實現原理你已經明白了呢 ？哈哈哈哈哈 ！

相關推薦

ButterKnife編譯時註解探祕

安卓中很多有名的開源框架都運用了編譯時註解，如ButterKnife，EventBus , Retrofit , GreenDao等。所以作為一個合格的安卓開發者，學會運用編譯時註解是非常有必要的。 下面就仿照ButterKnife的view的注入寫一個例子來

通過編譯時註解生成程式碼實現自己的ButterKnife

背景概述 註解的處理除了可以在執行時通過反射機制處理外，還可以在編譯期進行處理。 Java5中提供了apt工具來進行編譯期的註解處理。apt是命令列工具，與之配套的是一套描述“程式在編譯時刻的靜態結構”的API：Mirror API（com.sun.mirr

使用編譯時註解簡單實現類似 ButterKnife 的效果

讀完本文你將瞭解： 什麼是編譯時註解 上篇文章 什麼是註解以及執行時註解的使用 中我們介紹了註解的幾種使用場景，這裡回顧一下： 編譯前提示資訊：註解可以被編譯器用來發現錯誤，或者清除不必要的警告； 編譯時生成程式碼：一些處理器可以在編譯時根據註

Kotlin編譯時註解，簡單實現ButterKnife

ButterKnife在之前的Android開發中還是比較熱門的工具，幫助Android開發者減少程式碼編寫，而且看起來更加的舒適，於是簡單實現一下ButterKnife，相信把下面的程式碼都搞懂，看ButterKnife的難度就小很多。 今天實現的是編譯時註解，其實執行時註解也一樣能實現ButterKnif

java註解之編譯時註解RetentionPolicy.CLASS 基本用法

1 前言 我們知道，在日常開發中我們常用的兩種註解是執行時註解和編譯時註解，執行時註解是通過反射來實現註解處理器的，對效能稍微有一點損耗，而編譯時註解是在程式編譯期間生成相應的代理類，替我們完成某些功能。今天我們來講解一下編譯時註解以及寫一個小例子，以便加深對編譯時註解的理解。

編譯時註解（三）Arouter原始碼講解

專案中我們有時需要跨模組startActivity，但是這樣需要配置menifest，不方便。這時就需要阿里的一個路由框架Arouter Arouter的使用就不再多說了。這篇文章主要講解他的原始碼 1.初始化 ARouter.init( this ); public sta

編譯時註解（一）AbstractProcessor實戰

Java中的註解(Annotation)是一個很神奇的東西，特別現在有很多Android庫都是使用註解的方式來實現的。 我們並不討論那些在執行時（Runtime）通過反射機制執行處理的註解，而是討論在編譯時（Compile time）處理的註解。下面便入手學習下

Android 如何編寫基於編譯時註解的專案

                     一、概述在Android應用開發中，我們常常為了提升開發效率會選擇使用一些基於註解的框架，但是由於反射造成一定執行效率的損耗，所以我們會更青睞於編譯時註解的框架，例如：butterknife免去我們編寫View的初始化以及事件的注入的程式碼。fragmentargs輕

編譯時註解（二）JavaPoet的使用

上一篇文章提到AbstractProcessor中生成java類，可以使用JavaPoet開源庫進行編寫。但是有個問題，addModifier提示無法找到Modifier，其實只要把 compile project(’:libprocess’) 改成 annot

利用編譯時註解生成Java原始碼

我們在編寫註解的時候，需要指定@Retention，有三個可選值，表示註解會被保留到那個階段。 RetentionPolicy.SOURCE       這種型別的Annotations只在原始碼級別保留,編譯時就會被忽略，因此一般用來為編譯器提供額外資訊，以便於檢測錯誤，

ButterKnife編譯時生成程式碼原理：butterknife-compiler原始碼分析

1.butterknife-compiler介紹上篇文章：註解框架原始碼分析（XUtils、ButterKnife），根據程式碼執行流程分析了xUtils和ButterKnife，ButterKnife最終實現註解方法的程式碼是通過編譯執行時生成的，也就是gradle依賴中b

kotlin編寫編譯時註解

1.定義註解 As裡新建一個Java Library module，必須是Java Library Module 此處命名為route-api 該module存放一些與純java類相關的檔案 1. 定義一個註解 Route /** * @param name

Java編譯時註解自動生成程式碼

在開始之前，我們首先申明一個非常重要的問題：我們並不討論那些在執行時（Runtime）通過反射機制執行處理的註解，而是討論在編譯時（Compile time）處理的註解。註解處理器是一個在javac中的，用來編譯時掃描和處理的註解的工具。可以為特定的註解，註冊自己的註解處

自定義註解之編譯時註解(RetentionPolicy.CLASS)（二）——JavaPoet

在使用編譯時註解時，需要在編譯期間對註解進行處理，在這裡我們沒辦法影響程式的執行邏輯，但我們可以進行一些需處理，比如生成一些功能性程式碼來輔助程式的開發，最常見的是生成.java 原始檔，並在程式中可以呼叫到生成的檔案。這樣我們就可以用註解來幫助我們處理一些固定邏輯的重複性

Android 如何編寫基於編譯時註解的專案---轉載張鴻洋博文

一、概述 在Android應用開發中，我們常常為了提升開發效率會選擇使用一些基於註解的框架，但是由於反射造成一定執行效率的損耗，所以我們會更青睞於編譯時註解的框架，例如： butterknife免去我們編寫View的初始化以及事件的注入的程式碼。fragmentargs輕鬆的為fragment新增引數資

如何除錯編譯時註解處理器AnnotationProcessor

本來的話是想跟大家分享如何製作自己的編譯時註解處理器的，後來搜尋了一下發現網上有不少這方面的文章，寫得都很全面很優秀，所以就不獻醜了。如果大家還不知道怎麼寫自己的編譯時註解處理器，可以看下這位大神寫的文章學習下：http://blog.csdn.net/lmj6

Android編譯時註解框架4-爬坑

概述 因為有關APT的資料過少，又因為是Java Moudle +Android Moudle的使用方式，在專案編寫過程中，會有一些匪夷所思的奇怪問題~入門階段真的是步履維艱。 這篇部落格就是編寫《Android編譯時註解框架》系列中，將所遇到的一些坑列舉出來，並給出

Java編譯時註解應用-生成格式化原始檔

引言 有許多開源框架在編譯時通過註解資訊生成新的原始檔，已到達簡化樣板程式碼的書寫，比如說典型的Builder模式，或者實現框架的功能的橋接程式碼。因為我使用編譯時註解只是想要簡化樣板程式碼，下面我就以Builder模式作為示例。 Builder模式

關於java編譯時註解你需要知道的二三事。解除你的顧慮！

做Android開發。大家肯定會關心你的app的效能問題。不知道從何時開始。網上有流傳一句。不要使用註解。用註解會影響效能。這不能說錯。但是也不能說對。這裡普及一下關於註解的一些你需要知道的知識 網上常說的註解。基本是執行時註解。而所說的註解會影響效能。則

使用butterKnife在編譯時發生錯誤

應該將activity中繫結的函式設定為public，否則會無法被xml使用導致編譯錯誤。 // 正確的 @OnClick(R.id.btn_connect_wifi) public void connectWifi(View view){ presenter.con