从学习使用注解处理器到理解ButterKnife原理

如果你还没有学习过注解，请先戳这里
在形形色色的框架中，使用注解来简化代码的框架有许多，从解放findViewById的ButterKnife，到路由框架ARouter等等。这种符合声明式编程风格的框架，正越来越受欢迎。因此，有必要研究下他们的实现原理。
我们在声明一个注解的时候，有一个配置指明了注解的生命周期，如下

//三种可选
@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.CLASS)
@Retention(RetentionPolicy.RUNTIME)

• SOURCE 注解保留到源码期结束
• CLASS 注解保留到字节码期结束
• RUNTIME 注解保留到运行时

实际上，ButterKnife和ARouter都在编译时偷偷生成了新的java文件，这一点，平时使用的时候也会发现。那他们是如何生成的呢？这些新的java文件又有什么作用呢？

我们先研究下，这些文件是怎么生成的。

答案就是 注解处理器--Annotation Processor。

往往保留期到SOURCE和CLASS的注解，都是使用注解处理器来处理的。

Annotation Processor

Annotation Processor的中文是注解处理器，javac在编译源码时，会扫描java文件里用到注解的地方，然后交由注解处理器来处理这些注解。上面说到的文件，就是在这个时候生成的。

如何使用注解处理器

定义一个注解

首先创建一个java Module叫做annotationlib，插件类型为

apply plugin: 'java-library'

这里一定要使用java-library吗？可以直接在app中加入相关代码吗？我试了下，首先，javax的包，在app中默认没有引入，需要手动引入，引入后虽然在编译时不会报错，但是在构建app的时候还是会报错。所以，还是新建一个java module吧。

在java Module中添加一个注解。新建一个java文件BindView.java，添加以下代码：

@Retention(RetentionPolicy.SOURCE)//注解在编译后不会保留
@Target(ElementType.FIELD)//注解的对象是属性
public @interface BindView {
    int value() default -1;//注解支持int型参数
}

使用注解

注解定义好之后，我们可以在app中使用，类似于ButterKnife

public class MainActivity extends AppCompatActivity {
    @BindView(R.id.textView)
    private TextView textView;

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

处理注解

在上面的代码中使用注解后，不会有任何效果。因为我们还没有对注解进行任何处理。想要处理注解，我们需要定义一个注解处理器。javac在编译时会调用这个注解处理器，处理代码中的注解。
新建一个module，叫做compiler。gradle配置如下

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    //用于注册注解处理器的库
    implementation 'com.google.auto.service:auto-service:1.0-rc4'
    //用于生产java类的库
    implementation 'com.squareup:javapoet:1.11.1'
    //依赖定义的注解
    implementation project(':annotationlib')
}

sourceCompatibility = "7"
targetCompatibility = "7"

定义注解处理器的方法如下：

1.继承抽象类AbstractProcessor

2.添加注解@AutoService(Processor.class)，用于注册注解处理器。利用到了上面依赖的auto-service这个库。

@AutoService(Processor.class)//简单点理解，就是注册这个处理器，只有加了这个注解，javac在编译时才会调用这个处理器
public class MyProcessor extends AbstractProcessor {

    private Messager mMessager;

    //初始化方法，从传入的参数，可以获取到一些工具类。
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        mMessager = processingEnvironment.getMessager();
    }

    //指定我们这个处理器支持的注解类型。这里添加了BindView这个注解。如果不添加，不会调用process
    @Override
    public Set getSupportedAnnotationTypes() {
        Set annotations = new LinkedHashSet<>();
        annotations.add(BindView.class.getCanonicalName());
        return annotations;
    }

    //支持的java版本，通常返回最新的就可以了。实测，如果不填，会使用RELEASE_6,然后提示支持的版本低于编译的版本，但是还是会编译成功。
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    //这里是处理注解的重点部分，注解的信息会通过RoundEnviroment传入。然后使用从init获取到的一些工具，就可以获取到注解的具体信息。如何处理信息就看我们的具体需求了。
    @Override
    public boolean process(Set set, RoundEnvironment roundEnvironment) {
        Set bindViewElements = roundEnvironment.getElementsAnnotatedWith(BindView.class);
        for (Element element : bindViewElements) {
            BindView bindView = element.getAnnotation(BindView.class);
            int value = bindView.value();
            //下面生成java文件的方法依赖于三方库javapoet。会在指定包名下生成一个java文件。
            MethodSpec main = MethodSpec.methodBuilder("main")
                    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                    .addParameter(String[].class, "args")
                    .addStatement("$T.out.println($S)", System.class, element.getSimpleName() + "id is " + value)
                    .build();
            TypeSpec typeSpec = TypeSpec.classBuilder("HelloWorld")
                    .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
                    .addMethod(main)
                    .build();
            JavaFile file = JavaFile.builder("net.yc.test", typeSpec)
                    .build();
            try {
                file.writeTo(processingEnv.getFiler());
            } catch (IOException e) {
                e.printStackTrace();
            }
            return true;
        }
        return false;
    }
}

app的module依赖

  //必须使用annotationProcessor否则会编译失败
  annotationProcessor project(':compiler')
  //使用annotationProcessor后如果把注解放在compiler中，会无法依赖到注解
  implementation project(':annotationlib')

总结

以上我们就实现了自己编写一个注解处理器，在编译时动态生成一个java文件。文件可以在项目目录/app/build/generated/source/apt/debug/下查看。

在注解处理器的process方法回调中，我们获取到注解的信息，然后就可以做各种各样的自定义操作了。

---

ButterKnife的原理探究

ButterKnife最简单的使用方法

step 1

在Activity中调用绑定方法:

ButterKnife.bind(this);

关键作用：

1.定位绑定的类

2.获取最底层的View

step 2

使用注解注解一个View

@BindView(R.id.rl_finish)
RelativeLayout rl_finish;

在编译成功后，会发现

/app/build/generated/source/apt/xxxxx/debug/包名/activity/ViewHistoryActivity_ViewBinding.java
多了这样的一个文件。这个文件是ButterKnifeProcessor在编译时动态生成的。

文件中的关键方法是构造方法，在这个方法中对view进行了findViewById的初始化。

  @UiThread
  public ViewHistoryActivity_ViewBinding(ViewHistoryActivity target, View source) {
    this.target = target;

    target.rl_finish = Utils.findRequiredViewAsType(source, R.id.rl_finish, "field 'rl_finish'", 
  }

这里要理清的一件事是：

• 生成ViewBinding文件是在编译期
• ButterKnife.bind(this)是在运行期

也就是说，bind方法调用的时候，ViewBinding文件已经生成了。

理解了这一点后，再往下看

在bind方法的调用链中有一处是关键

Class bindingClass = cls.getClassLoader().loadClass(clsName + "_ViewBinding");

通过这个方法，加载了ViewBinding类。再往下就很好理解了，调用这个类的构造函数，把bind的时候获取到的对象和最底层view传递到viewBinding的构造方法中进行绑定。

ButterKnife的大致实现原理就是这样了，还有很多的细节就不谈了。

---

如果觉得我的文章对您有些作用的话，就麻烦点下喜欢吧~