ButterKnife源码梳理

写代码的时候，总会要不厌其烦的写findViewById，butterknife这个框架的作用就是利用注解来简化view查找过程。
先了解下注解的几个关键词：
Target:限定使用范围
1.CONSTRUCTOR:用于描述构造器
2.FIELD:用于描述域
　　3.LOCAL_VARIABLE:用于描述局部变量
　　4.METHOD:用于描述方法
　　5.PACKAGE:用于描述包
　　6.PARAMETER:用于描述参数
　　7.TYPE:用于描述类、接口(包括注解类型) 或enum声明
Retention：被保留的时间长短
1.SOURCE:在源文件中有效（即源文件保留）
　　2.CLASS:在class文件中有效（即class保留）
　　3.RUNTIME:在运行时有效（即运行时保留）
JDK 5中引入了源代码中的注解（annotation）这一机制。注解使得Java源代码中不但可以包含功能性的实现代码，还可以添加元数据。注解的功能类似于代码中的注释，所不同的是注解不是提供代码功能的说明，而是实现程序功能的重要组成部分。
只要知道注解大概就是可以方便的进行程序配置。
具体参考：
https://docs.oracle.com/javase/tutorial/java/annotations/index.html
http://computerdragon.blog.51cto.com/6235984/1210969
http://www.infoq.com/cn/articles/cf-java-annotation

最开始版本的butterknife使用反射来实现

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {
    int value();
}

像这样定义一个注解，然后通过遍历Activity或者Fragment中的成员变量来实现findViewById的过程

private static void injectView(Activity activity) {
        Class clazz = activity.getClass();
        //获得activity的所有成员变量
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            //获得每个成员变量上面的ViewInject注解，没有的话，就会返回null
            ViewInject viewInject = field.getAnnotation(ViewInject.class);
            if (viewInject != null) {
                int viewId = viewInject.value();
                View view = activity.findViewById(viewId);
                try {
                    field.setAccessible(true);
                    field.set(activity, view);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

但是这种方式的性能很低，特别是对类似Android这样的系统，对性能要求很苛刻的情况，最好不要用反射。所以Jake大神进行了修改。
新版本的Butterknife用的APT(Annotation Processing Tool)编译时解析技术。
APT大概就是你声明的注解的生命周期为CLASS,然后继承AbstractProcessor类。继承这个类后，在编译的时候，编译器会扫描所有带有你要处理的注解的类，然后再调用AbstractProcessor的process方法，对注解进行处理，那么我们就可以在处理的时候，动态生成绑定事件或者控件的java代码，然后在运行的时候，直接调用bind方法完成绑定。
先说下butterknife的几个模块：
‘:butterknife’ 静态绑定方法入口，查找生成类并存入缓存
‘:butterknife-annotations’ 定义所有的注解类
‘:butterknife-compiler’ 注解解析
‘:butterknife-gradle-plugin’ 插件
‘:butterknife-lint’
‘:butterknife-integration-test’ 测试模块

定义注解，注意，这儿Retention是CLASS

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

这个注解表明@BindView 是用来修饰 field 的，并且保留至编译时刻。内部有一个默认int类型的属性 value ，用来表示 View 的 id ，即平时程序中的 R.id.xxx

定义了注解之后，butterknife-compiler模块负责进行解析
核心类是ButterKnifeProcessor，它继承自AbstractProcessor，是专门处理annotation的类。
重写process方法后，在方法中butterknife进行的具体处理是

1.扫描所有具有注解的类，然后根据这些类的信息生成BindingClass，最后生成以TypeElement为键,BindingClass为值的键值对。

2.循环遍历这个键值对，根据TypeElement和BindingClass里面的信息生成对应的java类。例如AnnotationActivity生成的类即为Cliass$$ViewBinder类。

跟着代码具体看一下处理过程：

1.ButterKnifeProcessor类的init方法中主要根据 env 得到一些工具类。其中的 filter 主要是用来生成 Java 代码，而 elementUtils 和 typeUtils 会在下面源码中用到

2.process方法中首先调用了findAndParseTargets方法，在findAndParseTargets方法中调用scanForRClasses扫描所有的带有注解的类，然后遍历所有被 @BindView 注解的属性，最后调用 parseBindView 方法

private void parseBindView(Element element, Map builderMap,
      Set erasedTargetNames) {
    // 得到注解 @BindView 元素所在的类元素
    TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();
    // Start by verifying common generated code restrictions.
    // ---------- 类型校验逻辑 start ---------------
    // 判断是否被注解在属性上，如果该属性是被 private 或者 static 修饰的，则出错
    // 判断是否被注解在错误的包中，若包名以“android”或者“java”开头，则出错
    boolean hasError = isInaccessibleViaGeneratedCode(BindView.class, "fields", element)
        || isBindingInWrongPackage(BindView.class, element);
    // Verify that the target type extends from View.
    TypeMirror elementType = element.asType();
    if (elementType.getKind() == TypeKind.TYPEVAR) {
      TypeVariable typeVariable = (TypeVariable) elementType;
      elementType = typeVariable.getUpperBound();
    }
    // 判断元素是不是View及其子类或者Interface
    if (!isSubtypeOfType(elementType, VIEW_TYPE) && !isInterface(elementType)) {
      if (elementType.getKind() == TypeKind.ERROR) {
        note(element, "@%s field with unresolved type (%s) "+ "must elsewhere be generated as a View or interface. (%s.%s)",
            BindView.class.getSimpleName(), elementType, enclosingElement.getQualifiedName(),
            element.getSimpleName());
      } else {
        error(element, "@%s fields must extend from View or be an interface. (%s.%s)",
            BindView.class.getSimpleName(), enclosingElement.getQualifiedName(),
            element.getSimpleName());
        hasError = true;
      }
    }
    // 如果有错误 不执行下面代码
    if (hasError) {
      return;
    }
    //---------------- 类型校验逻辑 end -----------------
    // Assemble information on the field.  //得到被注解的注解值，即 R.id.xxx
    int id = element.getAnnotation(BindView.class).value();
    // 根据所在的类元素去查找 builder
    BindingSet.Builder builder = builderMap.get(enclosingElement);
    // 如果相应的 builder 已经存在
    if (builder != null) {
      // 得到相对应的 View 绑定的属性名
      String existingBindingName = builder.findExistingBindingName(getId(id));
      // 若该属性名已经存在，则说明之前已经绑定过，会报错
      if (existingBindingName != null) {
        error(element, "Attempt to use @%s for an already bound ID %d on '%s'. (%s.%s)",
            BindView.class.getSimpleName(), id, existingBindingName,
            enclosingElement.getQualifiedName(), element.getSimpleName());
        return;
      }
    } else {
      // 如果没有对应的 builder ，就通过 getOrCreateBindingBuilder 方法生成，并且放入 builderMap 中
      builder = getOrCreateBindingBuilder(builderMap, enclosingElement);
    }
    // 得到注解名
    String name = element.getSimpleName().toString();
    // 得到注解元素的类型
    TypeName type = TypeName.get(elementType);
    boolean required = isFieldRequired(element);
    // 根据 id ，添加相对应的 Field 的绑定信息
    builder.addField(getId(id), new FieldViewBinding(name, type, required));
    // Add the type-erased version to the valid binding targets set.
    // 添加到待 unbind 的序列中
    erasedTargetNames.add(enclosingElement);
}

最后将 builderMap 转换为了 bindingMap 并返回。
到这儿准备工作已经完成，接下来就是根据准备好的bindingMap 生成辅助类，比如说
MainActivity_ViewBinding

public class MainActivity_ViewBinding implements Unbinder {
  private MainActivity target;
  @UiThread
  public MainActivity_ViewBinding(MainActivity target) {
    this(target, target.getWindow().getDecorView());
  }
  @UiThread
  public MainActivity_ViewBinding(MainActivity target, View source) {
    this.target = target;
    View view;
    target.textView = Utils.findRequiredViewAsType(source, R.id.text_view, "field 'textView'", TextView.class);
    target.toolbar = Utils.findRequiredViewAsType(source, R.id.toolbar, "field 'toolbar'", Toolbar.class);
  }
  @Override
  @CallSuper
  public void unbind() {
    MainActivity target = this.target;
    if (target == null) throw new IllegalStateException("Bindings already cleared.");
    this.target = null;
    target.textView = null;
    target.toolbar = null;
  }
}

那这个是如何生成的呢，看process中的代码

 JavaFile javaFile = binding.brewJava(sdk);

是通过https://github.com/square/javapoet 来生成代码的
核心方法在brewJava中调用了 createType(sdk)，具体使用方法参考javapoet官网

生成类之后如何使用呢，butterknife调用了静态方法bind,在bind方法中调用了createBinding，这个方法是根据 target 创建对应的 targetClassName_ViewBinding对象 。在 targetClassName_ViewBinding 的构造器中会把对应的 View 进行绑定（具体可以查看上面的 MainActivity_ViewBinding ）。而在 findBindingConstructorForClass(Class cls) 方法中也使用了 Class.forName() 反射来查找 Class ，这也是无法避免的。但是仅限于一个类的第一次查找，之后都会从 BINDINGS 缓存中获取。

Demo地址：https://github.com/fanturbo/ButterKnifeStudy