探究 ButterKnife 的注解处理以及代码生成

野性酷女 2022-06-09 11:44 143阅读 0赞

## ButterKnife ##

ButterKnife 是一个常用的第三方库，它在编译期间，使用注解处理器解析注解，并生成样板代码，从而达到给 Android views 绑定的效果，从而简化了我们写的一些样板代码。

为了了解 ButterKnife 的原理，我自己模仿写了一个库，几乎可以以假乱真，当然，这个库只有学习参考的价值。

既然是模仿，先看下 ButterKnife 使用 @BindString 注解的例子。

首先，参照 github 上 ButterKnife 的 README，添加依赖

compile 'com.jakewharton:butterknife:8.8.1'
        annotationProcessor 'com.jakewharton:butterknife-compiler:8.8.1'

有没有想过，为何要添加2个库，并且添加库的方式还不一样？这个问题后面会给出解释。

在 MainActivity 中使用 @BindString

public class MainActivity extends AppCompatActivity { 
    
        @BindString(R.string.app_name)
        String mAppName;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            // 用 ButterKnife 绑定 Activity
            ButterKnife.bind(this);
        }
    }

代码中，`@BindString(R.string.app_name)` 其实只是为了在编译期间生成样板代码，而真正的为 mAppName 赋值的其实是 `ButterKnife.bind(this)` 完成的，所以这两步缺一不可。

那么，现在不要急着运行项目，先编译一下，也就是 Android Studio 中的 Build -> Rebuild Project，编译完成后会生成一个 MainActivity\_ViewBinding 的类，路径为 app\\build\\generated\\source\\apt\\debug\\ ，如下图

![这里写图片描述][SouthEast]  
那么，在看看这个生成的代码

// Generated code from Butter Knife. Do not modify!
    package com.ckt.customandroidannotation;
    
    import android.content.Context;
    import android.content.res.Resources;
    import android.support.annotation.CallSuper;
    import android.support.annotation.UiThread;
    import android.view.View;
    import butterknife.Unbinder;
    import java.lang.Deprecated;
    import java.lang.Override;
    
    public class MainActivity_ViewBinding implements Unbinder { 
      @UiThread
      public MainActivity_ViewBinding(MainActivity target) {
        this(target, target);
      }
    
      @UiThread
      public MainActivity_ViewBinding(MainActivity target, Context context) {
        Resources res = context.getResources();
        target.mAppName = res.getString(R.string.app_name);
      }
    
    }

这个代码我精简过，而且这个类简直毫无PS痕迹，这明明就是 Android Project 中的创建的一个 Java 类。

Now，你是否按耐不住内中的冲动，想要搞清楚这他妈的代码是怎么生成的，FOLLOW ME ~

## 注解处理以及代码生成 ##

注解处理器(Annotation Processor)，是在编译期间处理注解的，所以它并不影响程序的性能。在普通的 Java Project 中可以很轻松的自定义一个注解处理器，但是在 Android Project，并不能为 JavaCompiler 定义一个注解处理器，但是 Android Project 可以引用一个 Java Project 作为 library，从而使用整个 library 中的自定义注解处理器来编译代码。

为了更好的理解原理，首先看下项目的结构，如下图  
![这里写图片描述][SouthEast 1]

图中，android-annotation 和 android-compiler 为 Java Library ，mybutterknife 为 Android Library，app 为 Android Project.

首先创建一个 android-annotation 的 Java Library，用来自定义注解，可能有人不知道怎么创建 Java Library，所以我用2个图来表示创建过程，后面创建 android-compiler 的 Java Library 也是一样。

![这里写图片描述][SouthEast 2]

![这里写图片描述][SouthEast 3]

现在，在 android-annotation 中创建一个自定义的注解，搞直接点，就叫做 BindString

@Target(ElementType.FIELD)
    @Retention(RetentionPolicy.CLASS)
    public @interface BindString {
        int value();
    }

如代码所示，BindString 这个注解的目标是 FIELD，也就是成员变量，这个注解可以在 CLASS 文件中保留，当然也可以改为在只在源码中保留，因为这并不影响在编译时期获取注解。

现在，再来创建一个名为 android-compiler 的 Java Library，并在这个库中添加一个注解处理器的实现类，由于注解处理器要指定处理哪个注解，因此，android-compiler 要把 android-annotation 作为库引入进来。

那么，在 android-compiler 的 build.gradle 中引入

dependencies {
        compile fileTree(include: ['*.jar'], dir: 'libs')
        compile project(':android-annotation')
    }

当然，你也可以在 android-compiler 这个项目上，按 F4，然后通过添加 Module Dependency 把 android-annotation 添加进来。

现在，通过继承 AbstractProcessor 来自定义一个注解处理器

public class BindViewProcessor extends AbstractProcessor { 
        @Override
        public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
            return false;
        }
    }

process() 方法，是必须要重写的方法，另外一般还要重写三个方法

1.  init()，做初始化操作，用来获取一些辅助类，用来解析注解，创建文件等等。
2.  SupportedAnnotationTypes()，提供需要解析的注解的 Class。
3.  SupportedSourceVersion()，提供所支持的版本。

而 SupportedAnnotationTypes() 和 SupportedSourceVersion() 方法在 jdk 1.7 后，可以通过注解的方式来替代。

@SupportedAnnotationTypes("com.example.BindString")
    @SupportedSourceVersion(SourceVersion.RELEASE_7)
    public class BindViewProcessor extends AbstractProcessor { 
    
        // 用于解析 Element
        private Elements mElementUtils;
        // 用于创建文件
        private Filer mFiler;
    
        @Override
        public synchronized void init(ProcessingEnvironment processingEnvironment) {
            mElementUtils = processingEnvironment.getElementUtils();
            mFiler = processingEnvironment.getFiler();
        }
    
        @Override
        public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
            for (Element element : roundEnvironment.getElementsAnnotatedWith(BindString.class)) {
                // 如果注解不是应用在成员上，就过滤
                if (element.getKind() != ElementKind.FIELD) {
                    continue;
                }
                // 获取注解所在类的 Element
                Element enclosingElement = element.getEnclosingElement();
                // 获取注解所在类的 Name
                Name enclosingElementName = enclosingElement.getSimpleName();
                // 生成类的名字
                String clsName = enclosingElementName.toString() + "_BindString";
    
                // 获取成员变量的名字
                String fieldName = element.getSimpleName().toString();
                int value = element.getAnnotation(BindString.class).value();
    
                // 获取包的 Element
                PackageElement packageName = mElementUtils.getPackageOf(element);
    
                // 创建要生成的代码的字符串
                String content = getContentFromJava(value);
    
                try {
                    // 创建文件
                    JavaFileObject javaFileObject = mFiler.createSourceFile(packageName + "." + clsName);
                    Writer writer = javaFileObject.openWriter();
                    // 把内容写入到文件中
                    writer.write(content);
                    writer.flush();
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return true;
        }
    
        private String getContentFromJava(int id){
            StringBuilder sb = new StringBuilder();
            sb.append("package com.ckt.custombutterknife;\n\n");
            sb.append("import android.content.res.Resources;\n\n");
            sb.append("public class MainActivity_BindString {\n\n");
            sb.append("public MainActivity_BindString(MainActivity target) {\n");
            sb.append(" Resources res = target.getResources();\n");
            sb.append(" target.mAppName = res.getString(").append(id).append(");\n");
            sb.append("}\n");
            sb.append("}");
            return sb.toString();
        }    
    }

getContentFromJava() 方法是用 StringBuilder 来创建生成的代码字符串，然而，这种方式实在是违背了程序员的“懒惰”精神，那么可以使用 Square 公司开源的 JavaPoet 库，在 build.gradle 中引入

dependencies {
        compile fileTree(include: ['*.jar'], dir: 'libs')
        compile project(':android-annotation')
        compile 'com.squareup:javapoet:1.9.0'
    }

那么现在用 JavaPoet 库来创建样板代码

private String getContentFromJavaPoet(Name enclosingElementName, String clsName, String fieldName, int value, PackageElement packageName) {
            ClassName resource = ClassName.get("android.content.res", "Resources");
            ClassName mainActivity = ClassName.get(packageName.toString(), enclosingElementName.toString());
    
            MethodSpec constructor = MethodSpec.constructorBuilder()
                    .addModifiers(Modifier.PUBLIC)
                    .addParameter(mainActivity, "target")
                    .addStatement("$T res = target.getResources()", resource)
                    .addStatement("target.$L = res.getString($L)", fieldName, value)
                    .build();
    
            TypeSpec typeSpec = TypeSpec.classBuilder(clsName)
                    .addModifiers(Modifier.PUBLIC)
                    .addMethod(constructor)
                    .build();
    
            return JavaFile.builder(packageName.toString(), typeSpec).build().toString();
        }

这个代码就不多做解释了，有兴趣的朋友可以到 github 上看看 JavaPoet 的 wiki，里面有详细的使用教程。

Ok，到这了，一个自定义的注解处理器的类就完成了，但是 android-compiler 这个库还没有完成，因为 JavaComipler 还不知道怎么找到这个注解处理器呢，按照 Oracle 官方的做法，是需要手动创建包和文件，来指定注解处理器的路径，然而，这种机械化的操作可以由 Google 开源的 auto-service 库解决，因此在 build.gradle 中再次引入。

dependencies {
        compile fileTree(include: ['*.jar'], dir: 'libs')
        compile project(':android-annotation')
        compile 'com.squareup:javapoet:1.9.0'
        compile 'com.google.auto.service:auto-service:1.0-rc3'
    }

使用这个库就更简单了，直接给注解处理器的类加个注解就完了

@AutoService(Processor.class)
    @SupportedAnnotationTypes("com.example.BindString")
    @SupportedSourceVersion(SourceVersion.RELEASE_7)
    public class HelloProcessor extends AbstractProcessor { }

现在，JavaCompiler 就可以找到这个处理 BindString 注解的注解处理器了。

那么，现在 android-compiler 这个库就完成了，不过，你应该也想知道这个生成的类到底是什么样子吧？ 很简单，把 app 这个 Android Project 引入这2个 Java Library，然后使用 @BindString 注解(与例子中使用方法一样)，然后 rebuild 即可看到下面的代码

package com.ckt.custombutterknife;
    
    import android.content.res.Resources;
    
    public class MainActivity_BindString { 
    
    public MainActivity_BindString(MainActivity target) {
        Resources res = target.getResources();
        target.mAppName = res.getString(2131099681);
    }
    }

生成的代码很简单，就一个 Android Project 中普通的 Java 类以及一个构造方法，从构造方法中也可以看出，只要传递一个 MainActivity 对象，就可以给 MainActivity 的 mAppName 赋值了，那么在 rebuild 后，就可以直接在 MainActivity 中调用 `new MainActivity_BindString(this);` 就可以为 mAppName 赋值了。

然而，这有个很明显的缺陷，那就是要先编译，再自己手动创建对象，也就等于手动赋值了。而 ButterKnife 却不是这样做的，ButterKnife 创建一个 Android Library(build.gradle 中 compile ‘com.jakewharton:butterknife:8.8.1’)，通过传入的 Activity 对象，加载生成的类，通过反射获取生成类的构造函数，并创建了这个类的对象。 于是乎，Android Project 引用这个 Android Library，就可以在不用编译的情况下，也可以使用 `ButterKnife.bind(this);`，只是没有任何作用，一旦编译甚至运行后，这个代码就起作用了。

## 加载生成的代码 ##

在前面使用 ButterKnife 的例子中提到过, `ButterKnife.bind(this)` 为 mAppName 赋值，它的原理是加载生成的类，通过反射获取生成类的构造方法，然后创建这个类的对象。那么，我也来模仿下这个操作，创建一个名为 mybutterknife 的 Android Library，注意，不是 Java Library, 也不是 Android Project。具体步骤，如下2个图所示

![这里写图片描述][SouthEast 4]

![这里写图片描述][SouthEast 5]

然后，在 mybutterknife 这个类中，创建一个 MyButterKnife 的 Java 类

public class MyButterKnife { public static void bind(Activity target) { // 获取 activity 的 Class 对象 Class<? extends Activity> targetCls = target.getClass(); // 获取 activity 的名字 String clsName = targetCls.getName(); try { // 通过 activity 的 ClassLoader 加载生成的类 Class<?> generatedCls = targetCls.getClassLoader().loadClass(clsName + "BindString"); // 找到构造方法 Constructor<?> constructor = generatedCls.getConstructor(targetCls); if (constructor != null) { // 创建对象 constructor.newInstance(target); } } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } } }

通过 Activiy 的 ClassLoader 加载了生成的类，通过反射获取了构造方法，然后创建了生成类的对象，从而达到了为 mAppName 赋值的目的。

## 使用注解 ##

在使用 ButterKnife 的例子中，加载了两个 ButterKnife 的库

compile 'com.jakewharton:butterknife:8.8.1'
        annotationProcessor 'com.jakewharton:butterknife-compiler:8.8.1'

butterknife，这个已经说过，是一个 Android Library，而 butterknife-compiler，我想你也猜到了吧，是注解处理器的 Java Library，而 annotationProcessor 的意思是，app 项目编译时候，使用 butterknife-compiler ，然而并不会合并到最终的 apk 中,这是一种优化处理。

ok，到现在为止，模仿的项目中已经创建了两个 Java Library，android-annotation 和 android-compiler，一个 Android Library，mybutterknife，那么按照 ButterKnife 添加依赖库的方式，添加我们自己创建的依赖库

compile project(':mybutterknife')
        annotationProcessor project(':android-compiler')

很明显，如果想要在 Activity 中使用自定义注解 @BindString，还需要把 android-annotation 加进来，这个可以在 mybutterknife 的 build.gradle 中添加进来

dependencies {
        compile fileTree(include: ['*.jar'], dir: 'libs')
        androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
            exclude group: 'com.android.support', module: 'support-annotations'
        })
        compile 'com.android.support:appcompat-v7:26.+'
        testCompile 'junit:junit:4.12'
        // 添加自定义注解项目为依赖库
        compile project(':android-annotation')
    }

好的，到这里，app 项目就可以正常使用 @BindString 注解了

public class MainActivity extends AppCompatActivity { 
        @BindString(R.string.app_name)
        String mAppName;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            MyButterKnife.bind(this);
            System.out.println(mAppName);
        }
    }

与 ButterKnife 的使用方式完成一样，并且不需要预编译，也就是不需要先 rebuild，直接运行，mAppName 就可以被赋值。

## 总结 ##

本篇文章，抱着学习 ButterKnife 原理的心态，主要探究了注解处理的过程，代码生成的过程，并模仿 ButterKnife 做了一些优化。 当然，这篇文章只是抛砖引玉，想要了解更多，还是要深入研究下 ButterKnife 这个库。

## 参考链接 ##

[https://docs.oracle.com/javase/7/docs/api/javax/annotation/processing/Processor.html][https_docs.oracle.com_javase_7_docs_api_javax_annotation_processing_Processor.html]  
[https://docs.oracle.com/javase/7/docs/api/java/util/ServiceLoader.html][https_docs.oracle.com_javase_7_docs_api_java_util_ServiceLoader.html]

[https://medium.com/@iammert/annotation-processing-dont-repeat-yourself-generate-your-code-8425e60c6657][https_medium.com_iammert_annotation-processing-dont-repeat-yourself-generate-your-code-8425e60c6657]  
[https://stablekernel.com/the-10-step-guide-to-annotation-processing-in-android-studio/][https_stablekernel.com_the-10-step-guide-to-annotation-processing-in-android-studio]  
[http://www.jianshu.com/p/d7567258ae85][http_www.jianshu.com_p_d7567258ae85]

[https://github.com/square/javapoet][https_github.com_square_javapoet]

[SouthEast]: /images/20220609/707fbbc714284791a9a440a767444281.png
[SouthEast 1]: /images/20220609/ee5f5c26ccf24cfaae42cb973304bc12.png
[SouthEast 2]: /images/20220609/5703155df7964f63898b1e320f049f84.png
[SouthEast 3]: /images/20220609/533fdedd56044afab47288483f38d04c.png
[SouthEast 4]: /images/20220609/c7958ccb61bf479cb33004436dd60262.png
[SouthEast 5]: /images/20220609/897bd413286141638155a7604455e49f.png
[https_docs.oracle.com_javase_7_docs_api_javax_annotation_processing_Processor.html]: https://docs.oracle.com/javase/7/docs/api/javax/annotation/processing/Processor.html
[https_docs.oracle.com_javase_7_docs_api_java_util_ServiceLoader.html]: https://docs.oracle.com/javase/7/docs/api/java/util/ServiceLoader.html
[https_medium.com_iammert_annotation-processing-dont-repeat-yourself-generate-your-code-8425e60c6657]: https://medium.com/@iammert/annotation-processing-dont-repeat-yourself-generate-your-code-8425e60c6657
[https_stablekernel.com_the-10-step-guide-to-annotation-processing-in-android-studio]: https://stablekernel.com/the-10-step-guide-to-annotation-processing-in-android-studio/
[http_www.jianshu.com_p_d7567258ae85]: http://www.jianshu.com/p/d7567258ae85
[https_github.com_square_javapoet]: https://github.com/square/javapoet