用過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類是怎么生成的，為什么不同注解會有不一樣的內容，下一篇中我們繼續分析。
