一小時搞明白註解處理器（Annotation Processor Tool）

Java中的註解是個很神奇的東西，還不瞭解的能夠看下一小時搞明白自定義註解（Annotation）。如今不少Android的庫都用使用註解實現的，好比ButterKnife，咱們不防也來學習一下，學完註解處理器，咱們嘗試寫一個簡單的相似ButterKnife的東西來綁定控件。java

什麼是註解處理器？android

註解處理器是（Annotation Processor）是javac的一個工具，用來在編譯時掃描和編譯和處理註解（Annotation）。你能夠本身定義註解和註解處理器去搞一些事情。一個註解處理器它以Java代碼或者（編譯過的字節碼）做爲輸入，生成文件（一般是java文件）。這些生成的java文件不能修改，而且會同其手動編寫的java代碼同樣會被javac編譯。看到這裏加上以前理解，應該明白大概的過程了，就是把標記了註解的類，變量等做爲輸入內容，通過註解處理器處理，生成想要生成的java代碼。git

處理器AbstractProcessorgithub

處理器的寫法有固定的套路，繼承AbstractProcessor。以下：api

public class MyProcessor extends AbstractProcessor {

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
    }

    @Override
    public Set getSupportedAnnotationTypes() {
        return null;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    @Override
    public boolean process(Set annotations, RoundEnvironment roundEnv) {
        return true;
    }
}複製代碼

init(ProcessingEnvironment processingEnv) 被註解處理工具調用，參數ProcessingEnvironment 提供了Element，Filer，Messager等工具
getSupportedAnnotationTypes() 指定註解處理器是註冊給那一個註解的，它是一個字符串的集合，意味着能夠支持多個類型的註解，而且字符串是合法全名。
getSupportedSourceVersion 指定Java版本
process(Set annotations, RoundEnvironment roundEnv) 這個也是最主要的，在這裏掃描和處理你的註解並生成Java代碼，信息都在參數RoundEnvironment 裏了，後面會介紹。

在Java7 中還可使用

@SupportedSourceVersion(SourceVersion.latestSupported())
@SupportedAnnotationTypes({
   // 合法註解全名的集合
 })複製代碼

代替 getSupportedSourceVersion() 和 getSupportedAnnotationType() ,沒毛病，還能夠在註解處理離器中使用註解。

註冊註解處理器
markdown

打包註解處理器的時候須要一個特殊的文件 javax.annotation.processing.Processor 在 META-INF/services 路徑下app

－－myprcessor.jar
－－－－com
－－－－－－example
－－－－－－－－MyProcessor.class
－－－－META-INF
－－－－－－services
－－－－－－－－javax.annotation.processing.Processor複製代碼

打包進javax.annotation.processing.Processor的內容是處理器的合法全稱，多個處理器之間換行。ide

com.example.myprocess.MyProcessorA
com.example.myprocess.MyProcessorB複製代碼

google提供了一個註冊處理器的庫函數

compile 'com.google.auto.service:auto-service:1.0-rc2'複製代碼

一個註解搞定：工具

@AutoService(Processor.class)
public class MyProcessor extends AbstractProcessor {
      ...
}複製代碼

讀到這裏ButterKnife用到的知識點咱們都已經瞭解了

1.自定義註解

2.用註解處理器解析註解

3.解析完成後生成Java文件

BufferKnife使用：

public class MainActivity extends AppCompatActivity {

    @Bind(R.id.rxjava_demo)
    Button mRxJavaDemo;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
        mRxJavaDemo.setText("Text");
    }

}
複製代碼

而後咱們編譯一下，打開路徑：/app/build/intermediates/classes/release/com/ming/rxdemo/MainActivity?ViewBinder.class

這就是咱們生成的Java文件，能夠看到Button已經在bind裏面初始化了。

public class MainActivity$ViewBinder implements ViewBinder {
    public MainActivity$ViewBinder() {
    }

    public void bind(Finder finder, T target, Object source) {
        View view = (View)finder.findRequiredView(source, 2131492944, "field \'mRxJavaDemo\'");
        target.mRxJavaDemo = (Button)finder.castView(view, 2131492944, "field \'mRxJavaDemo\'");
    }

    public void unbind(T target) {
        target.mRxJavaDemo = null;
    }
}複製代碼

接下來咱們建立一個項目，寫一個簡單的用註解綁定控件的例子

項目結構

－－apt-demo
－－－－bindview-annotation(Java Library)
－－－－bindview-api(Android Library)
－－－－bindview-compiler(Java Library)
－－－－app(Android App)複製代碼

bindview-annotation 註解聲明
bindview-api 調用Android SDK API
bindview-compiler 註解處理器相關
app 測試App

1.在 bindview-annotation 下建立一個@BindView註解，該註解返回一個值，整型，名字爲value，用來表示控件ID。

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.CLASS)
public @interface BindView {
    /**
     * 用來裝id
     *
     * @return
     */
    int value();
}複製代碼

2.在 bindview-compiler 中建立註解處理器 BindViewProcessor 並註冊，作基本的初始化工做。

@AutoService(Processor.class)
public class BindViewProcessor extends AbstractProcessor {
    /**
     * 文件相關的輔助類
     */
    private Filer mFiler;
    /**
     * 元素相關的輔助類
     */
    private Elements mElementUtils;
    /**
     * 日誌相關的輔助類
     */
    private Messager mMessager;
    /**
     * 解析的目標註解集合
     */
    private Map mAnnotatedClassMap = new HashMap<>();

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        mElementUtils = processingEnv.getElementUtils();
        mMessager = processingEnv.getMessager();
        mFiler = processingEnv.getFiler();
    }

    @Override
    public Set getSupportedAnnotationTypes() {
        Set types = new LinkedHashSet<>();
        types.add(BindView.class.getCanonicalName());//返回該註解處理器支持的註解集合
        return types;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    @Override
    public boolean process(Set annotations, RoundEnvironment roundEnv) {
        return true;
    }
}複製代碼

是否是注意到了裏面有個Map容器，並且類型是AnnotatedClass，這是幹啥的呢？這個很好理解，咱們在解析XML，解析Json的時候數據解析完以後是否是要以對象的形式表示出來，這裏也同樣，@BindView用來標記類成員，一個類下能夠有多個成員，比如一個Activity中能夠有多個控件，一個容器下有多個控件等。以下：

package com.mingwei.myprocess.model;

import com.mingwei.myprocess.TypeUtil;
import com.squareup.javapoet.ClassName;
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.util.ArrayList;
import java.util.List;

import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;

/**
 * Created by mingwei on 12/10/16.
 * CSDN:    http://blog.csdn.net/u013045971
 * Github:  https://github.com/gumingwei
 */
public class AnnotatedClass {
    /**
     * 類名
     */
    public TypeElement mClassElement;
    /**
     * 成員變量集合
     */
    public List mFiled;
    /**
     * 元素輔助類
     */
    public Elements mElementUtils;

    public AnnotatedClass(TypeElement classElement, Elements elementUtils) {
        this.mClassElement = classElement;
        this.mElementUtils = elementUtils;
        this.mFiled = new ArrayList<>();
    }
    /**
     * 獲取當前這個類的全名
     */
    public String getFullClassName() {
        return mClassElement.getQualifiedName().toString();
    }
    /**
     * 添加一個成員
     */
    public void addField(BindViewField field) {
        mFiled.add(field);
    }
    /**
     * 輸出Java
     */
    public JavaFile generateFinder() {
        return null;
    }
    /**
     * 包名
     */
    public String getPackageName(TypeElement type) {
        return mElementUtils.getPackageOf(type).getQualifiedName().toString();
    }
    /**
     * 類名
     */
    private static String getClassName(TypeElement type, String packageName) {
        int packageLen = packageName.length() + 1;
        return type.getQualifiedName().toString().substring(packageLen).replace('.', '複製代碼

); } } 成員用BindViewField表示，沒什麼複雜的邏輯，在構造函數判斷類型和初始化，簡單的get函數

package com.mingwei.myprocess.model;

import com.mingwe.myanno.BindView;

import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.Name;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.TypeMirror;

/**
 * Created by mingwei on 12/10/16.
 * CSDN:    http://blog.csdn.net/u013045971
 * Github:  https://github.com/gumingwei
 * 被BindView註解標記的字段的模型類
 */
public class BindViewField {

    private VariableElement mFieldElement;

    private int mResId;

    public BindViewField(Element element) throws IllegalArgumentException {
        if (element.getKind() != ElementKind.FIELD) {//判斷是不是類成員
            throw new IllegalArgumentException(String.format("Only field can be annotated with @%s",
                    BindView.class.getSimpleName()));
        }
        mFieldElement = (VariableElement) element;
        //獲取註解和值
        BindView bindView = mFieldElement.getAnnotation(BindView.class);
        mResId = bindView.value();
        if (mResId < 0) {
            throw new IllegalArgumentException(String.format("value() in %s for field % is not valid",
                    BindView.class.getSimpleName(), mFieldElement.getSimpleName()));
        }
    }

    public Name getFieldName() {
        return mFieldElement.getSimpleName();
    }

    public int getResId() {
        return mResId;
    }

    public TypeMirror getFieldType() {
        return mFieldElement.asType();
    }
}複製代碼

這裏看到了不少的Element，在Xml解析時候就有Element這個概念。在Java源文件中一樣有Element概念：

package com.example;        // PackageElement

public class MyClass {      // TypeElement

    private int a;          // VariableElement

    private Foo other;      // VariableElement

    public Foo () {}        // ExecuteableElement

    public void setA (      // ExecuteableElement
                int newA    // TypeElement
                ) {

    }
}複製代碼

接下來就是在處理器的process中解析註解了

每次解析前都要清空，由於process方法可能不止走一次。

拿到註解模型以後遍歷調用生成Java代碼

@Override
    public boolean process(Set annotations, RoundEnvironment roundEnv) {
        mAnnotatedClassMap.clear();
        try {
            processBindView(roundEnv);
        } catch (IllegalArgumentException e) {
            error(e.getMessage());
            return true;
        }

        try {
            for (AnnotatedClass annotatedClass : mAnnotatedClassMap.values()) {
                info("generating file for %s", annotatedClass.getFullClassName());
                annotatedClass.generateFinder().writeTo(mFiler);
            }
        } catch (Exception e) {
            e.printStackTrace();
            error("Generate file failed,reason:%s", e.getMessage());
        }
        return true;
    }複製代碼

processBindView 和 getAnnotatedClass

/**
     * 遍歷目標RoundEnviroment
     * @param roundEnv
     */
    private void processBindView(RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(BindView.class)) {
            AnnotatedClass annotatedClass = getAnnotatedClass(element);
            BindViewField field = new BindViewField(element);
            annotatedClass.addField(field);
        }
    }
    /**
     * 若是在map中存在就直接用，不存在就new出來放在map裏
     * @param element
     */
    private AnnotatedClass getAnnotatedClass(Element element) {
        TypeElement encloseElement = (TypeElement) element.getEnclosingElement();
        String fullClassName = encloseElement.getQualifiedName().toString();
        AnnotatedClass annotatedClass = mAnnotatedClassMap.get(fullClassName);
        if (annotatedClass == null) {
            annotatedClass = new AnnotatedClass(encloseElement, mElementUtils);
            mAnnotatedClassMap.put(fullClassName, annotatedClass);
        }
        return annotatedClass;
    }複製代碼

3.在生成Java以前咱們要在bindview-api 中建立一些類，配合 bindview-compiler 一塊兒使用。

你在使用Butterknife的時候不是要在onCreate裏掉用一下BindView.bind(this)嗎，那這個玩意是幹什麼呢。試想一下，前面作的一大堆工做是爲了生成自動綁定控件的Java代碼，若是生成的Java代碼不能和你要使用的地方關聯起來，那也是沒有用的，能夠把BindView.bind(this)理解爲調用了你生成的Java代碼，而生成了代碼中完成了一些控件的初始化工做，天然你的控件就變得可用了。

接口：Finder 定義findView方法

實現類：ActivityFinder Activity中使用，ViewFinder View中使用

接口：Injector inject方法未來是要建立在生成的Java文件中，用該方法中傳遞過來的參數進行控件的初始化。

輔助類：ViewInjector 調用和傳遞參數

這個代碼我就不貼了，就一點點內容，一看就明白了。

4.在AnnotatedClass中生成Java代碼

生成代碼使用了一個很好用的庫 Javapoet 。類，方法，均可以使用構建器構建出來，很好上手，不再用拼接字符串了。哈哈哈哈～

public JavaFile generateFinder() {
        //構建方法
        MethodSpec.Builder injectMethodBuilder = MethodSpec.methodBuilder("inject")
                .addModifiers(Modifier.PUBLIC)//添加描述
                .addAnnotation(Override.class)//添加註解
                .addParameter(TypeName.get(mClassElement.asType()), "host", Modifier.FINAL)//添加參數
                .addParameter(TypeName.OBJECT, "source")//添加參數
                .addParameter(TypeUtil.FINDER, "finder");//添加參數

        for (BindViewField field : mFiled) {
            //添加一行
            injectMethodBuilder.addStatement("host.$N=($T)finder.findView(source,$L)", field.getFieldName()
                    , ClassName.get(field.getFieldType()), field.getResId());
        }

        String packageName = getPackageName(mClassElement);
        String className = getClassName(mClassElement, packageName);
        ClassName bindClassName = ClassName.get(packageName, className);
        //構建類
        TypeSpec finderClass = TypeSpec.classBuilder(bindClassName.simpleName() + "$Injector")//類名
                .addModifiers(Modifier.PUBLIC)//添加描述
                .addSuperinterface(ParameterizedTypeName.get(TypeUtil.INJECTOR, TypeName.get(mClassElement.asType())))//添加接口（類／接口，範型）
                .addMethod(injectMethodBuilder.build())//添加方法
                .build();

        return JavaFile.builder(packageName, finderClass).build();
    }

    public String getPackageName(TypeElement type) {
        return mElementUtils.getPackageOf(type).getQualifiedName().toString();
    }

    private static String getClassName(TypeElement type, String packageName) {
        int packageLen = packageName.length() + 1;
        return type.getQualifiedName().toString().substring(packageLen).replace('.', '複製代碼

); }

能夠在代碼裏System.out調試註解處理器的代碼。

還要注意的一點，項目之間的相互引用。

bindview-complier 引用 bindview-annotation

app 引用了剩下的三個module，在引用 bindview-complier 的時候用的apt的方式

apt project(':bindview-compiler')複製代碼

就寫到這裏吧，Demo 放在 Github上了