ButterKnife（8.4.0版本）原理分析

最新推荐文章于 2024-09-23 18:47:45 发布
最新推荐文章于 2024-09-23 18:47:45 发布
阅读量6.7k 收藏 5
点赞数 1
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/brycegao321/article/details/52863369
版权

        ButterKnife是鼎鼎大名的JakeWharton写的注解框架， 将你从findViewById这样无聊的体力活解脱出来。  github地址： https://github.com/JakeWharton/butterknife  ， 已超过1万颗星了，   很屌。

       JakeWharton是square公司的大咖，  是Piccaso（图片开源框架）、RxJava/RxAndroid(响应式编程）、OkHttp（Http通讯开源框架）的主要开发者。 不夸张的说， 对于一个做互联网app的码农来说， 如果不知道他就是少见识了。

       ButterKnife的集成方式和使用方法已在github上描述，    就不多说了。  8.4.0版本做了一些优化：

1、 删除了ButterKnife类的unbind方法。  改为保存ButterKnife.bind函数返回的Unbinder引用， 在onDestroy函数里调用Unbinder的unbind方法。 

2、如下图所示，在编译过程会生成*_ViewBinding.java,  如SimpleActivity_ViewBinding.java。

3、ButterKnife对性能没影响，  一些人说用了注解和反射影响性能， 这个锅ButterKnife不背。 增加Java方法数量和apk体积到是真的， 毕竟生成了_ViewBinding.java文件。


基础知识：APT(Annotation Processing Tool)是一种处理注释的工具,它对源代码文件进行检测找出其中的Annotation，使用Annotation进行额外的处理。 Annotation处理器在处理Annotation时可以根据源文件中的Annotation生成额外的源文件和其它的文件(文件具体内容由Annotation处理器的编写者决定), APT还会编译生成的源文件和原来的源文件，将它们一起生成class文件。


生成*_ViewBinding.java文件的原理：在编译时期，javac会调用java注解处理器（APT）进行处理，通过自定义注解处理器来实现想要的功能， 例如ButterKnife在编译期间生成Java文件。

 

下面看ButterKnife的核心代码ButterKnifeProcessor.java, 在Android编译期间

@AutoService(Processor.class)   //注册处理器，这样在编译时才会调用ButterKnifeProcessor
public final class ButterKnifeProcessor extends AbstractProcessor {
  ...
  //支持的监听器
 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 //
  );
  //支持注解的资源类型
  private static final List<String> SUPPORTED_TYPES = Arrays.asList(
      "array", "attr", "bool", "color", "dimen", "drawable", "id", "integer", "string"
  );
  ...   

  //指定使用的Java版本
  @Override public synchronized void init(ProcessingEnvironment env) {
    super.init(env);
    ...
  }

  //返回stirng类型的set集合，集合里包含了需要处理的注解</span></code>类型
  @Override public Set<String> getSupportedAnnotationTypes() {
    Set<String> types = new LinkedHashSet<>();
    for (Class<? extends Annotation> annotation : getSupportedAnnotations()) {
      types.add(annotation.getCanonicalName());
    }
    return types;
  }

  //支持的所有注解类型
  private Set<Class<? extends Annotation>> getSupportedAnnotations() {
    Set<Class<? extends Annotation>> annotations = new LinkedHashSet<>();

    annotations.add(BindArray.class);
    annotations.add(BindBitmap.class);
    annotations.add(BindBool.class);
    annotations.add(BindColor.class);
    annotations.add(BindDimen.class);
    annotations.add(BindDrawable.class);
    annotations.add(BindFloat.class);
    annotations.add(BindInt.class);
    annotations.add(BindString.class);
    annotations.add(BindView.class);
    annotations.add(BindViews.class);
    annotations.addAll(LISTENERS);

    return annotations;
  }

  //核心函数， 在这个函数里生成*_ViewBinding.java
  @Override public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
    //查找所有的注解信息，并形成BindingClass保存到 map中
   Map<TypeElement, BindingSet> bindingMap = findAndParseTargets(env); 

    //遍历bindingMap生成类名_ViewBinding的java文件
    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);
      } catch (IOException e) {
        error(typeElement, "Unable to write binding for type %s: %s", typeElement, e.getMessage());
      }
    }

    return true;
  }

  //解析所有的注解
  private Map<TypeElement, BindingSet> findAndParseTargets(RoundEnvironment env) {
    Map<TypeElement, BindingSet.Builder> builderMap = new LinkedHashMap<>();
    Set<TypeElement> erasedTargetNames = new LinkedHashSet<>();

    scanForRClasses(env);

    // Process each @BindArray element.
    for (Element element : env.getElementsAnnotatedWith(BindArray.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceArray(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindArray.class, e);
      }
    }

    // Process each @BindBitmap element.
    for (Element element : env.getElementsAnnotatedWith(BindBitmap.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceBitmap(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindBitmap.class, e);
      }
    }

    // Process each @BindBool element.
    for (Element element : env.getElementsAnnotatedWith(BindBool.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceBool(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindBool.class, e);
      }
    }

    // Process each @BindColor element.
    for (Element element : env.getElementsAnnotatedWith(BindColor.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceColor(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindColor.class, e);
      }
    }

    // Process each @BindDimen element.
    for (Element element : env.getElementsAnnotatedWith(BindDimen.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceDimen(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindDimen.class, e);
      }
    }

    // Process each @BindDrawable element.
    for (Element element : env.getElementsAnnotatedWith(BindDrawable.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceDrawable(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindDrawable.class, e);
      }
    }

    // Process each @BindFloat element.
    for (Element element : env.getElementsAnnotatedWith(BindFloat.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceFloat(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindFloat.class, e);
      }
    }

    // Process each @BindInt element.
    for (Element element : env.getElementsAnnotatedWith(BindInt.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceInt(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindInt.class, e);
      }
    }

    // Process each @BindString element.
    for (Element element : env.getElementsAnnotatedWith(BindString.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceString(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindString.class, e);
      }
    }

    // Process each @BindView element.
    for (Element element : env.getElementsAnnotatedWith(BindView.class)) {
      // we don't SuperficialValidation.validateElement(element)
      // so that an unresolved View type can be generated by later processing rounds
      try {
        parseBindView(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindView.class, e);
      }
    }

    // Process each @BindViews element.
    for (Element element : env.getElementsAnnotatedWith(BindViews.class)) {
      // we don't SuperficialValidation.validateElement(element)
      // so that an unresolved View type can be generated by later processing rounds
      try {
        parseBindViews(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindViews.class, e);
      }
    }

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

    // Associate superclass binders with their subclass binders. This is a queue-based tree walk
    // which starts at the roots (superclasses) and walks to the leafs (subclasses).
    Deque<Map.Entry<TypeElement, BindingSet.Builder>> entries =
        new ArrayDeque<>(builderMap.entrySet());
    Map<TypeElement, BindingSet> bindingMap = new LinkedHashMap<>();
    while (!entries.isEmpty()) {
      Map.Entry<TypeElement, BindingSet.Builder> entry = entries.removeFirst();

      TypeElement type = entry.getKey();
      BindingSet.Builder builder = entry.getValue();

      TypeElement parentType = findParentType(type, erasedTargetNames);
      if (parentType == null) {
        bindingMap.put(type, builder.build());
      } else {
        BindingSet parentBinding = bindingMap.get(parentType);
        if (parentBinding != null) {
          builder.setParent(parentBinding);
          bindingMap.put(type, builder.build());
        } else {
          // Has a superclass binding but we haven't built it yet. Re-enqueue for later.
          entries.addLast(entry);
        }
      }
    }

    return bindingMap;
  }
  ...
}

    下面看Java文件的生成方法： 

  JavaFile brewJava() {
  //参数1:包名
   //参数2:TypeSpec，这个可以生成class ，interface 等java文件
    //注意addFileComment的参数，已经说明是生成的代码了
   return JavaFile.builder(bindingClassName.packageName(), createBindingClass())
        .addFileComment("<span style="color:#FF0000;">Generated code from Butter Knife. Do not modify!</span>")
        .build();  }

bind：

如何才能生成的Java文件呢？

答案是： ButterKnife.bind(this);方法。


unbind：

在新版的8.4.0中去除了 unbind方法。

<span style="font-size:18px;">ButterKnife.unbind  //已经删除了</span>

并采用了接口的形式，让生成的类来实现释放引用。 例如：

<span style="font-size:18px;"> public final class SimpleAdapter$ViewHolder_ViewBinding implements Unbinder {
   @UiThread
  public SimpleAdapter$ViewHolder_ViewBinding(SimpleAdapter.ViewHolder target, View ) {
  //...
  }
 //...
  @Override
  public void unbind() {
  //...
  }
 ｝</span>

那如何unbind呢？ButterKnife.bind(this)返回值是一个Unbinder引用。
  所以可以这样：

<span style="font-size:18px;"> Unbinder mUnbinder;     
 @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.simple_activity);
     mUnbinder=ButterKnife.bind(this);  //保存引用
    ｝
      @Override
  protected void onDestroy() {
     super.onDestroy();
    mUnbinder.unbind();  //释放所有绑定的view
  }</span>

     综上， ButterKnife是个好东西，节省开发时间而且不影响性能。 是Android开发居家必备的良品。

butterknife 8.4.0 android studio 配置
浩宇碧海
08-29 1万+
android studio butterknife 8.4.0 使用
使用ButterKnife8.4.0的gradle配置
denghwen的博客
09-23 2657
刚开始用直接依赖了最新的，很happy的写完代码一运行，抛空指针，去官网上面按照官网照着弄也不行。抛android-apt can't find 巴拉巴拉。 最后才发现，我更新android studio2.2使用java8，使用了Jack编译，所以不用加 apply plugin: 'android-apt'这行的依赖。 然而我去掉这行依赖之后还是抛空指针。。。 最后把project g
butterknife 8.4.0
03-10
butterknife butterknife-annotations butterknife-compiler butterknife-gradle-plugin New: @BindFloat annotation for dimensions whose format is of type 'float'. See the annotation for more information. Generated constructors are now annotated with @UiThread and non-final, base classes unbind() methods are annotated with @CallSuper.
ButterKnife 原理及部分实现代码
weixin_33709609的博客
11-21 127
1.ButterKnife介绍 主要是解决掉 findViewById 和 setOnclick ,还包括资源的注入 ，编译时注解。 2. ButterKnife原理分析 主要采用编译时注解，就是用 apt 生成代码 3.注解处理器是什么？ 注解处理器是（Annotation Processor）是javac的一个工具，用来在编译 时扫描注解（Annotation）。 3.理解处理器Abstrac...
分分钟带你读懂-ButterKnife-的源码，深度解析跳槽从开始到结束完整流程
最新发布
2401_87545685的博客
09-23 826
如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。GitHub地址PS：我GitHub中有大量高阶Android学习视频资料和面试资料包~source");} else {// 添加 Context 类型的 context 参数如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。[外链图片转存中…(img-cNa6GgCk-1727088456733)]GitHub地址。
ButterKnife框架原理和使用
天行九歌
05-15 4159
大部分Android开发应该都知道@JakeWharton 大神的ButterKnife注解库，使用这个库我们可以不用写很多无聊的findViewById()和setOnClickListener()等代码 ButterKnife项目的主页在这里：http://jakewharton.github.io/butterknife/ 简单介绍一下使用方法：public class ExampleAct
ButterKnife原理
轻描时光
01-08 334
ButterKnife原理 ButterKnife对性能的影响很小，因为没有使用使用反射，而是使用的Annotation Processing Tool(APT),注解处理器，javac中用于编译时扫描和解析Java注解的工具。在编译阶段执行的，它的原理就是读入Java源代码，解析注解，然后生成新的Java代码。新生成的Java代码最后被编译成Java字节码，注解解析器不能改变读入的Java 类，...
Butterknife原理
weixin_39538641的博客
06-08 446
抛出问题:1.Butterknife是干什么的？2.我们如何去看Butterknife框架3.如果我们自己写一个类似Butterknife框架,我们如何去做?ButterKnife是一个专注于Android系统的View注入框架,可以减少大量的findViewById  以及 setOnClickListener代码，可视化一键生成。解决问题:2.首先我们要明白 butterknife-annot...
butterknife.rar
09-09
本文将深入探讨如何手写Butterknife，并分析其实现原理。 1. **Butterknife的基本使用** Butterknife通过注解的方式，让开发者可以在视图控件上直接声明其对应的Java字段，如`@BindView(R.id.button)`。编译时，...
ButterKnife 原理简单实现
09-18
了解了基本使用后，我们来看看ButterKnife的原理。ButterKnife的工作主要依赖于Java的注解处理器（Annotation Processor）。在项目编译期间，注解处理器会扫描源代码，找到所有`@BindView`和`@OnClick`等注解，然后...
ButterKnife 的工作原理
weixin_34361881的博客
12-13 104
使用 butterknife 很简单。 在 Activity 中只需在setContentView() 之后配置一句 ButterKnife.bind(this)，就可以省略繁琐的 findViewById 代码。可以推测它肯定是在内部帮我们处理然后生成了 findViewById 代码。它是如何生成的呢？ 使用反射是可以达到这个目的的，但是一定存在性能问题。Butterknife 使用的是 A...
butterknife实现原理
朴勇佑的专栏
02-05 267
butterknife实现原理
ButterKnife的使用和原理
weixin_43750332的博客
03-10 1万+
ButterKnife的使用和原理 参考文档： ButterKnife的使用：https://segmentfault.com/a/1190000016460847 ButterKnife的原理：https://juejin.cn/post/6844904181158019079 一、前言 ButterKnife是一个专注于Android系统的View注入框架,以前总是要写很多findViewById来找到View对象，有了ButterKnife可以很轻松的省去这些步骤。 使用ButterKnife对性能基
手撕黄油刀--探究ButterKnife实现原理
smily的博客
08-26 798
上篇文章我们提到属性动画中由一个setInterpolator(TimeInterpolator value)的方法，这个方法是为动画设置一个插值器，可以去控制动画的速率，那么本篇文章就承接属性动画继续探究属性动画插值器用法。 插值器的用法非常简单，系统给我们提供了setInterpolator(TimeInterpolator value)的方法，我们只需要传入一个插值器就可以了，我们来看一个......
4.ButterKnife(已停更)原理分析
lanxuan1993的博客
05-23 235
https://cloud.tencent.com/developer/article/1649920 1. 编写 ButterKnife框架 业界比较出名的基于完全注解方式就可以进行 UI 绑定和事件绑定，无需 findViewById 和setClickListener 等的IOC（Inverse Of Control 控制反转，就是将 UI 的初始化和事件绑定的“权利”交给框架来完成）框架有： ButterKnife使用如下： 会出现如下代码： @BindView(R.id..
傻瓜也可以看懂的——ButterKnife实现原理
m0_37218227的博客
11-15 354
       ButterKnife是一个专注于Android系统的View注入框架，以前总是要写很多findViewById来找到View对象，有了ButterKnife可以很轻松的省去这些步骤，目前使用很广。最重要的一点，使用ButterKnife对性能基本没有损失，因为ButterKnife用到的注解并不是在运行时反射的，而是在编译的时候生成新的class。项目集成起来也是特别方便，使用起来...
Android之Butterknife原理解析
热门推荐
顾林海
12-18 2万+
转载请标明出处:【顾林海的博客】 前言Butterknife是一个专注于Android系统的View注入框架，可以简化代码，比如findViewById、事件监听、资源绑定等，同时该框架使用了编译时注解，可能大家一听到编译时注解就认为这种方式会影响性能，其实编译时注解并不会影响应用的性能，这是因为编译时注解是在代码编译过程中对注解进行处理，生成代码，这些代码在运行时调用，除了编译时注解，还有一个是运
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值