俗話說的好“不想偷懶的程序員，不是好程序員”，我們在日常開發android的過程中，在前端activity或者fragment時，無法避免的會用到
findViewById這類的代碼，然后強制類型轉換出我們所需要的控件類型，說實話，對于追求代碼簡潔，高可讀，并且想偷懶的程序員來說，寫這樣的重復代碼，簡直就是災難。當然，我們可以通過一些技術手段來規避這些重復勞動并且“難看”的代碼出現
反射方式
我們先介紹一下傳統的使用反射方式進行優化findViewById類型的代碼，下面我們來看下是怎么實現的：
注解類FindView
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface FindView {
public int value();
/* parent view id */
public int parent() default 0;
}
在看下我們的使用方式
在activity或者fragment中，使用以下方式注入ID并且初始化對象
@SetOnClickListener({R.id.ll_community_switch,R.id.panel_abot,R.id.ll_me_info})
public class MeFragment implements OnClickListener{
@FindView(R.id.panel_shell)
private FrameLayout mShellPanel;
@FindView(R.id.panel_coverture)
private LinearLayout mPanelCoverture;
public void onClick(View v) {
switch (v.getId()) {
case R.id.ll_community_switch: {
// TODO
break;
}
case R.id.ll_panel_abot: {
// TODO
break;
}
......
}
我們都知道，注解使用的其中一種方式是給類/方法/成員變量設置注解，然后在某個地方，對設置的注解進行解析，以期獲取到注解對應的類/方法/成員變量的一些屬性或者能力，我們這里正是利用的這個特性，在activity(onCreate)或者fragment(onActivityCreated)的生命周期中，加入我們解析注解的代碼，對注解屬性進行初始化操作
// 查找注解到視圖
InjectFinder.injectView(this); // this代表Fragment或者Activity對象
在injectView方法中，我們通過反射方式獲取到activity或者fragment的FindView注解，然后根據注解中的ID，最終還是通過findViewById的方法獲取到對應的控件(注:SetOnClickListener注解原理類似)
public static <O> void injectView(Class<?> clazz, O o) {
Class<?> tempClazz = clazz != null ? clazz : (o != null ? o.getClass() : null);
if (tempClazz != null) {
// find view
final SparseArray<View> tempViewArray = new SparseArray<View>();
Field[] fields = tempClazz.getDeclaredFields();
if (Assert.notEmpty(fields)) {
for (Field field : fields) {
FindView viewInject = field.getAnnotation(FindView.class);
if (viewInject != null) {
try {
int viewId = viewInject.value();
View view = findViewById(o, viewId, viewInject.parent());
// Check if the object type is match
Class<?> targetType = field.getType();
Class<?> viewType = view.getClass();
if (!targetType.isAssignableFrom(viewType)) {
String err = "Type mismatch! \n"
+ " The view is (" + viewType.getName() + ") R.id."
+ view.getContext().getResources().getResourceEntryName(viewId)
+ "#" + String.format("0x%08x", viewId) + "\n"
+" Cannot set to (" + targetType.getName() + ") "
+ o.getClass().getName() + "." + field.getName();
Log.e(TAG, err);
continue;
}
// 設置變量值
if (setField(o, field, view)) {
tempViewArray.append(viewId, view);
}
} catch (Throwable e) {
Log.e(TAG, e);
}
}
}
}
// 獲取onClicklistener類
boolean isClickClazz = Assert.isInstanceOf(OnClickListener.class, o);
// 獲取注解的View id
int[] clickIds = findClickIds(tempClazz);
if (Assert.notEmpty(clickIds)) {
for (int id : clickIds) {
if (id != 0) {
View tempView = tempViewArray.get(id);
if (tempView == null) {
try {
tempView = findViewById(o, id, 0);
} catch (Throwable t) {
Log.e(TAG, t);
}
}
if (tempView != null) {
// 設置點擊事件
if (isClickClazz) {
tempView.setOnClickListener(ViewUtils.proxy((OnClickListener) o));
}
}
}
}
}
}
}
通過以上代碼，我們知道，通過反射方式，雖然可以達到我們的目的，但是反射我們都知道，效率是比較低下的，那么我們是否有更好的方式呢，條條大路通羅馬，我就不信只有這一條，下面我們隆重介紹一下我們的ButterKnife依賴注入框架，你會發現一切都是那么的自然，那么順溜～～～
ButterKnife
由于使用放射等方式處理注入，會存在效率方面的問題，所以我們的JakeWharton大神寫了ButterKnife框架，來幫助我們實現依賴注入。
ButterKnife的github地址，現在最新版本8.2.1，我們先來談談ButterKnife對比反射方式的優勢在哪里？
ButterKnife優勢
- 強大的View綁定和Click事件處理功能，簡化繁瑣的代碼編寫
- 可以支持Adapter中的VIewHolder綁定問題
- 采用編譯時通過注解生成代碼，對運行時沒有侵入，對比反射方式，效率倍高
- 代碼清晰，可讀性強
好了，廢話不多說，程序員學習一個新技術時，總是先嘗試這先使用它，再刨析他的原理
ButterKnife安裝
這里我們基于android studio(Android Studio 2.2 Preview 6)開發，所以安裝的時候也是預計studio的，我們看下具體配置
在你android project級別的build.gradle配置文件中，引入android-apt插件
buildscript {
repositories {
jcenter()
}
dependencies {
// butter knife plugins
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
}
在module中使用ButterKnife
在你使用ButterKnife框架的android module的build.gradle配置文件中，引入如下依賴
android studio版本是2.2.0及以上版本
dependencies {
/* butterknife */
compile 'com.jakewharton:butterknife:8.2.1'
annotationProcessor 'com.jakewharton:butterknife-compiler:8.2.1'
}
android studio版本是2.2.0以下版本
apply plugin: 'android-apt'
android {
...
}
dependencies {
compile 'com.jakewharton:butterknife:8.2.1'
apt 'com.jakewharton:butterknife-compiler:8.2.1'
}
在library中使用ButterKnife
添加插件到library的buildscript中
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'com.jakewharton:butterknife-gradle-plugin:8.2.1'
}
}
然后在使用該library的module中，配置以下插件
apply plugin: 'com.android.library'
apply plugin: 'com.jakewharton.butterknife'
ButterKnife使用實例
注入視圖
@BindView(R.id.toolbar)
Toolbar toolbar;
@BindView(R.id.fab)
FloatingActionButton fab;
注入事件
@OnClick(R.id.fab)
public void show(View view){
Snackbar.make(view, "Replace with your own action",Snackbar.LENGTH_LONG)
.setAction("Action", null).show();
}
當然，需要我們在activity或者fragment初始化的時候進行綁定操作
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);
setSupportActionBar(toolbar);
}
看到這里，是不是還是不清晰，只是知道了怎么使用，那我們現在來刨析一下ButterKnife是怎么工作的？
ButterKnife原理刨析
可能很多人都覺得ButterKnife在bind(this)方法執行的時候通過反射獲取MainActivity中所有的帶有@BindView注解的屬性并且獲得注解中的R.id.xxx值，最后還是通過反射拿到Activity.findViewById()方法獲取View，并賦值給MainActivity中的某個屬性。這是一種原始的使用反射的方式，缺點是反射影響App性能，造成卡頓，并且會產生大量的臨時對象，頻繁的引發GC。
ButterKnife顯然沒有使用這種方式，它用了Java Annotation Processing技術，就是在Java代碼編譯成Java字節碼的時候就已經處理了@Bind、@OnClick（ButterKnife還支持很多其他的注解）這些注解了。
Java Annotation Processing
Java Annotation Processing是javac中用于編譯時掃描和解析Java注解的工具
你可以你定義注解，并且自己定義解析器來處理它們。Annotation processing是在編譯階段執行的，它的原理就是讀入Java源代碼，解析注解，然后生成新的Java代碼。新生成的Java代碼最后被編譯成Java字節碼，注解解析器（Annotation Processor）不能改變讀入的Java 類，比如不能加入或刪除Java方法
下圖是Java 編譯代碼的整個過程，可以幫助我們很好理解注解解析的過程：
框架工作流程
當你編譯使用了ButterKnife框架的應用程序時，ButterKnifeProcessor類的process()方法開始工作，會執行以下操作：
- 掃描Java代碼中所有的ButterKnife注解@Bind、@OnClick、@OnItemClicked等
- 當它發現一個類中含有任何一個注解時，ButterKnifeProcessor會幫你生成一個Java類，名字類似<className>$$ViewBinder，這個新生成的類實現了ViewBinder<T>接口
- 這個ViewBinder類中包含了所有對應的代碼，比如@Bind注解對應findViewById(), @OnClick對應了view.setOnClickListener()等等
最后當Activity啟動ButterKnife.bind(this)執行時，ButterKnife會去加載對應的ViewBinder類調用它們的bind()方法
一個例子如下:
android源碼
public class MainActivity extends AppCompatActivity {
@BindView(R.id.toolbar)
Toolbar toolbar;
@BindView(R.id.fab)
FloatingActionButton fab;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);
setSupportActionBar(toolbar);
}
@OnClick(R.id.fab)
public void show(View view){
Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
.setAction("Action", null).show();
}
}
編譯之后，會在目錄下生成兩個文件
讓我們來看下這兩個文件內容：
MainActivity_ViewBinder.class
public final class MainActivity_ViewBinder implements ViewBinder<MainActivity> {
@Override
public Unbinder bind(Finder finder, MainActivity target, Object source) {
return new MainActivity_ViewBinding<>(target, finder, source);
}
}
MainActivity_ViewBinding.class
public class MainActivity_ViewBinding<T extends MainActivity> implements Unbinder {
protected T target;
private View view2131492973;
public MainActivity_ViewBinding(final T target, Finder finder, Object source) {
this.target = target;
View view;
target.toolbar = finder.findRequiredViewAsType(source, R.id.toolbar, "field 'toolbar'", Toolbar.class);
view = finder.findRequiredView(source, R.id.fab, "field 'fab' and method 'show'");
target.fab = finder.castView(view, R.id.fab, "field 'fab'", FloatingActionButton.class);
view2131492973 = view;
view.setOnClickListener(new DebouncingOnClickListener() {
@Override
public void doClick(View p0) {
target.show(p0);
}
});
}
@Override
public void unbind() {
T target = this.target;
if (target == null) throw new IllegalStateException("Bindings already cleared.");
target.toolbar = null;
target.fab = null;
view2131492973.setOnClickListener(null);
view2131492973 = null;
this.target = null;
}
}
我們可以看到MainActivity_ViewBinder類在執行bind方法的時候會new一個MainActivity_ViewBinding對象，并且傳入了MainActivity實例，在MainActivity_ViewBinding對象執行構造方法的時候，需要對target.XXX，所以我們這里在MainActivity中的BindView注解的屬性，不能使用private修飾符，那么使用protected修飾是否可以呢？答案是可以的，因為ButterKnifeProcessor類的process()方法會在MainActivity的同一個包下生成Binder和Binding類，所以同包下是可以調用到的。同樣的道理，onClickListener也是通過找到view，然后設置view的onclicklistener為target.XXX()方法，同樣的調用target.XXX()方法需要public或者protected修飾。
通過以上的流程我們知道，ButterKnife是在編譯時通過注解方式解析生成了Binder類和Binding，在Activity中調用了ButterKnife.bind(this)方法后，通過Bunder和Binding的配合，找到Activity中的類，并且類似與代理一樣的，為Activity的注解綁定了對應的實例或者調用方法。
ButterKnife.bind 執行階段
最后，執行bind方法時，我們會調用ButterKnife.bind(this)：
ButterKnife會調用findViewBinderForClass(targetClass)加載MainActivity$$ViewBinder.java類
然后調用ViewBinder的bind方法，動態注入MainActivity類中所有的View屬性和
如果Activity中有@OnClick注解的方法，ButterKnife會在ViewBinder類中給View設置onClickListener，并且將@OnClick注解的方法傳入其中
在上面的過程中可以看到，為什么你用@Bind、@OnClick等注解標注的屬性或方法必須是public或protected的，因為ButterKnife是通過ExampleActivity.this.editText來注入View的
為什么要這樣呢？有些注入框架比如roboguice你是可以把View設置成private的，答案就是性能。如果你把View設置成private，那么框架必須通過反射來注入View，不管現在手機的CPU處理器變得多快，如果有些操作會影響性能，那么是肯定要避免的，這就是ButterKnife與其他注入框架的不同
有一點需要注意
通過ButterKnife來注入View時，ButterKnife有bind(Object, View) 和 bind(View)兩個方法，有什么區別呢？
如果你自定義了一個View，比如public class BadgeLayout extends Fragment，那么你可以可以通過ButterKnife.bind(BadgeLayout)來注入View的
如果你在一個ViewHolder中inflate了一個xml布局文件，得到一個View對象，并且這個View是LinearLayout或FrameLayout等系統自帶View，那么不是不能用ButterKnife.bind(View)來注入View的，因為ButterKnife認為這些類的包名以com.android開頭的類是沒有注解功能的（-。- 這不是廢話嗎？），所以這種情況你需要使用ButterKnife.bind(ViewHolder，View)來注入View。
這表示你是把@Bind、@OnClick等注解寫到了這個ViewHolder類中，ViewHolder中的View呢需要從后面那個View中去找
