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