Android高级进阶之-APT原理解析及仿写ButterKnife实现View的自动绑定功能

我们在使用Dagger2、ButterKnife等框架的时候，会发现它们通过简单的注解就实现了强大的功能。不知道你又没有研究过这些框架又究竟是如何实现他们功能的呢？本篇文章就是带着这个问题来探究其原理并且自己实现一个简单的ButterKnife的View绑定功能框架。

其实使用过Dagger2或者ButterKnife框架的人都会注意到在项目的build->generated->source->apt 下面会在编译后生成一些java文件：

apt目录

没错，这里的MainActivity_Binding.java 就是编译时编译器自动生成的，上述的两个框架很多核心功能的实现也是通过apt目录下面的这些代码来完成的。我们不妨先看看我这里自己实现的ButterKnife框架是如何做到View自动绑定的。

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

import carlwu.top.annotation.BindView;
import carlwu.top.annotation.ButterKnife;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "sssssss";
    @BindView(R.id.tv1)
    TextView mTextView1;
    @BindView(R.id.tv2)
    TextView mTextView2;

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

        Log.d(TAG, "onCreate: "+mTextView1.getText().toString()+"   ,  "+mTextView2.getText().toString());
    }
}

我们这里的MainActivity使用了ButterKnife对不对？其实你注意一下ButterKnife的包名你会发现这是我自己实现的ButterKnife，但是用法上和原生的ButterKnife一模一样。接下来看看ButterKnife.bind(this)里面的代码：

public class ButterKnife {
    public static void bind(Object o){
        try {
            Class bindingClass = Class.forName(o.getClass().getName() + "_Binding");
            Method method = bindingClass.getMethod("bindViews",o.getClass());
            method.invoke(null,o);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

bind()方法内部使用了反射拿到了一个名称叫做“MainActivity_Binding”类下面的静态方法“bindViews”，并且调用了这个“bindViews”方法，那好，“MainActivity_Binding”不就是刚刚我们截图看到的apt目录下面编译器生成的一个类吗？顺藤摸瓜我们看看“MainActivity_Binding”是怎么实现的：

public final class MainActivity_Binding {
  public static void bindViews(MainActivity obj) {
    obj.mTextView1 = obj.findViewById(2131165307);
    obj.mTextView2 = obj.findViewById(2131165308);
  }
}

看到这里，恍然大悟了，bindViews的参数就是MainActivity，这里直接访问MainActivity里面我们加了注解@BindView(int id)的View控件，然后赋值findViewById(2131165307) ，我们有理由详细里的参数id就是在使用注解的时候传递进去的id：

    @BindView(R.id.tv1)
    TextView mTextView1;
    @BindView(R.id.tv2)
    TextView mTextView2;

看到这里，你就完全明白自动绑定View原来是这么一回事了：在Activity中对需要自动绑定的View加上注解，注解里面传递View的Id参数，然后在onCreate()方法的 setContentView(R.layout.activity_main)后执行ButterKnife.bind(this)，完成自动绑定。

那么接下来的工作就全部放在如何去生成这些Activity_Binding.java文件呢？答案回到了这个关键字“APT”。

apt全称可以叫做“annotation processor tool”，注解处理工具。

我们用过原生ButterKnife的人都是到如何去引用这个框架：

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

之所以引用这两个工程也是有原因的，第一个“implementation”是常规的库引用，可以直接告诉你，里面写的是一些要使用到的注解类以及其他工具类，在我们的自己实现ButterKnife中也这么做的：

注解工程目录结构

是的这个注解工程很简单，就给了@BindView以及ButterKnife的实现，那么除了注解工程，我们还需要一个处理注解的工程，就是“annotationProcessor”来指定的了：

注解处理工程目录结构

我们编译期间自动生成Activity_Binding.java的工作就是交给注解处理工程来完成的。

需要注意的是，我们的annotation工程以及compiler工程都只提供java文件的使用，所以在build.gradle中只需要把他们定义成java-library即可。

apply plugin: 'java-library'

compiler工程使用google提供的自动绑定功能，它的完整build.gradle如下：

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation 'com.google.auto.service:auto-service:1.0-rc2'//自动绑定
    implementation 'com.squareup:javapoet:1.7.0'

    implementation project(':annotation')
}

sourceCompatibility = "1.7"
targetCompatibility = "1.7"

好，接下来是时候看看注解处理工程里面是怎么实现的了。

import carlwu.top.annotation.BindView;

@SupportedAnnotationTypes("carlwu.top.annotation.BindView")
@SupportedSourceVersion(SourceVersion.RELEASE_7)
@AutoService(Processor.class)
public class MyProcessor extends AbstractProcessor {

    //日志工具
    private Messager messager;
    //文件工具
    private Filer filer;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        messager = processingEnvironment.getMessager();
        filer = processingEnvironment.getFiler();
        messager.printMessage(Diagnostic.Kind.NOTE, "myProcessor init================");
    }

    @Override
    public boolean process(Set set, RoundEnvironment roundEnvironment) {
        Map> map = new HashMap<>();
        for (TypeElement typeElement : set) {
            for (Element fieldElement : roundEnvironment.getElementsAnnotatedWith(typeElement)) {
                Element classElement = fieldElement.getEnclosingElement();
                if (fieldElement.getModifiers().contains(Modifier.PRIVATE))
                    throw new RuntimeException("@BindView can't annotate private field with " + fieldElement.getSimpleName()+" in "+classElement.getSimpleName());
                List list;
                if (map.containsKey(classElement))
                    list = map.get(classElement);
                else {
                    list = new ArrayList<>();
                    map.put(classElement, list);
                }
                list.add(fieldElement);
                messager.printMessage(Diagnostic.Kind.NOTE, "0000");
            }
        }
        javaFileOutput(map);
        return true;
    }

    private void javaFileOutput(Map> map) {
        for (Map.Entry> entry : map.entrySet()) {
            MethodSpec.Builder constructorBuilder = MethodSpec.methodBuilder("bindViews")
                    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                    .addParameter(ClassName.get(entry.getKey().asType()), "obj");
            for (Element fieldElement : entry.getValue()) {
                constructorBuilder.addStatement("$L.$L = $L.findViewById($L)", "obj", fieldElement.getSimpleName(), "obj", fieldElement.getAnnotation(BindView.class).value());
            }

            TypeSpec helloWorld = TypeSpec.classBuilder(entry.getKey().getSimpleName() + "_Binding")
                    .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
                    .addMethod(constructorBuilder.build())
                    .build();

            JavaFile javaFile = JavaFile.builder(((PackageElement) entry.getKey().getEnclosingElement()).getQualifiedName().toString(), helloWorld)
                    .build();
            try {
                javaFile.writeTo(filer);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

我们这个类的核心就是在process()方法里面，它使用到了叫做“javapoet”的工具来拼接出我们想要生成的Activity_Binding类，然后在：

            try {
                javaFile.writeTo(filer);
            } catch (IOException e) {
                e.printStackTrace();
            }

实现了java文件的输出。不熟悉javapoet的朋友可以看看git上关于它的介绍，也是很简单的。

https://github.com/square/javapoet

我们再来看看MainActivity和MainActivity_Binding这亮个java类：

package carlwu.top.apt4butterknife;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "sssssss";
    @BindView(R.id.tv1)
    TextView mTextView1;
    @BindView(R.id.tv2)
    TextView mTextView2;

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

package carlwu.top.apt4butterknife;

public final class MainActivity_Binding {
  public static void bindViews(MainActivity obj) {
    obj.mTextView1 = obj.findViewById(2131165307);
    obj.mTextView2 = obj.findViewById(2131165308);
  }
}

会发现两个要点：
①MainActivity 和MainActivity_Binding 是在相同的包下面的。
②MainActivity 中加了@BindView注解的View成员都是默认修饰符，也就是包访问的。

你是否知道为什么要关注这两个焦点吗？首先是View成员不能加private修饰，private就是私有类型了，那么我们的MainActivity_Binding 岂不是没法访问MainActivity 中的View成员，那就没法去绑定了是吧。然后我们让MainActivity 和MainActivity_Binding 同包目录，也是为了方便View成员在默认修饰符时，只能包内访问才这么做的，你想，如不MainActivity 和MainActivity_Binding 不同包目录，那么MainActivity 中的View成员就要被迫加上public修饰了，这样该多麻烦。

OK，文章写到这里整个apt原理和ButterKnife自动绑定View的功能也讲清楚了，当然原生的ButterKnife远不止这么简单，但也都是按照这个思路去一步步完善的。

最后，附上源码地址。
链接：https://share.weiyun.com/5TWiMEy