ButterKnife源码地址：https://github.com/JakeWharton/butterknife
1.所用主要技术
APT,反射,javaPoet(生成.java文件)
2.原理
在编译前，生成相应的辅助类，xx_ViewBinding.java,运行时，利用该辅助类对Activity中的view进行findViewById等操作
3.代码实现(以下以@BindView->findViewById为例)
在早期的时候，实现@BindView的功能，是在代码运行时通过反射+注解的方法来实现的。反射拿到当前activity中所有的变量->遍历所有变量->拿到变量上的注解信息(R.id.xxx)->调用findViewById->利用反射将activity中该变量初始化
以上方案可以实现@BindView的功能，但在运行时，大量运用反射，会影响app的性能。因此，ButterKnife在实现上，将这些功能移到了编译前。
1>生成辅助类
在编译前对代码进行处理，就要用到APT(Annotation Processor Tool),这个我在java注解的使用已经有大致的使用方法，简言之，就是当你需要动态生成.java文件时，就需要用到APT。通过ButterKnife的使用方法
implementation 'com.jakewharton:butterknife:10.2.3'
annotationProcessor 'com.jakewharton:butterknife-compiler:10.2.3'
可能看出，ButterKnife中，必然会有AbstractProcessor的子类来对处解进行处理，并生成相应的辅助类。
在ButterKnife工程中，butterknife-compiler工程，便是注解处理器相关的代码。在此工程下，可以发现一个类 ButterKnifeProcessor.java
public final class ButterKnifeProcessor extends AbstractProcessor {
@Override
public boolean process(Set elements, RoundEnvironment env) {
Map bindingMap = findAndParseTargets(env);
for (Map.Entry entry : bindingMap.entrySet()) {
TypeElement typeElement = entry.getKey();
BindingSet binding = entry.getValue();
JavaFile javaFile = binding.brewJava(sdk, debuggable);
try {
javaFile.writeTo(filer);
} catch (IOException e) {
error(typeElement, "Unable to write binding for type %s: %s", typeElement, e.getMessage());
}
}
return false;
}
}
以上只贴出了process方法，这是apt的关键，具体此方法是如何运行的，我就暂不分析了，里面东西太多，我们只需要知道，这个注解处理器会根据注解所在的类，生成一个相应的.java文件的辅助类，在代码运行时，通过辅助类来完成对view的findViewById.
2>辅助类的内容
下面以我的测试工程为例
public class MainActivity extends AppCompatActivity {
@BindView(R.id.event_reflect)
public Button reflectBt;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);
}
@OnClick(R.id.event_reflect)
public void reflectClick() {
startActivity(new Intent(MainActivity.this, Reflect2Activity.class));
}
}
MainActivity中，用到了@BindView以及@OnClick两个注解，在
apt生成的java代码会生成在此处，相应的java文件名称为MainActivity_ViewBinding.java，通过名称我们可以发现，apt生成的辅助类的名称即为注解所在类的名称加_ViewBinding，这样便于后续各Activity能找到其相应的辅助类。
public class MainActivity_ViewBinding implements Unbinder {
private MainActivity target;
private View view7f08007e;
@UiThread
public MainActivity_ViewBinding(MainActivity target) {
this(target, target.getWindow().getDecorView());
}
@UiThread
public MainActivity_ViewBinding(final MainActivity target, View source) {
this.target = target;
View view;
view = Utils.findRequiredView(source, R.id.event_reflect, "field 'reflectBt' and method 'reflectClick'");
target.reflectBt = Utils.castView(view, R.id.event_reflect, "field 'reflectBt'", Button.class);
view7f08007e = view;
view.setOnClickListener(new DebouncingOnClickListener() {
@Override
public void doClick(View p0) {
target.reflectClick();
}
});
}
@Override
@CallSuper
public void unbind() {
MainActivity target = this.target;
if (target == null) throw new IllegalStateException("Bindings already cleared.");
this.target = null;
target.reflectBt = null;
view7f08007e.setOnClickListener(null);
view7f08007e = null;
}
}
打开此文件，我们可能看到setOnClickListener，以及 Utils.findRequiredView方法，顺着代码，我们在Utils中就可以找到相应的findViewById的方法。
关于辅助类的生成，大致内容就是这些.
3>辅助类如何起作用
下面来看我们在用ButterKnife时，用到的ButterKnife.bind(this)，其代码出下：
public final class ButterKnife {
public static Unbinder bind(@NonNull Activity target) {
View sourceView = target.getWindow().getDecorView();
return bind(target, sourceView);
}
public static Unbinder bind(@NonNull Object target, @NonNull View source) {
Class targetClass = target.getClass();
if (debug) Log.d(TAG, "Looking up binding for " + targetClass.getName());
Constructor constructor = findBindingConstructorForClass(targetClass);
if (constructor == null) {
return Unbinder.EMPTY;
}
//noinspection TryWithIdenticalCatches Resolves to API 19+ only type.
try {
return constructor.newInstance(target, source);
} catch (IllegalAccessException e) {
throw new RuntimeException("Unable to invoke " + constructor, e);
} catch (InstantiationException e) {
throw new RuntimeException("Unable to invoke " + constructor, e);
} catch (InvocationTargetException e) {
Throwable cause = e.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException) cause;
}
if (cause instanceof Error) {
throw (Error) cause;
}
throw new RuntimeException("Unable to create binding instance.", cause);
}
}
private static Constructor findBindingConstructorForClass(Class cls) {
Constructor bindingCtor = BINDINGS.get(cls);
if (bindingCtor != null || BINDINGS.containsKey(cls)) {
if (debug) Log.d(TAG, "HIT: Cached in binding map.");
return bindingCtor;
}
String clsName = cls.getName();
if (clsName.startsWith("android.") || clsName.startsWith("java.")
|| clsName.startsWith("androidx.")) {
if (debug) Log.d(TAG, "MISS: Reached framework class. Abandoning search.");
return null;
}
try {
Class bindingClass = cls.getClassLoader().loadClass(clsName + "_ViewBinding");
//noinspection unchecked
bindingCtor = (Constructor) bindingClass.getConstructor(cls, View.class);
if (debug) Log.d(TAG, "HIT: Loaded binding class and constructor.");
} catch (ClassNotFoundException e) {
if (debug) Log.d(TAG, "Not found. Trying superclass " + cls.getSuperclass().getName());
bindingCtor = findBindingConstructorForClass(cls.getSuperclass());
} catch (NoSuchMethodException e) {
throw new RuntimeException("Unable to find binding constructor for " + clsName, e);
}
BINDINGS.put(cls, bindingCtor);
return bindingCtor;
}
}
从findBindingConstructorForClass(targetClass)及cls.getClassLoader().loadClass(clsName + "_ViewBinding");可以看出，在ButterKnife.bind(this)中，最主要的就是通过当前activity的名称以固定的"_ViewBinding"后缀，找到了当前Activity的辅助类，并通过反射，生成了该辅助类的对象。而该辅助类持有当前的activity对象，从辅助类的代码可以看出，在辅助类里对当前Activity中的各变量进行了相应的findViewById及setOnClickListener等操作
4>为什么要求public
在使用BindView时，我们发现，要求变量不能为private,从辅助类的代码
target.reflectBt = Utils.castView(view, R.id.event_reflect, "field 'reflectBt'", Button.class);
可以看出，在初始化view时，是直接使用的该view,如果设置成private,这里就会出问题
4.总结
以上对ButterKnife的原理做了一些简单的介绍，当然，ButterKnife中还有很多内容和功能，以及其中关于javaPoet使用，我们就不一一介绍了，了解了其实现原理后，其他相应的注解相信你会很快掌握。