ButterKnife原理分析(一)设计思想

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hesong1120/article/details/78841392

用过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类是怎么生成的，为什么不同注解会有不一样的内容，下一篇中我们继续分析。