ButterKnife第三方庫源碼分析

maohude 8年前發布 | 6K 次閱讀源碼分析 Android開發移動開發 butterknife

ButterKnife原理其實也很簡單

ButterKnife是大名鼎鼎JakeWharton熱門開源項目的其中一個，讓開發者不再重復的進行findViewById的操作。

配合android studio的插件，一鍵自動生成xml文件所有view的實例。

ButterKnife為什么會那么神奇，自動幫助開發者省去了繁瑣的操作，他的實現的原理到底是怎么樣的呢？

下面我們從代碼使用上，一步一步的分析ButterKnife的實現原理

分析ButterKnife版本：com.jakewharton:butterknife:7.0.1

使用ButterKnife快速初始化xml布局對象.



public class MainActivity extends AppCompatActivity {

  @Bind(R.id.tv01) TextView tv01;
  @Bind(R.id.tv02) TextView tv02;
  @Bind(R.id.tv03) TextView tv03;
  @Bind(R.id.tv04) TextView tv04;
  @Bind(R.id.activity_main) LinearLayout activityMain;

  @OnClick(R.id.tv01)
  public void test(View v) {

  }

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    ButterKnife.bind(this);
  }

}

一段很常規使用ButterKnife快速初始化xml布局對象的代碼。為什么當onCreate方法的ButterKnife.bind(this);

調用完畢，xml所有的布局對象都初始化好了呢？

我們進入到@Bind注解里看看究竟，看看是否找得到線索


@Retention(CLASS) @Target(FIELD)
public @interface Bind {
  /** View ID to which the field will be bound. */
  int[] value();
}

可以看到@Retention(CLASS)，這句表示：保留時間編譯時，也就是工程編譯時運行的注解.

常規獲取View對象的方式是這樣的：

tv01 = (TextView) findViewById(R.id.tv01);


//現在變成這樣
@Bind(R.id.tv01) TextView tv01;

所以說，ButterKnife這個庫應該拿到了R.id.tv01 這個id值，也拿到了tv01成員變量，在通過findViewById給tv01賦值

但是，ButterKnife在哪里進行這樣的操作呢？

從@Bind注解來看，應該是編譯時拿到了id值

我們在build目錄下找到了ButterKnife生成的新文件：

build\generated\source\apt\debug\com\butterknifedemo\MainActivity$$ViewBinder



// Generated code from Butter Knife. Do not modify!
package com.butterknifedemo;

import android.view.View;
import butterknife.ButterKnife.Finder;
import butterknife.ButterKnife.ViewBinder;

public class MainActivity$$ViewBinder<T extends com.butterknifedemo.MainActivity> implements ViewBinder<T> {
  @Override public void bind(final Finder finder, final T target, Object source) {
    View view;
    view = finder.findRequiredView(source, 2131427413, "field 'tv01' and method 'test'");
    target.tv01 = finder.castView(view, 2131427413, "field 'tv01'");
    view.setOnClickListener(
      new butterknife.internal.DebouncingOnClickListener() {
        @Override public void doClick(
          android.view.View p0
        ) {
          target.test(p0);
        }
      });
    view = finder.findRequiredView(source, 2131427414, "field 'tv02'");
    target.tv02 = finder.castView(view, 2131427414, "field 'tv02'");
    view = finder.findRequiredView(source, 2131427415, "field 'tv03'");
    target.tv03 = finder.castView(view, 2131427415, "field 'tv03'");
    view = finder.findRequiredView(source, 2131427416, "field 'tv04'");
    target.tv04 = finder.castView(view, 2131427416, "field 'tv04'");
    view = finder.findRequiredView(source, 2131427412, "field 'activityMain'");
    target.activityMain = finder.castView(view, 2131427412, "field 'activityMain'");
  }

  @Override public void unbind(T target) {
    target.tv01 = null;
    target.tv02 = null;
    target.tv03 = null;
    target.tv04 = null;
    target.activityMain = null;
  }
}

我們發現ButterKnife在build目錄下生成了一個類，這個類竟然幫助我們完成了findVieweById的操作

那這個類是怎么制作出來的呢？

現在，我們直接去看ButterKnife源碼：

    

//先進入里面看看
ButterKnife.bind(this);


 //顯然Activity對象作為target往下傳遞了
 //Finder.ACTIVITY 是什么呢
 public static void bind(Activity target) {
   bind(target, target, Finder.ACTIVITY);
 }


//Finder.ACTIVITY 原來是 ButterKnife 內部枚舉
//return ((Activity) source).findViewById(id); 注意看句代碼
public final class ButterKnife {
  private ButterKnife() {
    throw new AssertionError("No instances.");
  }

  /** DO NOT USE: Exposed for generated code. */
  @SuppressWarnings("UnusedDeclaration") // Used by generated code.
  public enum Finder {
    VIEW {
      @Override protected View findView(Object source, int id) {
        return ((View) source).findViewById(id);
      }

      @Override public Context getContext(Object source) {
        return ((View) source).getContext();
      }
    },
    ACTIVITY {
      @Override protected View findView(Object source, int id) {
        return ((Activity) source).findViewById(id);
      }

      @Override public Context getContext(Object source) {
        return (Activity) source;
      }
    },
    DIALOG {
      @Override protected View findView(Object source, int id) {
        return ((Dialog) source).findViewById(id);
      }

      @Override public Context getContext(Object source) {
        return ((Dialog) source).getContext();
      }
    };



 //findViewBinderForClass這個方法通過Activity對象去查找返回了一個ViewBinder類，
 //然后viewBinder.bind(finder, target, source);
 static void bind(Object target, Object source, Finder finder) {
   Class<?> targetClass = target.getClass();
   try {
     if (debug) Log.d(TAG, "Looking up view binder for " + targetClass.getName());
     ViewBinder<Object> viewBinder = findViewBinderForClass(targetClass);
     if (viewBinder != null) {
       viewBinder.bind(finder, target, source);
     }
   } catch (Exception e) {
     throw new RuntimeException("Unable to bind views for " + targetClass.getName(), e);
   }
 }

這里有兩個問題：

findViewBinderForClass通過Activity字節碼如何找到的viewBinder？
viewBinder是什么？

首先，看viewBinder是什么：


/** DO NOT USE: Exposed for generated code. */
public interface ViewBinder<T> {
void bind(Finder finder, T target, Object source);
void unbind(T target);
}

原來是個接口，注釋說自動生成代碼用的，看看剛剛在build找到的類：


public class MainActivity$$ViewBinder
<T extends com.butterknifedemo.MainActivity> implements ViewBinder<T> {

  @Override public void bind(final Finder finder, final T target, Object source) {

原來viewBinder.bind(finder, target, source);這行代碼調用了MainActivity$$ViewBinder類里的bind方法，

幫助我們完成findViewById工作

現在我們知道了，平時我們調用ButterKnife.bind(this);

最終都會調用對應生成的$$ViewBinder類里的bind方法幫助我們完成繁瑣的操作

問題2：怎么通過Activity字節碼找到viewBinder對象的？

private static ViewBinder<Object> findViewBinderForClass(Class<?> cls)
    throws IllegalAccessException, InstantiationException {
  ViewBinder<Object> viewBinder = BINDERS.get(cls);
  if (viewBinder != null) {
    if (debug) Log.d(TAG, "HIT: Cached in view binder map.");
    return viewBinder;
  }
  String clsName = cls.getName();
  if (clsName.startsWith(ANDROID_PREFIX) || clsName.startsWith(JAVA_PREFIX)) {
    if (debug) Log.d(TAG, "MISS: Reached framework class. Abandoning search.");
    return NOP_VIEW_BINDER;
  }
  try {
    Class<?> viewBindingClass = 
    Class.forName(clsName + ButterKnifeProcessor.SUFFIX);//SUFFIX = "$$ViewBinder";
    //noinspection unchecked
    viewBinder = (ViewBinder<Object>) viewBindingClass.newInstance();
    if (debug) Log.d(TAG, "HIT: Loaded view binder class.");
  } catch (ClassNotFoundException e) {
    if (debug) Log.d(TAG, "Not found. Trying superclass " + cls.getSuperclass().getName());
    viewBinder = findViewBinderForClass(cls.getSuperclass());
  }
  BINDERS.put(cls, viewBinder);
  return viewBinder;
}

原來先從BINDERS.get(cls);里面取，空的話在通過Class.forName(clsName + ButterKnifeProcessor.SUFFIX);

創建出一個新對象出來，前提是這個$$ViewBinder已經生成好了

什么時候生成這個類，怎么生成的？通過注解@Bind我們應該猜到，是工程編譯時就生成好了的

在ButterKnife源碼中我們發現了這一個類：


public final class ButterKnifeProcessor extends AbstractProcessor {
  public static final String SUFFIX = "$$ViewBinder";
  public static final String ANDROID_PREFIX = "android.";
  public static final String JAVA_PREFIX = "java.";
  static final String VIEW_TYPE = "android.view.View";
  private static final String COLOR_STATE_LIST_TYPE = "android.content.res.ColorStateList";
  private static final String DRAWABLE_TYPE = "android.graphics.drawable.Drawable";
  private static final String NULLABLE_ANNOTATION_NAME = "Nullable";
  private static final String ITERABLE_TYPE = "java.lang.Iterable<?>";
  private static final String LIST_TYPE = List.class.getCanonicalName();
  private static final List<Class<? extends Annotation>> LISTENERS = Arrays.asList(//
      OnCheckedChanged.class, //
      OnClick.class, //
      OnEditorAction.class, //
      OnFocusChange.class, //
      OnItemClick.class, //
      OnItemLongClick.class, //
      OnItemSelected.class, //
      OnLongClick.class, //
      OnPageChange.class, //
      OnTextChanged.class, //
      OnTouch.class //
  );


 @Override public Set<String> getSupportedAnnotationTypes() {
   Set<String> types = new LinkedHashSet<String>();

   types.add(Bind.class.getCanonicalName());

   for (Class<? extends Annotation> listener : LISTENERS) {
     types.add(listener.getCanonicalName());
   }

   types.add(BindBool.class.getCanonicalName());
   types.add(BindColor.class.getCanonicalName());
   types.add(BindDimen.class.getCanonicalName());
   types.add(BindDrawable.class.getCanonicalName());
   types.add(BindInt.class.getCanonicalName());
   types.add(BindString.class.getCanonicalName());

   return types;
 }

extends AbstractProcessor，繼承這一個類，表示它可以在工程編譯是運行里面的process方法，

ButterKnife就是通過編譯時，apt會自動查找集成AbstractProcessor的類，調用process方法

在process方法中找到存在ButterKnife的注解信息，獲取在注解對應下的數據，例如id值

上面的代碼我們還可以看到，Bind，OnClick等等注解已經存儲好了，就等著遍歷配對處理獲取數據

看process方法：


@Override public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
Map<TypeElement, BindingClass> targetClassMap = findAndParseTargets(env);

for (Map.Entry<TypeElement, BindingClass> entry : targetClassMap.entrySet()) {
  TypeElement typeElement = entry.getKey();
  BindingClass bindingClass = entry.getValue();

  try {
    JavaFileObject jfo = filer.createSourceFile(bindingClass.getFqcn(), typeElement);
    Writer writer = jfo.openWriter();
    writer.write(bindingClass.brewJava());
    writer.flush();
    writer.close();
  } catch (IOException e) {
    error(typeElement, "Unable to write view binder for type %s: %s", typeElement,
        e.getMessage());
  }
}

return true;
}

從JavaFileObject，Writer這個類就可以知道，ButterKnife把一些東西寫到文件中去了，應該猜到

那些自動生成的java文件就從這里出來的

代碼生成java文件，代碼加載java文件去運行，有點意思

先看看findAndParseTargets方法做了什么：



private Map<TypeElement, BindingClass> findAndParseTargets(RoundEnvironment env) {
Map<TypeElement, BindingClass> targetClassMap = new LinkedHashMap<TypeElement, BindingClass>();
Set<String> erasedTargetNames = new LinkedHashSet<String>();

// Process each @Bind element.
for (Element element : env.getElementsAnnotatedWith(Bind.class)) {
  try {
    parseBind(element, targetClassMap, erasedTargetNames);
  } catch (Exception e) {
    logParsingError(element, Bind.class, e);
  }
}

// Process each annotation that corresponds to a listener.
for (Class<? extends Annotation> listener : LISTENERS) {
  findAndParseListener(env, listener, targetClassMap, erasedTargetNames);
}

// Process each @BindBool element.
for (Element element : env.getElementsAnnotatedWith(BindBool.class)) {
  try {
    parseResourceBool(element, targetClassMap, erasedTargetNames);
  } catch (Exception e) {
    logParsingError(element, BindBool.class, e);
  }
}

....

可以看到，正在查找Bind之類的注解，猜都猜到通過定位注解獲取注解下面的值了吧

現在，我們回過頭看看把什么東西寫到文件中去了，看著行代碼： writer.write(bindingClass.brewJava());



String brewJava() {
StringBuilder builder = new StringBuilder();
builder.append("http:// Generated code from Butter Knife. Do not modify!\n");
builder.append("package ").append(classPackage).append(";\n\n");

if (!resourceBindings.isEmpty()) {
  builder.append("import android.content.res.Resources;\n");
}
if (!viewIdMap.isEmpty() || !collectionBindings.isEmpty()) {
  builder.append("import android.view.View;\n");
}
builder.append("import butterknife.ButterKnife.Finder;\n");
if (parentViewBinder == null) {
  builder.append("import butterknife.ButterKnife.ViewBinder;\n");
}
builder.append('\n');

builder.append("public class ").append(className);
builder.append("<T extends ").append(targetClass).append(">");

if (parentViewBinder != null) {
  builder.append(" extends ").append(parentViewBinder).append("<T>");
} else {
  builder.append(" implements ViewBinder<T>");
}
builder.append(" {\n");

emitBindMethod(builder);
builder.append('\n');
emitUnbindMethod(builder);

builder.append("}\n");
return builder.toString();
}

可以一目了然的看到使用了StringBuilder手動拼接字符串的方式，生成了java文件，挺不容易的。

問題又來了，這些java文件靜態不變化的部分可以寫死，那些動態靈活的部分呢？例如View的id，對象名稱

繼續深入看源碼：


//bind方法代碼拼接
private void emitBindMethod(StringBuilder builder) {
builder.append("  @Override ")
    .append("public void bind(final Finder finder, final T target, Object source) {\n");

// Emit a call to the superclass binder, if any.
if (parentViewBinder != null) {
  builder.append("    super.bind(finder, target, source);\n\n");
}

if (!viewIdMap.isEmpty() || !collectionBindings.isEmpty()) {
  // Local variable in which all views will be temporarily stored.
  builder.append("    View view;\n");

  // Loop over each view bindings and emit it.
  for (ViewBindings bindings : viewIdMap.values()) {

    //進入里面看看
    emitViewBindings(builder, bindings);
  }







  private void emitViewBindings(StringBuilder builder, ViewBindings bindings) {
    builder.append("    view = ");

    List<ViewBinding> requiredViewBindings = bindings.getRequiredBindings();
    if (requiredViewBindings.isEmpty()) {
      builder.append("finder.findOptionalView(source, ")
          .append(bindings.getId())//這個就是View的id了
          .append(", null);\n");
    } else {
      if (bindings.getId() == View.NO_ID) {
        builder.append("target;\n");
      } else {
        builder.append("finder.findRequiredView(source, ")
            .append(bindings.getId())
            .append(", \"");
        emitHumanDescription(builder, requiredViewBindings);
        builder.append("\");\n");
      }
    }

    //字段看這里，進去
    emitFieldBindings(builder, bindings);
    emitMethodBindings(builder, bindings);
  }



static void emitHumanDescription(StringBuilder builder,
      Collection<? extends ViewBinding> bindings) {
    Iterator<? extends ViewBinding> iterator = bindings.iterator();
    switch (bindings.size()) {
      case 1:
        builder.append(iterator.next().getDescription());//View變量名稱
        break;
      case 2:
        builder.append(iterator.next().getDescription())



@Override public String getDescription() {
    return "field '" + name + "'";
  }

從上面的代碼可以知道，動態的部分通過BindingClass這個類來獲取的，那這是類怎么來的，看之前的代碼：

@Override public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
  Map<TypeElement, BindingClass> targetClassMap = findAndParseTargets(env);

原來這個類是從findAndParseTargets里來的，剛剛我們知道，里面做了定位Bind，OnClick注解的操作，

定位的同時也把注解的值，例如id值，變量名稱存在到BindingClass對象中了，很符合面向對象的思想


private void parseBindOne(Element element, Map<TypeElement, BindingClass> targetClassMap,
  Set<String> erasedTargetNames) {
boolean hasError = false;
TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();


    ...


    BindingClass bindingClass = targetClassMap.get(enclosingElement);
if (bindingClass != null) {
  ViewBindings viewBindings = bindingClass.getViewBinding(id);
  if (viewBindings != null) {
    Iterator<FieldViewBinding> iterator = viewBindings.getFieldBindings().iterator();
    if (iterator.hasNext()) {
      FieldViewBinding existingBinding = iterator.next();
      error(element, "Attempt to use @%s for an already bound ID %d on '%s'. (%s.%s)",
          Bind.class.getSimpleName(), id, existingBinding.getName(),
          enclosingElement.getQualifiedName(), element.getSimpleName());
      return;
    }
  }
} else {
  bindingClass = getOrCreateTargetClass(targetClassMap, enclosingElement);
}

String name = element.getSimpleName().toString();
String type = elementType.toString();
boolean required = isRequiredBinding(element);

FieldViewBinding binding = new FieldViewBinding(name, type, required);
bindingClass.addField(id, binding);

// Add the type-erased version to the valid binding targets set.
erasedTargetNames.add(enclosingElement.toString());
}




 private BindingClass getOrCreateTargetClass(Map<TypeElement, BindingClass> targetClassMap,
     TypeElement enclosingElement) {
   BindingClass bindingClass = targetClassMap.get(enclosingElement);
   if (bindingClass == null) {
     String targetType = enclosingElement.getQualifiedName().toString();
     String classPackage = getPackageName(enclosingElement);
     String className = getClassName(enclosingElement, classPackage) + SUFFIX;

     bindingClass = new BindingClass(classPackage, className, targetType);
     targetClassMap.put(enclosingElement, bindingClass);
   }
   return bindingClass;
 }

最后，還有一點的是：ButterKnife通過注解獲取id值并沒有使用到反射，獲取到變量也是通過Activity.view的形式

不同與一些反射獲取注解的框架，使用反射會增加IO操作，增加了時間操作，多了會變得卡頓

反射的方式成員變量可使用private，而ButterKnife不可以，必須public或者protected

因為ButterKnife沒有使用反射，需要Activity.view這樣去獲取一些對象賦值

具體可以去看源碼，總的來說：

ButterKnife將View的id值放到@Bind注解中
ButterKnife通過extends AbstractProcessor編譯時自動調用process方法來定位和存在注解與注解上的id值
找到所有帶注解與值的對象，存儲在集合中，一個for循環一頓狂寫，把java文件寫到build目錄下
當調用ButterKnife.bind(this)的時候，最終會調用生成的$$viewBinder類里的bind方法
$$viewBinder里的bind方法，找已動態生成好了finfViewById的過程，通過Activity.view的形式初始化所有view

來自：https://ruzhan123.github.io/2016/11/09/2016-11-09-22-ButterKnife第三方庫源碼分析/

本文由用戶 maohude 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1478748930943.html

源碼分析 Android開發移動開發 butterknife

ButterKnife第三方庫源碼分析

相關經驗

相關資訊

相關文檔

目錄