手撕ButterKnife

思惟导图

使用方法

最新版本具体信息根据ButterKnife的官网来进行查找。

1. 导入包。 在app下的build.gradle的dependencies中进行引入,固然高版本也容易出现问题。

implementation 'com.jakewharton:butterknife:10.2.1'
annotationProcessor 'com.jakewharton:butterknife-compiler:10.2.1'
复制代码

2. 项目中进行使用。 根据官网中给出的使用方式来使用便可，下方只给出一种使用

class ExampleActivity extends Activity {
  // 经过BindView的一个
  @BindView(R.id.title) TextView title;

  @Override public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.simple_activity);
    ButterKnife.bind(this);
  }
}
复制代码

经过上述的@BindView的一个注解，将布局中一个控件和引用进行相关联的绑定操做。这样的操做还有不少

ButterKnife中的注解	对应Java代码
@BindView	findViewById()
@BindString	getResources().getString()
@OnClick	view.setOnClickListener(new View.OnClickListener() {...})

不得不认可，ButterKnife在必定的程度上会提升个人开发效率，可是他究竟是怎么运做呢？

源码分析

在使用ButterKnife的时候其实咱们是否注意到一个问题，咱们必定须要写一个这样的一段代码。

ButterKnife.bind(this);
复制代码

若是不写会出现下方这样的错误。

@BindView(R.id.view) View view;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
// 判断写和不写时的区别
// ButterKnife.bind(this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        view.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

            }
        });
    }
复制代码

咱们可以发现没有加入这句的话的代码出现对象为空的状况，那咱们也就能明白ButterKnife的入口其实就是咱们必需要写的这一段代码了。

对ButterKnife.bind(this)进行追溯

public static Unbinder bind(@NonNull Activity target) {
    // DecoView是Window中一个变量，是根布局视图的载体
    // 详细须要查看Window的惟一子类PhoneWindow
    // Activity和Window绑定，获取当前的根视图
    View sourceView = target.getWindow().getDecorView();
    return bind(target, sourceView); // 1
  }

// 由注释1调用的函数
public static Unbinder bind(@NonNull Object target, @NonNull View source) {
    Class<?> targetClass = target.getClass();
    // 去寻找一个构造函数
    Constructor<? extends Unbinder> constructor = findBindingConstructorForClass(targetClass); // 2

    if (constructor == null) {
      // 直接返回为空
      return Unbinder.EMPTY;
    }

    //noinspection TryWithIdenticalCatches Resolves to API 19+ only type.
    try {
      return constructor.newInstance(target, source); // 3
    } catch (IllegalAccessException e) {
      // 一些错误处理
    }
  }
复制代码

先通过上述代码中的注释2，也就是使去构造一个对象。若是没有找到，就直接返回为空；若是找到构造方法了，就进行构造（使用的ClassLoader来加载，也就是反射机制）。那么主要任务仍是注释3经过newInstance函数来完成一个Unbinder对象的建立。

public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        if (serializationClass == null) {
            return newInstance0(initargs);
        } else {
            return (T) newInstanceFromSerialization(serializationCtor, serializationClass);
        }
    }
复制代码

这里的返回值居然是一个泛型，说明咱们以前有说落了什么？回头看看，其实咱们就知道了Constructor<? extends Unbinder> constructor = findBindingConstructorForClass(targetClass);这段函数中传入的泛型正是继承自Unbinder的，因此咱们的泛型返回值也就肯定了。

加载文件长相

看看咱们经过这个ButterKnife生成的代码是长什么样的。

public class MainActivity_ViewBinding implements Unbinder {
  private MainActivity target;

  @UiThread
  public MainActivity_ViewBinding(MainActivity target) {
    this(target, target.getWindow().getDecorView());
  }
  // 绑定，这里存在两个函数是否是似曾相识呢？
  @UiThread
  public MainActivity_ViewBinding(MainActivity target, View source) {
    this.target = target;
    // 经过变量来调用他内部的一个变量
    target.view = Utils.findRequiredView(source, R.id.view, "field 'view'");
  }
  
  // 解绑
  @Override
  @CallSuper
  public void unbind() {
    MainActivity target = this.target;
    if (target == null) throw new IllegalStateException("Bindings already cleared.");
    this.target = null;
    target.view = null;
  }
}
复制代码

在这里其实咱们已经明白了，为何咱们的变量只能是public或者不加修饰符的缘由了。

可是咱们并不仅是来看这个的，咱们要知道注释的功能是如何实现的？咱们看到了一个咱们定义的view变量，作了一个Utils.findRequiredView(source, R.id.view, "field 'view'");的操做，咱们姑且进去看看好了。

public static View findRequiredView(View source, @IdRes int id, String who) {
    // 我看到了啥??????????????????????
    View view = source.findViewById(id);
    if (view != null) {
      return view;
    }
    String name = getResourceEntryName(source, id);
  }
复制代码

原来他的寻找原理仍是经过findViewById()来完成整个的定位操做的，那ButterKnife的神奇之处也就再也不神奇了。

为了验证咱们的想法，我对@OnClick的注解作了一个测试。下方贴出ButterKnife中给出的答案。

@UiThread
  public MainActivity_ViewBinding(MainActivity target, View source) {
    viewSource = source;
    source.setOnClickListener(new DebouncingOnClickListener() {
      @Override
      public void doClick(View p0) {
        target.start();
      }
    });
  }
复制代码

和咱们写的方式仍是如出一辙的。那咱们的好奇心来了，他是如何实现这个代码的输出的，这也是咱们整个ButterKnife的核心工做了。

文件生成过程

其实在最开始的导包的时候，咱们就应该注意到的一个问题，由于咱们导入的ButterKnife并非只有一个库，而咱们上面的那个库的工做明显是一个调用的过程。那猜想一下另一个库的做用会不会是生成的做用呢？

annotationProcessor 'com.jakewharton:butterknife-compiler:10.2.1'
复制代码

这里咱们要经历一个测试，他是经过ButterKinife.bind(this);触发的仍是@BindView这一类的注解来进行触发的？ 测试以后，可以发现ButterKinife.bind(this);删除，对咱们的使用彻底没有影响，可是删去所有的@BindView的注解后，文件没了！！！ 这也就说明了文件生成的触发的方式来自于了注解。而注解所在的包的位置正是库com.jakewharton:butterknife-compiler中。可是究竟是哪一个文件呢？咱们只好一个个看过去了。

文件也很少，那咱们能够一个个看了。首先咱们要明确一个目标，固然这是个人一个猜想，他应该要对注解进行一个收集，而后再进行一个源码的生成，并且这个文件中，可能会出现几个以下的特征： （1）输出的时候会出现一个后缀"_ViewBinding"。 （2）文件路径应该会出现对咱们本身的包一个名字获取，也就是获取包名/getPackageName()等获取函数。 （3）编译时就要调用的一个注解

在ButterKnifeProcessor中咱们发现了一个注解@AutoService(Processor.class)说明了这个文件，而这个注解就是为了编译时进行加载的，那咱们也就找到了咱们的目标了。

• init()函数是他的一个入口。

@Override public synchronized void init(ProcessingEnvironment env) {
    super.init(env);

    String sdk = env.getOptions().get(OPTION_SDK_INT);
    if (sdk != null) {
      try {
        this.sdk = Integer.parseInt(sdk);
      } catch (NumberFormatException e) {
        env.getMessager()
            .printMessage(Kind.WARNING, "Unable to parse supplied minSdk option '"
                + sdk
                + "'. Falling back to API 1 support.");
      }
    }

    debuggable = !"false".equals(env.getOptions().get(OPTION_DEBUGGABLE));

    typeUtils = env.getTypeUtils();
    filer = env.getFiler();
    try {
      trees = Trees.instance(processingEnv);
    } catch (IllegalArgumentException ignored) {
    }
  }
复制代码

• process()函数是一个执行过程，主要就是一个文件的输出。

@Override public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
    // 调用一些parseXXX的函数，来获取注解并生成相对应的数据
    Map<TypeElement, BindingSet> bindingMap = findAndParseTargets(env);

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

      // 这个文件中会出现相对应的文件操做方式
      // 好比上述的一些猜想_ViewBinding后缀的文件建立
      // 获取包名等一系列操做了。
      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;
  }
复制代码

那这里咱们也就彻底的解释清楚了文件是怎么进行生成的。具体的生成过程仍是须要去查看butterknife.compiler包下的BindingSet文件。

总结

在这里就能解决咱们的思考的问题了，其实文章中已经解决了大部分的问题，剩下最后一个反射的问题，在这里作一个解答。

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;
    }
    // 。。。。经过反射机制建立。
    BINDINGS.put(cls, bindingCtor);
    return bindingCtor;
}
复制代码

这是ButterKnife中一段代码，贴出他的意思很明确，其实就是为了说明会出现反射机制，对性能也确实有必定的消耗，可是这种消耗并不大，由于他作了一个缓冲的机制，也就保障咱们的性能仍是可以作到较大的缓存的。从编码效率提升的角度来看，这种性能代价并不大。

以上就是个人学习成果，若是有什么我没有思考到的地方或是文章内存在错误，欢迎与我分享。

---

相关文章推荐：

手撕OkHttp

手撕AsyncTask

HandlerThread那些事儿

手撕Handler