ButterKnife源码初步探秘

butterknife使用很方便，在接入之后，在activity中使用ButterKnife.bind(this)即可

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

这里获取decorview后继续调用

  private static Unbinder createBinding(@NonNull Object target, @NonNull View source) {
    Class<?> targetClass = target.getClass();

    Constructor<? extends Unbinder> constructor = findBindingConstructorForClass(targetClass);

    try {
      return constructor.newInstance(target, source);
    }
  }

先获取构造器，然后构建实例

  private static Constructor<? extends Unbinder> findBindingConstructorForClass(Class<?> cls) {
    Constructor<? extends Unbinder> bindingCtor = BINDINGS.get(cls);

    String clsName = cls.getName();

    try {
      Class<?> bindingClass = cls.getClassLoader().loadClass(clsName + "_ViewBinding");
      //noinspection unchecked
      bindingCtor = (Constructor<? extends Unbinder>) bindingClass.getConstructor(cls, View.class);
    } 
    BINDINGS.put(cls, bindingCtor);
    return bindingCtor;
  }

以SimpleActivity为例，会首先创建一个新的类SimpleActivity_ViewBinding，然后获取它的构造器，构造器需要两个参数，这里对应的是Activity和View，如图

看到这里可能有些懵，因为似乎没有其他处理了，那么@BindView()这些注解是如何起作用的呢？这时需要引入一个概念AbstractProcessor， 其中的process方法会在程序编译时执行。ButterKnife中该类为ButterKnifeProcessor，所在包是butterknife.compiler。在一个项目中引用butterknife时并不会下载该包，所以如果需要查看代码，需要下载butterknife的工程https://github.com/JakeWharton/butterknife。先看看它的process方法

  @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);
      try {
        javaFile.writeTo(filer);
      } 
    }

    return false;
  }

大致的流程是，通过findAndParseTargets获取一个map，然后进行遍历，分别写入文件，所以主要分析
1、findAndParseTargets
2、JavaFile
首先分析1，代码很多，暂时只看其中一部分

  private Map<TypeElement, BindingSet> findAndParseTargets(RoundEnvironment env) {
      for (Element element : env.getElementsAnnotatedWith(BindView.class)) {
          try {
            parseBindView(element, builderMap, erasedTargetNames);
          } 
      }

首先分析对BindView注解的处理

  private void parseBindView(Element element, Map<TypeElement, BindingSet.Builder> builderMap,
      Set<TypeElement> erasedTargetNames) {
      TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();
      int id = element.getAnnotation(BindView.class).value();
      BindingSet.Builder builder = builderMap.get(enclosingElement);
      builder = getOrCreateBindingBuilder(builderMap, enclosingElement);
      builder.addField(getId(qualifiedId), new FieldViewBinding(name, type, required));

这里，通过enclosingElement获取builder，并存入builderMap

builder = BindingSet.newBuilder(enclosingElement);

newBuilder()的执行，无非就是通过一些参数构建Builder

  static Builder newBuilder(TypeElement enclosingElement) {
    TypeMirror typeMirror = enclosingElement.asType();

    TypeName targetType = TypeName.get(typeMirror);
    if (targetType instanceof ParameterizedTypeName) {
      targetType = ((ParameterizedTypeName) targetType).rawType;
    }

    String packageName = getPackage(enclosingElement).getQualifiedName().toString();
    String className = enclosingElement.getQualifiedName().toString().substring(
        packageName.length() + 1).replace('.', '$');
    ClassName bindingClassName = ClassName.get(packageName, className + "_ViewBinding");

    boolean isFinal = enclosingElement.getModifiers().contains(Modifier.FINAL);
    return new Builder(targetType, bindingClassName, isFinal, isView, isActivity, isDialog);
  }

构建完成后，会调用addField()方法

    void addField(Id id, FieldViewBinding binding) {
      getOrCreateViewBindings(id).setFieldBinding(binding);
    }

到此看出，每个BindView()对应一个BindingSet.Builder，并存入builderMap中，我们先不看关于listener的处理，先走一遍流程，看看如何生成bindview对应的代码，所以回到开始

  @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);
      try {
        javaFile.writeTo(filer);
      } 
    }

    return false;
  }

在获取buildmap后，通过每一个BindingSet的brewJava方法创建JavaFile

  JavaFile brewJava(int sdk) {
    return JavaFile.builder(bindingClassName.packageName(), createType(sdk))
        .addFileComment("Generated code from Butter Knife. Do not modify!")
        .build();
  }

这里涉及一个开源项目JavaPoet，用于自动生成代码，建议了解其用法后再继续看下去，先看看createType(sdk)如何实现

  private TypeSpec createType(int sdk) {
    //首先根据bindingClassName.simpleName()创建一个类
    TypeSpec.Builder result = TypeSpec.classBuilder(bindingClassName.simpleName())
        .addModifiers(PUBLIC);
    //创建一个私有的变量target,类型对应，如SimpleActivity_ViewBinding这里就是SimpleActivity
    if (hasTargetField()) {
      result.addField(targetTypeName, "target", PRIVATE);
    }
    //接下来，根据bind()处的类型创建构造器
    if (isView) {
      result.addMethod(createBindingConstructorForView());
    } else if (isActivity) {
      result.addMethod(createBindingConstructorForActivity());
    } else if (isDialog) {
      result.addMethod(createBindingConstructorForDialog());
    }
    //再创建一个包含view的构造器
    result.addMethod(createBindingConstructor(sdk));
    //创建一个unbind方法
    if (hasViewBindings() || parentBinding == null) {
      result.addMethod(createBindingUnbindMethod(result));
    }

    return result.build();
  }

对应activity的构造器如下

  private MethodSpec createBindingConstructorForActivity() {
    MethodSpec.Builder builder = MethodSpec.constructorBuilder()
        .addAnnotation(UI_THREAD)
        .addModifiers(PUBLIC)
        .addParameter(targetTypeName, "target");
    if (constructorNeedsView()) {
      builder.addStatement("this(target, target.getWindow().getDecorView())");
    } else {
      builder.addStatement("this(target, target)");
    }
    return builder.build();
  }

所以，生成类的大致结构如下

看到这里不禁发问，那么构造器里的代码，也就是一些findview是如何实现的呢？其实就是在createBindingConstructor(sdk)中实现的，先上张图

  private MethodSpec createBindingConstructor(int sdk) {
    //创建一个public类型带有注解UiThread的方法
    MethodSpec.Builder constructor = MethodSpec.constructorBuilder()
        .addAnnotation(UI_THREAD)
        .addModifiers(PUBLIC);
    //第一个变量是target
    if (hasMethodBindings()) {
      constructor.addParameter(targetTypeName, "target", FINAL);
    } else {
      constructor.addParameter(targetTypeName, "target");
    }
    //第二个变量是source，类型是View
    if (constructorNeedsView()) {
      constructor.addParameter(VIEW, "source");
    } else {
      constructor.addParameter(CONTEXT, "context");
    }
    //如果有target，会生成this.target = target
    if (hasTargetField()) {
      constructor.addStatement("this.target = target");
      constructor.addCode("\n");
    }

    if (hasViewBindings()) {
      //这里，就会遍历每一个view，去进行findview
      for (ViewBinding binding : viewBindings) {
        addViewBinding(constructor, binding);
      }
    }
    //这里则是对资源的处理
    if (!resourceBindings.isEmpty()) {
      if (constructorNeedsView()) {
        constructor.addStatement("$T context = source.getContext()", CONTEXT);
      }
    }

    return constructor.build();
  }

继续看addViewBinding

  private void addViewBinding(MethodSpec.Builder result, ViewBinding binding) {
    List<MemberViewBinding> requiredBindings = binding.getRequiredBindings();
    if (!binding.isBoundToRoot()) {
      result.addStatement("view = $T.findRequiredView(source, $L, $S)", UTILS,
          binding.getId().code, asHumanDescription(requiredBindings));
    }

这里使用了一个帮助类Utils用于findview的操作，至此，生成view的流程算是跑通了。不过，我碰到了一个需求，在使用@OnClick的事件发生时，调用一段项目中收集点击事件的代码，那么该如何去修改butterknife的源码呢？一切在下一篇揭晓。