用过ButterKnife的同学都知道，它可以方便我们用注解的方式来省去每次用findViewById去获取View对象等。而其实它的原理也是很简单的，就是在调用ButterKnife.bind(Object obj, View view)方法时，创建一个对象，这个对象构造方法里面会调用参数view的findViewById来赋值给obj中你注解过的字段（通常是各种View），也就是说ButterKnife把本来我们在自己要显式实现的findViewById等方法，放到了它自己的一个对象里去实现了。现在我们一步步来实现它的设计思路。
未优化的获取View实现方式
首先是我们原始的获取View的方式。
public class TestActivity extends Activity{
TextView text1;
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
//获取text1对象
text1 = (TextView)findViewById(R.id.text1);
text1.setText("我是测试Text 1");
//设置btn_1的点击和长按事件
Button btn_1 = (Button) findViewById(R.id.btn_1);
btn_1.setOnClickListener(new View.OnClickListener() {
@Override public void onClick(View v) {
Toast.makeText(getApplicationContext(), "点击btn_1", Toast.LENGTH_SHORT).show();
}
});
btn_1.setOnLongClickListener(new View.OnLongClickListener() {
@Override public boolean onLongClick(View v) {
Toast.makeText(getApplicationContext(), "长按btn_1", Toast.LENGTH_SHORT).show();
return false;
}
});
//设置btn_2的点击和长按事件
Button btn_2 = (Button) findViewById(R.id.btn_2);
btn_2.setOnClickListener(new View.OnClickListener() {
@Override public void onClick(View v) {
Toast.makeText(getApplicationContext(), "点击btn_2", Toast.LENGTH_SHORT).show();
}
});
btn_2.setOnLongClickListener(new View.OnLongClickListener() {
@Override public boolean onLongClick(View v) {
Toast.makeText(getApplicationContext(), "长按btn_2", Toast.LENGTH_SHORT).show();
return false;
}
});
}
}
这是我们最初的编写方式，简单直接，我们会想是否能稍微优化一下，是它变得更整洁，于是有了下面的改动。
简单优化的获取View实现方式
public class TestActivity extends Activity{
TextView text1;
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
new TestActivity_ViewBind(this, getWindow().getDecorView());
}
public void onClick(View view) {
switch (view.getId()) {
case R.id.btn_1:
Toast.makeText(this, "点击btn_1", Toast.LENGTH_SHORT).show();
break;
case R.id.btn_2:
Toast.makeText(this, "点击btn_2", Toast.LENGTH_SHORT).show();
break;
default:
break;
}
}
public boolean onLongClick(View view) {
switch (view.getId()) {
case R.id.btn_1:
Toast.makeText(this, "长按btn_1", Toast.LENGTH_SHORT).show();
return true;
case R.id.btn_2:
Toast.makeText(this, "长按btn_2", Toast.LENGTH_SHORT).show();
return true;
default:
break;
}
return false;
}
}
public class TestActivity_ViewBind{
public TestActivity_ViewBind(final TestActivity activity, final View view){
//获取text1对象
activity.text1 = (TextView) view.findViewById(R.id.text1);
//设置btn_1的点击和长按事件
Button btn_1 = (Button) view.findViewById(R.id.btn_1);
btn_1.setOnClickListener(new View.OnClickListener() {
@Override public void onClick(View v) {
activity.onClick(v);
}
});
btn_1.setOnLongClickListener(new View.OnLongClickListener() {
@Override public boolean onLongClick(View v) {
activity.onLongClick(v);
return false;
}
});
//设置btn_2的点击和长按事件
Button btn_2 = (Button) view.findViewById(R.id.btn_2);
btn_2.setOnClickListener(new View.OnClickListener() {
@Override public void onClick(View v) {
activity.onClick(v);
}
});
btn_2.setOnLongClickListener(new View.OnLongClickListener() {
@Override public boolean onLongClick(View v) {
activity.onLongClick(v);
return false;
}
});
}
}
看上面，我们把获取text1和给btn_1，btn_2设置点击长按事件等操作独立出来，引出一个TestActivity_ViewBind类负责帮TestActivity做初始化。通过findViewById获取到text1后赋值给TestActivity对象的text1，同时btn_1，btn_2也是通过findViewById获取到，然后给它们设置点击和长按事件，在onClick或onLongClick回调时再去调用TestActivity的onClick或onLongClick方法。这样TestActivity看起来是不是精简了不少？但是这样我们发现还有个问题，就是TestActivity_ViewBind还是得我们自己写，写TestActivity_ViewBind这个类比之前正常写法的工作量反而更大了，除了把部分任务独立出来之外，好像并没有什么用处。因此ButterKnife就想到了TestActivity_ViewBind这个类不用我们自己编写，我给你在编译时动态创建，而你所要做的就是在之前的TestActivity中加点注解，告诉ButterKnife要给你做什么初始化。
ButterKnife优化的获取View实现方式
下面就是使用ButterKnife之后的代码
public class TestActivity extends Activity{
//加上@BindView注解，内容为text1对应的id（R.id.text1）
@BindView(R.id.text1) TextView text1;
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
ButterKnife.bind(this);
text1.setText("我是测试Text 1");
}
//加上@OnClick注解，作为点击事件的回调标记，内容为btn_1和btn_2的id（R.id.btn_1和R.id.btn_2）
@OnClick({ R.id.btn_1, R.id.btn_2 }) public void onClick(View view) {
switch (view.getId()) {
case R.id.btn_1:
Toast.makeText(this, "点击btn_1", Toast.LENGTH_SHORT).show();
break;
case R.id.btn_2:
Toast.makeText(this, "点击btn_2", Toast.LENGTH_SHORT).show();
break;
default:
break;
}
}
//加上OnLongClick注解，作为长按事件的回调标记，内容为btn_1和btn_2的id（R.id.btn_1和R.id.btn_2）
@OnLongClick({ R.id.btn_1, R.id.btn_2 }) public boolean onLongClick(View view) {
switch (view.getId()) {
case R.id.btn_1:
Toast.makeText(this, "长按btn_1", Toast.LENGTH_SHORT).show();
return true;
case R.id.btn_2:
Toast.makeText(this, "长按btn_2", Toast.LENGTH_SHORT).show();
return true;
default:
break;
}
return false;
}
}
可以看到@BindView(R.id.text1)这个注解，可以标记要findViewById的是R.id.text1这个id，创建之后的对象是赋给text1。@OnClick({ R.id.btn_1, R.id.btn_2 })这个注解，标记的是当发生R.id.btn_1或者R.id.btn_2的点击事件时回调我标记的这个方法，因此方法名可以是任意的，并不一定是onClick，重要的是看加了什么注解。你可能会想知道帮我生成的这个TestActivity_ViewBind是在哪里了。它的实现是在当前项目模块（如app）的build目录下的，具体是
app\build\generated\source\apt\debug\（包名）\TestActivity_ViewBinding.java
我们进去看看它的实现
public class TestActivity_ViewBinding<T extends TestActivity> implements Unbinder {
protected T target;
private View view2131558538;
private View view2131558539;
@UiThread
public TestActivity_ViewBinding(final T target, View source) {
this.target = target;
View view;
target.text1 = Utils.findRequiredViewAsType(source, R.id.text1, "field 'text1'", TextView.class);
view = Utils.findRequiredView(source, R.id.btn_1, "method 'onClick' and method 'onLongClick'");
view2131558538 = view;
view.setOnClickListener(new DebouncingOnClickListener() {
@Override
public void doClick(View p0) {
target.onClick(p0);
}
});
view.setOnLongClickListener(new View.OnLongClickListener() {
@Override
public boolean onLongClick(View p0) {
return target.onLongClick(p0);
}
});
view = Utils.findRequiredView(source, R.id.btn_2, "method 'onClick' and method 'onLongClick'");
view2131558539 = view;
view.setOnClickListener(new DebouncingOnClickListener() {
@Override
public void doClick(View p0) {
target.onClick(p0);
}
});
view.setOnLongClickListener(new View.OnLongClickListener() {
@Override
public boolean onLongClick(View p0) {
return target.onLongClick(p0);
}
});
}
@Override
@CallSuper
public void unbind() {
T target = this.target;
if (target == null) throw new IllegalStateException("Bindings already cleared.");
target.text1 = null;
view2131558538.setOnClickListener(null);
view2131558538.setOnLongClickListener(null);
view2131558538 = null;
view2131558539.setOnClickListener(null);
view2131558539.setOnLongClickListener(null);
view2131558539 = null;
this.target = null;
}
}
看了之后有没有觉得和我上面写的TestActivity_ViewBind好像，实现方式是差不多的，当然这些都是动态生成的，不需要我们编写，感觉解放了双手啊，而且ButterKnife还更贴心的做了unbind这个释放引用的实现，防止可能TestActivity_ViewBinding对象没有被销毁时，一直持有引用，导致TestActivity内存泄漏的问题。接下来我们分析ButterKnife.bind(this);是怎么实现绑定的
ButterKnife绑定流程
ButterKnife有几个bind方法，分别对应的是Activity，View，Dialog，Object，也就是说，它能够给Activity，View，Dialog，Object这些对象中的属性进行赋值，初始化等操作。
public final class ButterKnife {
@NonNull @UiThread
public static Unbinder bind(@NonNull Activity target) {
View sourceView = target.getWindow().getDecorView();
return createBinding(target, sourceView);
}
@NonNull @UiThread
public static Unbinder bind(@NonNull View target) {
return createBinding(target, target);
}
@NonNull @UiThread
public static Unbinder bind(@NonNull Dialog target) {
View sourceView = target.getWindow().getDecorView();
return createBinding(target, sourceView);
}
@NonNull @UiThread
public static Unbinder bind(@NonNull Object target, @NonNull Activity source) {
View sourceView = source.getWindow().getDecorView();
return createBinding(target, sourceView);
}
@NonNull @UiThread
public static Unbinder bind(@NonNull Object target, @NonNull View source) {
return createBinding(target, source);
}
@NonNull @UiThread
public static Unbinder bind(@NonNull Object target, @NonNull Dialog source) {
View sourceView = source.getWindow().getDecorView();
return createBinding(target, sourceView);
}
}
可以它们最终都是调用到createBinding(target, sourceView); 也就是说，必须要找到一个View对象，才能在后续的处理中对target的内容进行操作。
public final class ButterKnife {
private static Unbinder createBinding(@NonNull Object target, @NonNull View source) {
//找到target所属的类Class对象，例如TestActivity.class
Class<?> targetClass = target.getClass();
if (debug) Log.d(TAG, "Looking up binding for " + targetClass.getName());
//找到target对应的bind的Class对象的构造器，例如TestActivity_ViewBinding这个类的构造器
Constructor<? extends Unbinder> constructor = findBindingConstructorForClass(targetClass);
if (constructor == null) {
return Unbinder.EMPTY;
}
//noinspection TryWithIdenticalCatches Resolves to API 19+ only type.
try {
//创建ViewBinding的对象了，例如创建TestActivity_ViewBinding这个对象，调用构造方法
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);
}
}
@Nullable @CheckResult @UiThread
private static Constructor<? extends Unbinder> findBindingConstructorForClass(Class<?> cls) {
//从map中获取ViewBinding的构造器，避免每次通过反射获取，算是优化
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();
//忽略android.和java.包名开头的类
if (clsName.startsWith("android.") || clsName.startsWith("java.")) {
if (debug) Log.d(TAG, "MISS: Reached framework class. Abandoning search.");
return null;
}
try {
//看这里，查找target类对应的ViewBinding类型
Class<?> bindingClass = Class.forName(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);
}
//把构造器缓存到map
BINDINGS.put(cls, bindingCtor);
return bindingCtor;
}
@VisibleForTesting
static final Map<Class<?>, Constructor<? extends Unbinder>> BINDINGS = new LinkedHashMap<>();
}
可以发现，其实原理也很简单，就是获取target所属的类，比如说是一个HomeFragment对象的话，就是获取HomeFragment这个类对象，然后去查找HomeFragment_ViewBinding这个类，如果找到了就反射创建它的构造器，并缓存起来，避免每次去查找了，如果没找到，找它的父类看有没有对应的ViewBinding类。有了构造器，就可以反射创建HomeFragment_ViewBinding这个对象了，也就会调用它的构造方法，而构造方法里就是做了哪些初始化设置操作，这样整个流程就走通了。
ButterKnife功能
- 除了@BindView和@OnClick，@OnLongClick注解之外，ButterKnife还提供了@OnItemClick，@OnItemLongClick，@OnTouch等注解。
- ButterKnife提供了findById方法，让我们不用强制类型转换，它的实现方式是通过泛型实现的。
//不用类型转换
TextView text2 = ButterKnife.findById(this, R.id.text2);
public final class ButterKnife {
//泛型实现
public static <T extends View> T findById(@NonNull Activity activity, @IdRes int id) {
return (T) activity.findViewById(id);
}
}
- ButterKnife提供了apply方法，来做一些通用化的设置。例如
List<TextView> viewList = new ArrayList<>();
viewList.add(text1);
viewList.add(text2);
ButterKnife.apply(viewList, new ButterKnife.Action<TextView>() {
@Override public void apply(@NonNull TextView view, int index) {
view.setBackgroundDrawable(new ColorDrawable(ContextCompat.getColor(getBaseContext(), android.R.color.darker_gray)));
}
});
可以对viewList中的TextView进行统一的操作，这里是给它们统一设置背景等。而原理也很简单，就是简单的回调而已，所以并没什么稀奇的。
public final class ButterKnife {
@UiThread
public static <T extends View> void apply(@NonNull List<T> list,
@NonNull Action<? super T> action) {
//遍历list，调用action.apply
for (int i = 0, count = list.size(); i < count; i++) {
action.apply(list.get(i), i);
}
}
}
ButterKnife总结
ButterKnife最大的作用就是方便我们用注解的方式，省去了findViewById操作，还有各种setOnXXXListener操作，是代码看起来更简洁，而它的设计思想就是独立出来一个类负责这些初始化操作，然后又通过注解及注解生成的方式实现它们之间的解耦，只需要调用 ButterKnife.bind(this);，本类压根不知道谁帮它做了初始化操作的。实现原理其实也很简单，也不简单。简单的是，它给你编译生成了Bind类，然后查找创建对象，就完成了初始化操作。不简单的是这个Bind类是怎么生成的，为什么不同注解会有不一样的内容，下一篇中我们继续分析。
网友评论