写代码的时候，总会要不厌其烦的写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使用反射来实现
<pre>
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {
int value();
}
</pre>
像这样定义一个注解，然后通过遍历Activity或者Fragment中的成员变量来实现findViewById的过程
<pre>
private static void injectView(Activity activity) {
Class<? extends Activity> 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();
}
}
}
}
</pre>
但是这种方式的性能很低，特别是对类似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
<pre>
@Retention(CLASS) @Target(FIELD)
public @interface BindView {
/** View ID to which the field will be bound. */
@IdRes int value();
}
</pre>
这个注解表明@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 方法
<pre>
private void parseBindView(Element element, Map<TypeElement, BindingSet.Builder> builderMap,
Set<TypeElement> 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);
}
</pre>
最后将 builderMap 转换为了 bindingMap 并返回。
到这儿准备工作已经完成，接下来就是根据准备好的bindingMap 生成辅助类，比如说
MainActivity_ViewBinding
<pre>
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;
}
}
</pre>
那这个是如何生成的呢，看process中的代码
<pre> JavaFile javaFile = binding.brewJava(sdk);</pre>
是通过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 缓存中获取。
