前言
这个框架大家都是特别熟悉的了，JakeWharton大神的作品，项目地址，怎么用我就不多讲了，可以去参考官方文档，今天主要来扒一扒里面的源码
本文讲解项目地址 TestButterKnife 基于butterknife:8.8.1
一、ButterKnife能解决什么问题？
我个人认为主要是两个方面：
- 1.避免写烦琐的findviewbyid,以及一些资源的获取，比如getString
- 2.避免写一些交互事件，比如setOnclickListener
平常我们要绑定View到Activity上，都得一步步写findviewbyid，setOnclickListener,代码显得多余，而用了butterKnife就简洁了很多，而且配合一些插件比如Android ButterKnife Zelezny,一键生成所有需要的ButterKnife代码，写起来不要太爽！
二、编译器原理
首先我们要明白一点，ButterKnife是一个框架，不是什么高级API，虽然看似新奇的用法，背后也只是调用我们平常使用的那些findviewbyid等等，它之所以能如此简洁，是因为它用了Java Annotation Processing（Java注解解析器）。通俗讲，就是它在Java编译期间通过注解生成了一些实体类，这些类可以辅助我们绑定view到Activity上，也就省去了我们自己去写findviewbyid这些重复的代码。
有关Java Annotation Processing的使用本文不作深入讲解，有兴趣的可以去看下ButterKnifeProcessor这个类的process方法实现。总之在编译后，只要我们在类中使用了ButterKnife的注解，就会生成一个相应的辅助类，比如我们在MainActivity中使用注解，就会生成一个MainActivity_ViewBinding的辅助类。
三、神秘的_ViewBinding
我们以MainActivity为例，代码如下：
public class MainActivity extends AppCompatActivity {
@BindView(R.id.btn_jump)
Button btnJump;
@BindString(R.string.jump)
String stringJump;
private Unbinder unbinder;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
unbinder=ButterKnife.bind(this);
btnJump.setText(stringJump);
}
@OnClick(R.id.btn_jump)
public void onViewClicked() {
startActivity(new Intent(this,FragmentJumpActivity.class));
}
@Override
protected void onDestroy() {
super.onDestroy();
unbinder.unbind();
}
}
我们从注册方法开始讲起：
3.1 ButterKnife.bind
MainActivity中的onCreate方法调用了unbinder=ButterKnife.bind(this)这一句，该方法返回了一个Unbinder对象，这是一个接口，主要用来注销绑定的
public interface Unbinder {
@UiThread void unbind();
Unbinder EMPTY = new Unbinder() {
@Override public void unbind() { }
};
}
我们接着ButterKnife.bind方法读
@NonNull @UiThread
public static Unbinder bind(@NonNull Activity target) {
View sourceView = target.getWindow().getDecorView();
return createBinding(target, sourceView);
}
/**
* BindView annotated fields and methods in the specified {@link View}. The view and its children
* are used as the view root.
*
* @param target Target view for view binding.
*/
@NonNull @UiThread
public static Unbinder bind(@NonNull View target) {
return createBinding(target, target);
}
这里边有好几个重载的方法，其实的都是指向的createBinding方法，不同的只是将组件对应的View获取到，比如Activity是getWindow().getDecorView()，返回的是Activity的顶层View
，看过Activity源码的都知道，getDecorView返回的是一个FrameLayout。我们重点看createBinding方法：
private static Unbinder createBinding(@NonNull Object target, @NonNull View source) {
Class<?> targetClass = target.getClass();
if (debug) Log.d(TAG, "Looking up binding for " + targetClass.getName());
Constructor<? extends Unbinder> 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);
}
}
这个方法的逻辑也不多，主要是findBindingConstructorForClass方法得到了一个构造函数，然后通过constructor.newInstance构造一个对象返回，如果constructor为空，默认返回Unbinder.EMPTY，这个在之前Unbinder源码中可以看到，就是一个空实现。我们继续看findBindingConstructorForClass方法
@VisibleForTesting
static final Map<Class<?>, Constructor<? extends Unbinder>> BINDINGS = new LinkedHashMap<>();
@Nullable @CheckResult @UiThread
private static Constructor<? extends Unbinder> findBindingConstructorForClass(Class<?> cls) {
Constructor<? extends Unbinder> bindingCtor = BINDINGS.get(cls);
if (bindingCtor != null) {
if (debug) Log.d(TAG, "HIT: Cached in binding map.");
return bindingCtor;
}
String clsName = cls.getName();
if (clsName.startsWith("android.") || clsName.startsWith("java.")) {
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<? extends Unbinder>) 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;
}
这段代码也不复杂，我们一段段看：
Constructor<? extends Unbinder> bindingCtor = BINDINGS.get(cls);
if (bindingCtor != null) {
if (debug) Log.d(TAG, "HIT: Cached in binding map.");
return bindingCtor;
}
BINDINGS是一个LinkedHashMap，首先是从BINDINGS里读缓存，如果有对应的Unbinder且不为空，直接返回。
String clsName = cls.getName();
if (clsName.startsWith("android.") || clsName.startsWith("java.")) {
if (debug) Log.d(TAG, "MISS: Reached framework class. Abandoning search.");
return null;
}
跳过以android.和java.开头的Class，因为这些是framework层的类，直接返回null
try {
Class<?> bindingClass = cls.getClassLoader().loadClass(clsName + "_ViewBinding");
//noinspection unchecked
bindingCtor = (Constructor<? extends Unbinder>) 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;
将传进来的类名加上_ViewBinding，也就是我们之前讲的那个辅助类，获取它的构造方法，然后将这个构造方法缓存到BINDINGS中，最后返回该构造方法
这样的话，结合之前的逻辑ButterKnife.bind方法就返回了一个辅助类XXX_ViewBinding的实例，那我们那些view怎么绑定到Activity上的呢？其实是在XXX_ViewBinding里面做的
3.2 _ViewBinding
MainActivity对应生成的MainActivity_ViewBinding代码如下：
public class MainActivity_ViewBinding implements Unbinder {
private MainActivity target;
private View view2131427419;
@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.btn_jump, "field 'btnJump' and method 'onViewClicked'");
target.btnJump = Utils.castView(view, R.id.btn_jump, "field 'btnJump'", Button.class);
view2131427419 = view;
view.setOnClickListener(new DebouncingOnClickListener() {
@Override
public void doClick(View p0) {
target.onViewClicked();
}
});
Context context = source.getContext();
Resources res = context.getResources();
target.stringJump = res.getString(R.string.jump);
}
@Override
@CallSuper
public void unbind() {
MainActivity target = this.target;
if (target == null) throw new IllegalStateException("Bindings already cleared.");
this.target = null;
target.btnJump = null;
view2131427419.setOnClickListener(null);
view2131427419 = null;
}
}
这个类其实也很简单，主要分为两部分：
- 1.在构造方法中绑定view和事件
- 2.在unbind方法解除绑定
在之前ButterKnife.bind方法中，有这样一句代码
constructor.newInstance(target, source);
其中target为MainActivity对象，source为decorview,也就是说，会走第二个构造方法，我们一段段分析
======华丽分割线========================================
this.target = target;
View view;
view = Utils.findRequiredView(source, R.id.btn_jump, "field 'btnJump' and method 'onViewClicked'");
target.btnJump = Utils.castView(view, R.id.btn_jump, "field 'btnJump'", Button.class);
view2131427419 = view;
======华丽分割线========================================
public static View findRequiredView(View source, @IdRes int id, String who) {
View view = source.findViewById(id);
if (view != null) {
return view;
}
String name = getResourceEntryName(source, id);
throw new IllegalStateException("Required view '"
+ name
+ "' with ID "
+ id
+ " for "
+ who
+ " was not found. If this view is optional add '@Nullable' (fields) or '@Optional'"
+ " (methods) annotation.");
}
public static <T> T castView(View view, @IdRes int id, String who, Class<T> cls) {
try {
return cls.cast(view);
} catch (ClassCastException e) {
String name = getResourceEntryName(view, id);
throw new IllegalStateException("View '"
+ name
+ "' with ID "
+ id
+ " for "
+ who
+ " was of the wrong type. See cause for more info.", e);
}
}
这里其实对应是MainActivity中@BindView(R.id.btn_jump)这个注解，Utils.findRequiredView内部实现其实就是我们经常用的findviewbyid,而Utils.castView其实就是向下强转，所以这几句代码的功能就相当于
Button btnJump= (Button) source.findViewById(R.id.btn_jump);
那干嘛要写那么多代码呢？为啥不用这句直接代替，主要是为了找不到id的时候抛出对应的异常，便于开发者发现问题。
view.setOnClickListener(new DebouncingOnClickListener() {
@Override
public void doClick(View p0) {
target.onViewClicked();
}
});
这里对应的是MainActivity中@OnClick(R.id.btn_jump)的注解，就是普通的setOnClickListener，然后回调MainActivity中的onViewClicked方法
Context context = source.getContext();
Resources res = context.getResources();
target.stringJump = res.getString(R.string.jump);
这里对应的是MainActivity中@BindString(R.string.jump)的注解，也是普通的res.getString方法
所以综上可以看出，ButterKnife就是用了我们平时那些findViewById,setOnClickListener实现view的绑定。
3.3 unbinder.unbind();
我们一般会在onDestroy方法中调用unbinder.unbind
public void unbind() {
MainActivity target = this.target;
if (target == null) throw new IllegalStateException("Bindings already cleared.");
this.target = null;
target.btnJump = null;
view2131427419.setOnClickListener(null);
view2131427419 = null;
}
这里边就是一些置空的操作，便于垃圾回收器回收对应的内存
