ButterKnife源码探究（附实现自定义注解处理器）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/rikkatheworld/article/details/88771869

今天直接解决ButterKnife的源码，Butter Knife直译过来就是黄油刀。

它使用编译时注解的方式来完成Android中控件和点击事件的绑定。

不用再重复的去写findViewById以及setOnClickListener代码了，提升了开发效率，解放了开发者的双手。

---

编译时注解概念

编译时注解的定义是：程序在编译阶段，根据注解生成想要生成的任何文件或者其他的逻辑处理。
这里使用的是ButterKnife9.0，配置教程在这里配置教程，需要把最低sdk调成26
比如我们在MainActivity中绑定一个控件：

@BindView(R.id.user_name)
EditText mName;

那么在编译运行项目时，就会在app模块的"builde/generated/source/apt/debug/包名/"目录下生成MainActivity_ViewBinding.java文件。MainActivity_ViewBinding.java的代码如下：

这个文件就是在编译阶段，butter knife注解自动生成的。
在使用ButterKnife时我们调用其bind方法来完成控件的绑定，但实质上bind方法内部调用了生成的java文件MainActivity_ViewBinding的构造方法来完成最后的绑定。
如果调用MainActivity_ViewBinding的构造方法，EditTest对象mName会通过ButterKnife的工具类Utils中的工具方法findRequiredViewAsType来找到，其内部还是通过findViewById来实现的，ButterKnife的绑定功能都是通过编译时生成的代码实现的。
另外，这样做比在运行时通过反射来完成绑定在性能上效果更好。

Element

在了解编译时注解之前，我们需要了解Element类。使用编译时注解的框架上基本都是用了Element，它是实现编译时注解解析处理功能的基石。
Element在javax.lang.model.element包下，一个Element表示一个程序元素，比如包、类、方法，都是一个元素，Element子类常用的有 ExecutableElement、PackageElement、TypeElement
、VariableElement等
比如一个最简单的例子：

package com.rikka.test;       //PackageElement

public class Test{                 //TypeElement
           private int value;       //VariableElement
           
           //ExecutableElement
           public int add(int a,int b){
              return a+b;
            }
}

Element有几个方法比较重要，用的比较多：

• getEnclosingElement
  获取一个元素的外部元素，比如上述例子中的value和add方法分别对应VariableElement和ExecutableElement，如果调用他们的getEnclosingElement方法，得到的是Test的元素 TypeElement
• getEnclosedElement
  获取一个元素的内部包含的元素集合，如果调用Test类的getEnclosedElement，将会得到VariableElement和ExecutableElement构成的Element集合。

---

自定义实现编译时注解

我们定义两个注解InjectSting和InjectInt来在代码中注解字符串和整型的成员变量，让这些成员变量能够自动从资源文件中获取到对应的值来完成初始化。

（1）定义注解
使用Android Studio创建项目后，新建模块JavaLibrary名为annotation是，在里面定义注解：

扫描二维码关注公众号，回复： 6040474 查看本文章

//InjectString.java文件
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface InjectInt {
}
//InjectInt.java文件
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface InjectString {
}

这里面@interfaace定义一个注解类，@Retentaion和@Target修饰注解类InjectString和InjectInt，用来乘坐注解的注解，也是元注解。这里有元注解的教程传送门 ， @Retentaion指定注解保留的时长，具体保留至什么时候，由RetentaionPolicy这个枚举类型定义：

public enum RetentionPolicy {  
    /** 
     * 注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃. 
     * 这意味着注解仅存在于编译器处理期间，编译器处理完之后，该注解就没用了，在class文件找不到了
     */  
    SOURCE,  
  
    /** 
     * 注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期. 
     * 简单来说就是你在class文件中还能看到注解
     */  
    CLASS,  
  
    /** 
     * 注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在， 
     * 保存到class对象中，可以通过反射来获取 
     */  
    RUNTIME  
}  

@Target指定注解修饰的类型，由枚举类型ElementType定义：

public enum ElementType {
    TYPE,          //类，接口，enum
    FIELD,         //成员变量
    METHOD,    //方法
    PARAMETER,   //方法参数或者构造方法参数
    CONSTRUCTOR,     //构造方法
    LOCAL_VARIABLE,    //局部变量
    ANNOTATION_TYPE,  //注解类型
    PACKAGE,                   //包
    TYPE_PARAMETER,     //类型参数，1.8加入
    TYPE_USE               //类型使用 1.8加入
}

将InjectString和InjectInt的@Target设置为ElementType.FIELD，所以他们只能注解成员变量。

（2）使用注解
在app模块的build.gradle中依赖annotions模块：

dependencies {
   compile project(':annotations')
}

然后在MainActivity中使用两个注解InjectString和InjectInt分别来注解两个成员变量：

   @InjectString
    public String hello;

    @InjectString
    public String world;

    @InjectInt
    public int one;

    @InjectInt
    public int two;

在资源文件中创建成员变量同名的字符串和整型资源：

//res/values/ints
<resources>
    <integer name="one">1</integer>
    <integer name="two">2</integer>
</resources>
//res/values/strings
<resources>
    <string name="hello">Hello</string>
    <string name="world">World</string>
</resources>

我们期望通过注解生成一个对应的Java类来处理资源和成员变量的绑定，假设期望生成的代码如下：

public class MainAcivity_Inject{
 public MainActivity_Inject(Context context){
   ((MainActivity)context).one=context.getResources().getInteger(R.integer.one);
   ......
   }
}

这样就只需要在MainActivity的onCreate方法中调用MainActivity_Inject的构造方法就能完成成员变量的初始化了。

所以接下来的任务就是解析在代码中使用的注解，根据注解生成MainActivity_Inject.java这个文件

（3）解析注解
新建一个Java Library模块命名为compiler，在其中创建一个类InjectProcessor，继承自AbstractProcessor，AbstractProcessor类为注解处理器的抽象类。在编译阶段，会查找指定的注解处理器实现类，并调用其process方法，完成注解的解析。

//配置注解处理器支持处理的注解类型为InjectString和InjectInt
@SupportedAnnotationTypes({"com.example.annotations.InjectString", 
"com.example.annotations.InjectInt"})

//配置注解处理器支持的Java版本
@SupportedSourceVersion(SourceVersion.RELEASE_7)
@AutoService(Processor.class)
//定义注解处理器继承自AbstractProcessor
public class InjectProcessor extends AbstractProcessor{

    private static final ClassName CONTEXT = ClassName.get("android.content", "Context");

    //待生成java文件的的集合，key为被注解的类的类名，value为GenerateJavaFile对象
    private HashMap<String,GenerateJavaFile> mGenerateJavaFiles = new HashMap<String, GenerateJavaFile>();

    /**
     * 实现process方法，完成注解的解析和处理，通常生成文件或者校验处理
     * @param set 定义的注解类型的集合
     * @param roundEnvironment 回合环境，注解的处理可能要经过几个回合的处理，每个回合处理一批注解
     * @return 返回true表示注解被当前注解处理器处理，就不会再交给其他注解处理器
     */
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        //遍历所有的TypeElement的，一个注解类型对应一个TypeElement
        for (TypeElement typeElement : set) {
            //遍历在代码中使用typeElement对应注解类型来注解的元素
            //例如：如果typeElement对应的是InjectString注解类型，那么Element对应为使用@InjectString注解的成员变量
            for (Element element : roundEnvironment.getElementsAnnotatedWith(typeElement)) {
                //添加注解元素到将要生成的java文件对应的GenerateJavaFile的对象中
                addElementToGenerateJavaFile(element);
            }
        }
        //生成java文件
        createJavaFile();
        return true;
    }
}

因为之前定义的InjectString和InjectInt是类，所以他们的Element类型是TypeElement，一个TypeElement对应一个注解类型，所以process传入的set集合中有两个TypeElement对象，分别对应InjectString和InjectInt，我们遍历set集合，处理每个注解类型。通过调用roundEnvironment的getElementsAnnotatedWith(typeElement)来获取一个注解类型注解了哪些元素。

比如我们使用了InjectStirng注解了两个字符串成员变量：
@InjectString
public String hello;
@InjectString
public String world;

在InjectStirng的TypeElement会遍历hello和world这两个Element 。因为我们要将注解的元素转化成Java代码，所以需要处理每个Element对象，为生成Java文件做准备。我们定义类GenerateJavaFile来描述一个待生成的Java文件在InjectProcessor中：

   /**
     * 描述一个待生成的Java文件
     */
    private static class GenerateJavaFile {
        String packageName;//包名
        String className;//类名
        List<Element> elements;//注解元素集合
    }

通过调用addElementToGenerateJavaFile方法创建GenerateJavaFile对象，并将Element对象加入到GenerateJavaFile对象内部的elements集合中。addElementToGenerateJavaFile实现如下：

  /**
     * 添加一个注解元素到对应的GenerateJavaFile对象中
     * @param element 注解元素
     */
    private void addElementToGenerateJavaFile(Element element) {
        //获取element对应成员变量所在的类，即被注解的类
        TypeElement typeElement = (TypeElement) element.getEnclosingElement();
        String[] split = typeElement.getQualifiedName().toString().split("\\.");
        String className = split[split.length - 1];

        //通过父类的processingEnv获取报信者，用于在编译过程中打印log
        Messager messager = processingEnv.getMessager();
        messager.printMessage(Diagnostic.Kind.NOTE, "add element to generate file " + className);

        //获取被注解类对应的GenerateJavaFile对象，如果没有，则创建
        GenerateJavaFile generateJavaFile = mGenerateJavaFiles.get(className);
        if (generateJavaFile == null) {
            GenerateJavaFile file = new GenerateJavaFile();
            //设置待生成java文件的包名
            file.packageName = processingEnv.getElementUtils().getPackageOf(element).toString();
            //设置待生成java文件的类名
            file.className = className + "_Inject";
            //初始化元素集合
            file.elements = new ArrayList<Element>();
            file.elements.add(element);
            //保存被注解类所对应要生成java类的GenerateJavaFile对象
            mGenerateJavaFiles.put(className, file);
        } else {
            //将注解元素添加到有的generateJavaFile对象中
            generateJavaFile.elements.add(element);
        }
    }

（4）生成Java源文件
解析完所有的注解，创建GenerateJavaFile对象后，就可以根据GenerateJavaFile对象来生成对应的Java文件，这里可以使用第三方库javapoet来完成Java文件的生成，它的使用方式可以参考blog，这里不再赘述。

在compiler模块的build.gradle下添加javapoet的依赖同步：

compile 'com.squareup:javapoet:1.9.0'

接着实现createJavaFile文件方法，来完成Java文件的生成，遍历GenerateJavaFile集合，一个GenerateJavaFile对象对应一个要生成的Java文件，首先创建这个Java类的构造方法：

//createJavaFile()
//构建一个构造方法，该构造方法带有一个Context类型的参数
            MethodSpec.Builder builder = MethodSpec.constructorBuilder()
                    .addModifiers(Modifier.PUBLIC)
                    .addParameter(CONTEXT, "context");

参数类型CONTEXT定义为：

private static final ClassName CONTEXT = ClassName.get("android.content", "Context");

然后遍历注解元素，一个Element对象对应一条赋值代码：

 //遍历该类中需要处理的注解元素
            for (Element element: file.elements) {
                //如果注解的成员变量是一个int类型
                if (element.asType().toString().equals("int")) {
                    //在构造方法中添加一条语句
                    //例如：((MainActivity)context).one = context.getResources().getInteger(R.integer.one);
                    builder.addStatement("(($N)context).$N = context.getResources().getInteger(R.integer.$N)",
                            file.className.split("_")[0], element.getSimpleName(), element.getSimpleName());
                //如果注解的是一个String类型
                } else if (element.asType().toString().equals("java.lang.String")) {
                    //在构造方法中添加一条语句
                    //例如：((MainActivity)context).hello = context.getResources().getString(R.string.hello);
                    builder.addStatement("(($N)context).$N = context.getResources().getString(R.string.$N)",
                            file.className.split("_")[0], element.getSimpleName(), element.getSimpleName());
                }
            }

最后构建一个类，输出Java文件：

    //构建一个类，添加一个上述的构造方法
            TypeSpec typeSpec = TypeSpec.classBuilder(file.className)
                    .addModifiers(Modifier.PUBLIC)
                    .addMethod(builder.build())
                    .build();
            try {
                //输出java文件
                JavaFile javaFile = JavaFile.builder(file.packageName, typeSpec).build();
                javaFile.writeTo(processingEnv.getFiler());
            } catch (IOException e) {
                e.printStackTrace();
            }

（5）注解处理器，开始构建
注解处理器创建完后，还需要注册，这里最简单的方法是使用AutoService工具注册，在compiler的build.gradle添加依赖：

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

然后给InjectProcess添加AutoService注解：

@AutoService(Processor.class)
//定义注解处理器继承自AbstractProcessor
public class InjectProcessor extends AbstractProcessor{
         。。。。
}

AutoService的作用是生成一个配置文件来注册注解处理器。该配置文件的内容为com.example.InjectProcessor。
一切准备就绪，我们在app模块下添加依赖：

dependencies{
           annotationProcessor project(':compiler')
}

在项目目录terminal下输入：gradle clean和gradle build，来构建一遍项目，构建成功后会在app模块下的路径：build/generated/source/apt/debug/包名 下生成一个MainActivity_Inject.java文件。结果与期望的代码一致：

public class MainAcivity_Inject{
 public MainActivity_Inject(Context context){
   ((MainActivity)context).one=context.getResources().getInteger(R.integer.one);
   ((MainActivity)context).two=context.getResources().getInteger(R.integer.two);
   ((MainActivity)context).hello=context.getResources().getInteger(R.integer.hello);
   ((MainActivity)context).world=context.getResources().getInteger(R.integer.world);
   }
}

到这里就完成一个自定义的注解器啦，最后我们将one、two输出在屏幕上得出的就是1、2。
从结果来看注解器帮我们做的事情就是 另one=1、tow=2、hello=‘hello’，world=‘world’这样子。

我们再来对自定义注解器的过程做一个小结：

1. 定义注解
   创建一个Java Library，在这里通过@Interface来定义注解类，并声明它要修饰的变量类型(类、成员变量等等)。
2. 在Activity去使用注解
   在build.gradle中添加依赖的模块，并在Activity中使用注解绑定一个控件或者变量。
3. 解析注解（最关键的一步）
   创建一个Java Library作为注解器，表明支持的注解类型，并且注解类要继承AbstractProcessor， 实现其process方法，在process方法中会传入一个set和roundEnviroment回合环境，set里面是注解类型的集合，通过遍历set，我们所有被注解的对象加入到自己准备的文件中。这个文件存储所有被注解的Element。
4. 生成Java源文件
   在创建完文件后，我们需要在程序编译时让这个文件生成一个正式的文件类，就是类似于MainActivity_ViewBinding那样的文件类，我们通过第三方库javapoet来完成Java文件的生成。通过MethodSpec.Build为这个类设置构造方法，并格式化代码（如为每个Element使用FindViewById）。最后输出这个Java文件。
5. 注册注解处理器
   通过第三方库AutoService来为当前项目注册这个注解处理器。注册完后就可以使用编译时注解了。

---

ButterKnife源码分析

下面来分析ButterKnife的源码，ButterKnife的Java Library为butter-annotation模块，下面有其所有注解，包括常用的bindView和onClick。

1、注解定义：

@Retention(RUNTIME) @Target(FIELD)
public @interface BindView {
  /** View ID to which the field will be bound. */
  @IdRes int value();
}

可以看到BindeView注解保留到class文件中，并且是修饰成员变量的。另外内部有一个int类型的value方法，这是注解参数的定义，表示在使用BindView注解时可以接收一个int类型的参数，并且使用了注解@IdRes，表示参数必须是一个资源id。

这就体现出了我们使用BindView的格式：@BindeView(R.id.xxxx)

2、解析注解
在模块butterknife-compiler中，定义了注解处理器ButterKnifeProcessor类。

ButterKnifeProcessor同样使用process方法来完成注解的解析，里面的逻辑脉络十分清晰。
首先通过findAndParesTargets方法来获取所有注解来解析成一个Map集合，Map集合的key为一个TypeElement类型（比如我们在MainActivity中定义了注解，那么比会有一个TypeElement的对象对应MainActivity），表示被注解的类，value为一个BindingSet对象，里面有待生成的Java类所需的所有信息，包括类名包名、绑定的控件（比如我们生成MainActivity对应的绑定类MainActivity_ViewBinding所需要的所有信息）。
然后遍历Map集合中的所有元素，使用BindingSet对象创建一个JavaFile对象，进而生成一个Java文件。

我们这里主要分析 findAndParseTargets方法是如何解析注解的，该方法的目的是生成一个Map< TypeElement,BindingSet>集合，首先我们要先创建这个Map对象builderMap，解析所有注解来完成builderMap的初始化，最后使用builderMap对象来完成Map< TypeElement,BindingSet>集合bindingMap的创建并返回。

上半部分是解析被BindView注解的元素，下半部分是将整合好的信息传入到最后的bindMap并返回这个Map。

在findAndParseTargets 方法中会遍历所有被注解的元素，我们只看一下最常用的注解@BindView是如何被解析的，也就是parseBindView的实现。

在parseBindView中会对被注解的元素做可访问检查和包名检查，被绑定的元素必须继承View类或者一个接口，然后从builderMap集合中获取被注解的元素所在的类对应的BindingSet.Builder对象，如果没有，则调用getOrCreateBindingBuilder 方法创建一个BindingSet.Builder对象，再存入builderMap中，getOrCreateBindingBuilder代码如下：

我们可以在BindingSet的newBuilder方法中得到一些有用的信息，比如将要生成的Java文件的包名、类名等：

3、生成Java文件
BindingSet对象准备好之后，就可以使用BindingSet对象来生成一个对应的Java文件，process方法中调用BindingSet对象的brewJava 方法来“酿制”一个Java文件。brewJava就和我们自定义实现一个注解处理器中用到的Javapoet一样，调用createType方法来生成MainActiviy_ViewBinding类。
这个方法中首先调用addField方法给MainActiviy_ViewBinding类添加一个私有的成员变量target，然后由于要生成的MainActiviy_ViewBinding是对应MainActivity的，这就使得isActivity为true，所以会调用createBindingConstructorForActivity 方法来创建一个带参数的构造方法，接着调用createBindingConstructor方法来创建两个参数的构造方法，最后调用 createBindingUnbindMehtod方法创建解绑方法 unbind。

4、绑定bind
在ButterKnife中的ButterKnife类，里面提供了所有绑定方法，比如bind(Activity target），它的逻辑是根据传入的activity名字 找到对应的_ViewBinding 结尾的类，使用类加载器加载这个类，通过反射获取其构造方法，并将构造方法存入缓存后备用。最后调用获取到的构造方法完成Activity中注解的元素绑定。bind方法实现如下：
最后在try中调用构造方法。