Android 如何編寫基於編譯時注解的項目

這裡的描述有點模糊沒關系，一會結合代碼就好理解了。

a.收集信息

private Map mProxyMap = new HashMap();
@Override
public boolean process(Set annotations, RoundEnvironment roundEnv){
    mProxyMap.clear();
    Set elements = roundEnv.getElementsAnnotatedWith(BindView.class);
    //一、收集信息
    for (Element element : elements){
        //檢查element類型
        if (!checkAnnotationUseValid(element)){
            return false;
        }
        //field type
        VariableElement variableElement = (VariableElement) element;
        //class type
        TypeElement typeElement = (TypeElement) variableElement.getEnclosingElement();//TypeElement
        String qualifiedName = typeElement.getQualifiedName().toString();

        ProxyInfo proxyInfo = mProxyMap.get(qualifiedName);
        if (proxyInfo == null){
            proxyInfo = new ProxyInfo(mElementUtils, typeElement);
            mProxyMap.put(qualifiedName, proxyInfo);
        }
        BindView annotation = variableElement.getAnnotation(BindView.class);
        int id = annotation.value();
        proxyInfo.mInjectElements.put(id, variableElement);
    }
    return true;
}

首先我們調用一下 mProxyMap.clear(); ，因為process可能會多次調用，避免生成重復的代理類，避免生成類的類名已存在異常。

然後，通過 roundEnv.getElementsAnnotatedWith 拿到我們通過 @BindView 注解的元素，這裡返回值，按照我們的預期應該是 VariableElement 集合，因為我們用於成員變量上。

接下來for循環我們的元素，首先檢查類型是否是 VariableElement .

然後拿到對應的類信息 TypeElement ，繼而生成 ProxyInfo 對象，這裡通過一個 mProxyMap 進行檢查，key為 qualifiedName 即類的全路徑，如果沒有生成才會去生成一個新的， ProxyInfo 與類是一一對應的。

接下來，會將與該類對應的且被 @BindView 聲明的 VariableElement 加入到 ProxyInfo 中去，key為我們聲明時填寫的id，即View的id。

這樣就完成了信息的收集，收集完成信息後，應該就可以去生成代理類了。

b.生成代理類

@Override
public boolean process(Set annotations, RoundEnvironment roundEnv){
    //...省略收集信息的代碼，以及try,catch相關
    for(String key : mProxyMap.keySet()){
        ProxyInfo proxyInfo = mProxyMap.get(key);
        JavaFileObject sourceFile = mFileUtils.createSourceFile(
                proxyInfo.getProxyClassFullName(), proxyInfo.getTypeElement());
            Writer writer = sourceFile.openWriter();
            writer.write(proxyInfo.generateJavaCode());
            writer.flush();
            writer.close();
    }
    return true;
}

可以看到生成代理類的代碼非常的簡短，主要就是遍歷我們的 mProxyMap ，然後取得每一個 ProxyInfo ，最後通過 mFileUtils.createSourceFile 來創建文件對象，類名為 proxyInfo.getProxyClassFullName() ，寫入的內容為 proxyInfo.generateJavaCode() .

看來生成Java代碼的方法都在ProxyInfo裡面。

c.生成Java代碼

這裡我們主要關注其生成Java代碼的方式。下面主要看生成Java代碼的方法：

#ProxyInfo
//key為id，value為對應的成員變量
public Map mInjectElements = new HashMap();

public String generateJavaCode(){
    StringBuilder builder = new StringBuilder();
    builder.append("package " + mPackageName).append(";\n\n");
    builder.append("import com.zhy.ioc.*;\n");
    builder.append("public class ").append(mProxyClassName).append(" implements " + SUFFIX + "<" + mTypeElement.getQualifiedName() + ">");
    builder.append("\n{\n");
    generateMethod(builder);
    builder.append("\n}\n");
    return builder.toString();
}
private void generateMethod(StringBuilder builder){
     builder.append("public void inject("+mTypeElement.getQualifiedName()+" host , Object object )");
    builder.append("\n{\n");
    for(int id : mInjectElements.keySet()){
        VariableElement variableElement = mInjectElements.get(id);
        String name = variableElement.getSimpleName().toString();
        String type = variableElement.asType().toString() ;

        builder.append(" if(object instanceof android.app.Activity)");
        builder.append("\n{\n");
        builder.append("host."+name).append(" = ");
        builder.append("("+type+")(((android.app.Activity)object).findViewById("+id+"));");
        builder.append("\n}\n").append("else").append("\n{\n");
        builder.append("host."+name).append(" = ");
        builder.append("("+type+")(((android.view.View)object).findViewById("+id+"));");
        builder.append("\n}\n");
    }
    builder.append("\n}\n");
}

這裡主要就是靠收集到的信息，拼接完成的代理類對象了，看起來會比較頭疼，不過我給出一個生成後的代碼，對比著看會很多。

package com.zhy.ioc_sample;
import com.zhy.ioc.*;
public class MainActivity$$ViewInjector implements ViewInjector{
    @Override
    public void inject(com.zhy.sample.MainActivity host , Object object ){
        if(object instanceof android.app.Activity){
            host.mTv = (android.widget.TextView)(((android.app.Activity)object).findViewById(2131492945));
        }
        else{
            host.mTv = (android.widget.TextView)(((android.view.View)object).findViewById(2131492945));
        }
    }
}

這樣對著上面代碼看會好很多，其實就死根據收集到的成員變量（通過 @BindView 聲明的），然後根據我們具體要實現的需求去生成java代碼。

這裡注意下，生成的代碼實現了一個接口 ViewInjector ，該接口是為了統一所有的代理類對象的類型，到時候我們需要強轉代理類對象為該接口類型，調用其方法；接口是泛型，主要就是傳入實際類對象，例如 MainActivity ，因為我們在生成代理類中的代碼，實際上就是 實際類.成員變量 的方式進行訪問，所以，使用編譯時注解的成員變量一般都不允許 private 修飾符修飾（有的允許，但是需要提供getter,setter訪問方法）。

這裡采用了完全拼接的方式編寫Java代碼，你也可以使用一些開源庫，來通過Java api的方式來生成代碼，例如：

A Java API for generating .java source files.

到這裡我們就完成了代理類的生成，這裡任何的注解處理器的編寫方式基本都遵循著收集信息、生成代理類的步驟。

五、API模塊的實現

有了代理類之後，我們一般還會提供API供用戶去訪問，例如本例的訪問入口是

//Activity中
 Ioc.inject(Activity);
 //Fragment中，獲取ViewHolder中
 Ioc.inject(this, view);

模仿了butterknife，第一個參數為宿主對象，第二個參數為實際調用 findViewById 的對象；當然在Actiivty中，兩個參數就一樣了。

其實很簡單，只要你了解了其原理，這個API就干兩件事：

• 根據傳入的host尋找我們生成的代理類：例如 MainActivity->MainActity$$ViewInjector 。
• 強轉為統一的接口，調用接口提供的方法。

這兩件事應該不復雜，第一件事是拼接代理類名，然後反射生成對象，第二件事強轉調用。

public class Ioc{
    public static void inject(Activity activity){
        inject(activity , activity);
    }
    public static void inject(Object host , Object root){
        Class clazz = host.getClass();
        String proxyClassFullName = clazz.getName()+"$$ViewInjector";
       //省略try,catch相關代碼 
        Class proxyClazz = Class.forName(proxyClassFullName);
        ViewInjector viewInjector = (com.zhy.ioc.ViewInjector) proxyClazz.newInstance();
        viewInjector.inject(host,root);
    }
}
public interface ViewInjector{
    void inject(T t , Object object);
}

代碼很簡單，拼接代理類的全路徑，然後通過 newInstance 生成實例，然後強轉，調用代理類的inject方法。

這裡一般情況會對生成的代理類做一下緩存處理，比如使用 Map 存儲下，沒有再生成，這裡我們就不去做了。

這樣我們就完成了一個編譯時注解框架的編寫。

六、總結

本文通過具體的實例來描述了如何編寫一個基於編譯時注解的項目，主要步驟為：項目結構的劃分、注解模塊的實現、注解處理器的編寫以及對外公布的API模塊的編寫。通過文本的學習應該能夠了解基於編譯時注解這類框架運行的原理，以及自己如何去編寫這樣一類框架。