ButterKnife实现原理

ButterKnife源码地址：https://github.com/JakeWharton/butterknife
1.所用主要技术
APT,反射,javaPoet(生成.java文件)
2.原理
在编译前，生成相应的辅助类，xx_ViewBinding.java,运行时，利用该辅助类对Activity中的view进行findViewById等操作
3.代码实现(以下以@BindView->findViewById为例)
在早期的时候，实现@BindView的功能，是在代码运行时通过反射+注解的方法来实现的。反射拿到当前activity中所有的变量->遍历所有变量->拿到变量上的注解信息(R.id.xxx)->调用findViewById->利用反射将activity中该变量初始化
以上方案可以实现@BindView的功能，但在运行时，大量运用反射，会影响app的性能。因此，ButterKnife在实现上，将这些功能移到了编译前。

1>生成辅助类
在编译前对代码进行处理，就要用到APT(Annotation Processor Tool),这个我在java注解的使用已经有大致的使用方法，简言之，就是当你需要动态生成.java文件时，就需要用到APT。通过ButterKnife的使用方法

 implementation 'com.jakewharton:butterknife:10.2.3'
 annotationProcessor 'com.jakewharton:butterknife-compiler:10.2.3'

可能看出，ButterKnife中，必然会有AbstractProcessor的子类来对处解进行处理，并生成相应的辅助类。

image.png

在ButterKnife工程中，butterknife-compiler工程，便是注解处理器相关的代码。在此工程下，可以发现一个类 ButterKnifeProcessor.java

  public final class ButterKnifeProcessor extends AbstractProcessor {
  @Override 
  public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
    Map<TypeElement, BindingSet> bindingMap = findAndParseTargets(env);

    for (Map.Entry<TypeElement, BindingSet> entry : bindingMap.entrySet()) {
      TypeElement typeElement = entry.getKey();
      BindingSet binding = entry.getValue();

      JavaFile javaFile = binding.brewJava(sdk, debuggable);
      try {
        javaFile.writeTo(filer);
      } catch (IOException e) {
        error(typeElement, "Unable to write binding for type %s: %s", typeElement, e.getMessage());
      }
    }
    return false;
  }
}

以上只贴出了process方法，这是apt的关键，具体此方法是如何运行的，我就暂不分析了，里面东西太多，我们只需要知道，这个注解处理器会根据注解所在的类，生成一个相应的.java文件的辅助类，在代码运行时，通过辅助类来完成对view的findViewById.

2>辅助类的内容
下面以我的测试工程为例

public class MainActivity extends AppCompatActivity {
    @BindView(R.id.event_reflect)
    public Button reflectBt;

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

    @OnClick(R.id.event_reflect)
    public void reflectClick() {
        startActivity(new Intent(MainActivity.this, Reflect2Activity.class));
    }
}

MainActivity中，用到了@BindView以及@OnClick两个注解，在

image.png

apt生成的java代码会生成在此处，相应的java文件名称为MainActivity_ViewBinding.java，通过名称我们可以发现，apt生成的辅助类的名称即为注解所在类的名称加_ViewBinding，这样便于后续各Activity能找到其相应的辅助类。

public class MainActivity_ViewBinding implements Unbinder {
  private MainActivity target;

  private View view7f08007e;

  @UiThread
  public MainActivity_ViewBinding(MainActivity target) {
    this(target, target.getWindow().getDecorView());
  }

  @UiThread
  public MainActivity_ViewBinding(final MainActivity target, View source) {
    this.target = target;

    View view;
    view = Utils.findRequiredView(source, R.id.event_reflect, "field 'reflectBt' and method 'reflectClick'");
    target.reflectBt = Utils.castView(view, R.id.event_reflect, "field 'reflectBt'", Button.class);
    view7f08007e = view;
    view.setOnClickListener(new DebouncingOnClickListener() {
      @Override
      public void doClick(View p0) {
        target.reflectClick();
      }
    });
  }

  @Override
  @CallSuper
  public void unbind() {
    MainActivity target = this.target;
    if (target == null) throw new IllegalStateException("Bindings already cleared.");
    this.target = null;

    target.reflectBt = null;

    view7f08007e.setOnClickListener(null);
    view7f08007e = null;
  }
}

打开此文件，我们可能看到setOnClickListener，以及 Utils.findRequiredView方法，顺着代码，我们在Utils中就可以找到相应的findViewById的方法。
关于辅助类的生成，大致内容就是这些.

3>辅助类如何起作用
下面来看我们在用ButterKnife时，用到的ButterKnife.bind(this)，其代码出下：

  public final class ButterKnife {
    public static Unbinder bind(@NonNull Activity target) {
    View sourceView = target.getWindow().getDecorView();
    return bind(target, sourceView);
  }

  public static Unbinder bind(@NonNull Object target, @NonNull View source) {
    Class<?> targetClass = target.getClass();
    if (debug) Log.d(TAG, "Looking up binding for " + targetClass.getName());
    Constructor<? extends Unbinder> constructor = findBindingConstructorForClass(targetClass);

    if (constructor == null) {
      return Unbinder.EMPTY;
    }

    //noinspection TryWithIdenticalCatches Resolves to API 19+ only type.
    try {
      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);
    }
  }

  private static Constructor<? extends Unbinder> findBindingConstructorForClass(Class<?> cls) {
    Constructor<? extends Unbinder> bindingCtor = BINDINGS.get(cls);
    if (bindingCtor != null || BINDINGS.containsKey(cls)) {
      if (debug) Log.d(TAG, "HIT: Cached in binding map.");
      return bindingCtor;
    }
    String clsName = cls.getName();
    if (clsName.startsWith("android.") || clsName.startsWith("java.")
        || clsName.startsWith("androidx.")) {
      if (debug) Log.d(TAG, "MISS: Reached framework class. Abandoning search.");
      return null;
    }
    try {
      Class<?> bindingClass = cls.getClassLoader().loadClass(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);
    }
    BINDINGS.put(cls, bindingCtor);
    return bindingCtor;
  }
}

从findBindingConstructorForClass(targetClass)及cls.getClassLoader().loadClass(clsName + "_ViewBinding");可以看出，在ButterKnife.bind(this)中，最主要的就是通过当前activity的名称以固定的"_ViewBinding"后缀，找到了当前Activity的辅助类，并通过反射，生成了该辅助类的对象。而该辅助类持有当前的activity对象，从辅助类的代码可以看出，在辅助类里对当前Activity中的各变量进行了相应的findViewById及setOnClickListener等操作

4>为什么要求public
在使用BindView时，我们发现，要求变量不能为private,从辅助类的代码

 target.reflectBt = Utils.castView(view, R.id.event_reflect, "field 'reflectBt'", Button.class);

可以看出，在初始化view时，是直接使用的该view,如果设置成private,这里就会出问题

4.总结
以上对ButterKnife的原理做了一些简单的介绍，当然，ButterKnife中还有很多内容和功能，以及其中关于javaPoet使用，我们就不一一介绍了，了解了其实现原理后，其他相应的注解相信你会很快掌握。