X
admin

你对APT了解吗？

介绍

APT(Annotation Processing Tool)即注解处理器，是一种处理注解的工具，确切的说它是javac的一个工具，它用来在编译时扫描和处理注解。注解处理器以Java代码(或者编译过的字节码)作为输入，生成.java文件作为输出。 简单来说就是在编译期，通过注解生成.java文件。

作用

使用APT的优点就是方便、简单，可以少些很多重复的代码。

用过ButterKnife、Dagger、EventBus等注解框架的同学就能感受到，利用这些框架可以少些很多代码，只要写一些注解就可以了。 其实，他们不过是通过注解，生成了一些代码。通过对APT的学习，你就会发现，他们很强~~~

实现

说了这么多，动手试试

目标 通过APT实现一个功能，通过对View变量的注解，实现View的绑定（类似于ButterKnife中的@BindView）

（参考自这里）

创建项目 创建Android Module命名为app 创建Java library Module命名为 apt-annotation 创建Java library Module命名为 apt-processor 依赖 apt-annotation 创建Android library Module 命名为apt-library依赖 apt-annotation、auto-service

结构如下

功能主要分为三个部分

  • apt-annotation：自定义注解，存放@BindView

  • apt-processor：注解处理器，根据apt-annotation中的注解，在编译期生成xxxActivity_ViewBinding.java代码

  • apt-library：工具类，调用xxxActivity_ViewBinding.java中的方法，实现View的绑定。

关系如下

app？app不是功能代码，只是用来验证功能的~~~

1、apt-annotation（自定义注解）

创建注解类BindView

  1. @Retention(RetentionPolicy.CLASS)
  2. @Target(ElementType.FIELD)
  3. public @interface BindView {
  4.    int value();
  5. }
@Retention(RetentionPolicy.CLASS)：表示运行时注解 @Target(ElementType.FIELD)：表示注解范围为类成员（构造方法、方法、成员变量）
@Retention： 定义被保留的时间长短 RetentionPoicy.SOURCE、RetentionPoicy.CLASS、RetentionPoicy.RUNTIME @Target： 定义所修饰的对象范围 TYPE、FIELD、METHOD、PARAMETER、CONSTRUCTOR、LOCAL_VARIABLE等 详细内容
这里定义了运行时注解BindView，其中value()用于获取对应View的id。
2、apt-processor（注解处理器）
(重点部分)
在Module中添加依赖
  1. dependencies {
  2.     implementation 'com.google.auto.service:auto-service:1.0-rc2' 
  3.     implementation project(':apt-annotation')
  4. }
Android Studio升级到3.0以后，Gradle也随之升级到3.0。implementation替代了之前的compile
创建BindViewProcessor
  1. @AutoService(Processor.class)
  2. public class BindViewProcessor extends AbstractProcessor {
  4.    private Messager mMessager;
  5.    private Elements mElementUtils;
  6.    private Map<String, ClassCreatorProxy> mProxyMap = new HashMap<>();
  8.    @Override
  9.    public synchronized void init(ProcessingEnvironment processingEnv) {
  10.        super.init(processingEnv);
  11.         mMessager = processingEnv.getMessager();
  12.         mElementUtils = processingEnv.getElementUtils();
  13.    }
  15.    @Override
  16.    public Set<String> getSupportedAnnotationTypes() {
  17.        HashSet<String> supportTypes = new LinkedHashSet<>();
  18.         supportTypes.add(BindView.class.getCanonicalName());
  19.        return supportTypes;
  20.    }
  22.    @Override
  23.    public SourceVersion getSupportedSourceVersion() {
  24.        return SourceVersion.latestSupported();
  25.    }
  27.    @Override
  28.    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnv) {
  29.        //根据注解生成Java文件
  30.        return false;
  31.    }
  32. }
  • init：初始化。可以得到ProcessingEnviroment，ProcessingEnviroment提供很多有用的工具类Elements, Types 和 Filer
  • getSupportedAnnotationTypes：指定这个注解处理器是注册给哪个注解的，这里说明是注解BindView
  • getSupportedSourceVersion：指定使用的Java版本，通常这里返回SourceVersion.latestSupported()
  • process：可以在这里写扫描、评估和处理注解的代码，生成Java文件（process中的代码下面详细说明）
  1. @AutoService(Processor.class)
  2. public class BindViewProcessor extends AbstractProcessor {
  4.    private Messager mMessager;
  5.    private Elements mElementUtils;
  6.    private Map<String, ClassCreatorProxy> mProxyMap = new HashMap<>();
  8.    @Override
  9.    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
  10.         mMessager.printMessage(Diagnostic.Kind.NOTE, "processing...");
  11.         mProxyMap.clear();
  12.        //得到所有的注解
  13.        Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindView.class);
  14.        for (Element element : elements) {
  15.            VariableElement variableElement = (VariableElement) element;
  16.            TypeElement classElement = (TypeElement) variableElement.getEnclosingElement();
  17.            String fullClassName = classElement.getQualifiedName().toString();
  18.            ClassCreatorProxy proxy = mProxyMap.get(fullClassName);
  19.            if (proxy == null) {
  20.                 proxy = new ClassCreatorProxy(mElementUtils, classElement);
  21.                 mProxyMap.put(fullClassName, proxy);
  22.            }
  23.            BindView bindAnnotation = variableElement.getAnnotation(BindView.class);
  24.            int id = bindAnnotation.value();
  25.             proxy.putElement(id, variableElement);
  26.        }
  27.        //通过遍历mProxyMap，创建java文件
  28.        for (String key : mProxyMap.keySet()) {
  29.            ClassCreatorProxy proxyInfo = mProxyMap.get(key);
  30.            try {
  31.                 mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName());
  32.                JavaFileObject jfo = processingEnv.getFiler().createSourceFile(proxyInfo.getProxyClassFullName(), proxyInfo.getTypeElement());
  33.                Writer writer = jfo.openWriter();
  34.                 writer.write(proxyInfo.generateJavaCode());
  35.                 writer.flush();
  36.                 writer.close();
  37.            } catch (IOException e) {
  38.                 mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName() + "error");
  39.            }
  40.        }
  42.         mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ...");
  43.        return true;
  44.    }
  45. }
通过roundEnvironment.getElementsAnnotatedWith(BindView.class)得到所有注解elements，然后将elements的信息保存到mProxyMap中，最后通过mProxyMap创建对应的Java文件，其中mProxyMap是ClassCreatorProxy的Map集合。
ClassCreatorProxy是创建Java代码的代理类，如下：
  1. public class ClassCreatorProxy {
  2.    private String mBindingClassName;
  3.    private String mPackageName;
  4.    private TypeElement mTypeElement;
  5.    private Map<Integer, VariableElement> mVariableElementMap = new HashMap<>();
  7.    public ClassCreatorProxy(Elements elementUtils, TypeElement classElement) {
  8.        this.mTypeElement = classElement;
  9.        PackageElement packageElement = elementUtils.getPackageOf(mTypeElement);
  10.        String packageName = packageElement.getQualifiedName().toString();
  11.        String className = mTypeElement.getSimpleName().toString();
  12.        this.mPackageName = packageName;
  13.        this.mBindingClassName = className + "_ViewBinding";
  14.    }
  16.    public void putElement(int id, VariableElement element) {
  17.         mVariableElementMap.put(id, element);
  18.    }
  20.    /**
  21.      * 创建Java代码
  22.      * @return
  23.      */
  24.    public String generateJavaCode() {
  25.        StringBuilder builder = new StringBuilder();
  26.         builder.append("package ").append(mPackageName).append(";nn");
  27.         builder.append("import com.example.gavin.apt_library.*;n");
  28.         builder.append('n');
  29.         builder.append("public class ").append(mBindingClassName);
  30.         builder.append(" {n");
  32.         generateMethods(builder);
  33.         builder.append('n');
  34.         builder.append("}n");
  35.        return builder.toString();
  36.    }
  38.    /**
  39.      * 加入Method
  40.      * @param builder
  41.      */
  42.    private void generateMethods(StringBuilder builder) {
  43.         builder.append("public void bind(" + mTypeElement.getQualifiedName() + " host ) {n");
  44.        for (int id : mVariableElementMap.keySet()) {
  45.            VariableElement element = mVariableElementMap.get(id);
  46.            String name = element.getSimpleName().toString();
  47.            String type = element.asType().toString();
  48.             builder.append("host." + name).append(" = ");
  49.             builder.append("(" + type + ")(((android.app.Activity)host).findViewById( " + id + "));n");
  50.        }
  51.         builder.append("  }n");
  52.    }
  54.    public String getProxyClassFullName()
  55.    {
  56.        return mPackageName + "." + mBindingClassName;
  57.    }
  59.    public TypeElement getTypeElement()
  60.    {
  61.        return mTypeElement;
  62.    }
  63. }
上面的代码主要就是从Elements、TypeElement得到想要的一些信息，如package name、Activity名、变量类型、id等，通过StringBuilder一点一点拼出Java代码，每个对象分别代表一个对应的.java文件。
没想到吧！Java代码还可以这样写~~ 提前看下生成的代码（不大整齐，被我格式化了）
  1. public class MainActivity_ViewBinding {
  2.    public void bind(com.example.gavin.apttest.MainActivity host) {
  3.         host.mButton = (android.widget.Button) (((android.app.Activity) host).findViewById(2131165218));
  4.         host.mTextView = (android.widget.TextView) (((android.app.Activity) host).findViewById(2131165321));
  5.    }
  6. }
缺陷 通过StringBuilder的方式一点一点来拼写Java代码，不但繁琐还容易写错~~
更好的方案 通过javapoet可以更加简单得生成这样的Java代码。(后面会说到）
介绍下依赖库auto-service 在使用注解处理器需要先声明，步骤： 1、需要在 processors 库的 main 目录下新建 resources 资源文件夹； 2、在 resources文件夹下建立 META-INF/services 目录文件夹； 3、在 META-INF/services 目录文件夹下创建 javax.annotation.processing.Processor 文件； 4、在 javax.annotation.processing.Processor 文件写入注解处理器的全称，包括包路径；） 这样声明下来也太麻烦了？这就是用引入auto-service的原因。 通过auto-service中的@AutoService可以自动生成AutoService注解处理器是Google开发的，用来生成 META-INF/services/javax.annotation.processing.Processor 文件的
3、apt-library 工具类
完成了Processor的部分，基本快大功告成了。
在BindViewProcessor中创建了对应的xxxActivity_ViewBinding.java，我们改怎么调用？当然是反射啦！！！
在Module的build.gradle中添加依赖
  1. dependencies {
  2.     implementation project(':apt-annotation')
  3. }
创建注解工具类BindViewTools
  1. public class BindViewTools {
  3.    public static void bind(Activity activity) {
  5.        Class clazz = activity.getClass();
  6.        try {
  7.            Class bindViewClass = Class.forName(clazz.getName() + "_ViewBinding");
  8.            Method method = bindViewClass.getMethod("bind", activity.getClass());
  9.             method.invoke(bindViewClass.newInstance(), activity);
  10.        } catch (ClassNotFoundException e) {
  11.             e.printStackTrace();
  12.        } catch (IllegalAccessException e) {
  13.             e.printStackTrace();
  14.        } catch (InstantiationException e) {
  15.             e.printStackTrace();
  16.        } catch (NoSuchMethodException e) {
  17.             e.printStackTrace();
  18.        } catch (InvocationTargetException e) {
  19.             e.printStackTrace();
  20.        }
  21.    }
  22. }
apt-library的部分就比较简单了，通过反射找到对应的ViewBinding类，然后调用其中的bind()方法完成View的绑定。
到目前为止，所有相关的代码都写完了，终于可以拿出来溜溜了
4、app
依赖 在Module的 build.gradle中（Gradle>=2.2）
  1. dependencies {
  2.     implementation project(':apt-annotation')
  3.     implementation project(':apt-library')
  4.     annotationProcessor project(':apt-processor')
  5. }
Android Gradle 插件 2.2 版本的发布，Android Gradle 插件提供了名为 annotationProcessor的功能来完全代替 android-apt
（若Gradle<2.2） 在Project的 build.gradle中：
  1. buildscript {
  2.     dependencies {
  3.         classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' 
  4.    }
  5. }
在Module的buile.gradle中：
  1. apply plugin: 'com.android.application'
  2. apply plugin: 'com.neenbedankt.android-apt'
  3. dependencies {
  4.     apt project(':apt-processor')
  5. }
使用 在MainActivity中，在View的前面加上BindView注解，把id传入即可
  1. public class MainActivity extends AppCompatActivity {
  3.    @BindView(R.id.tv)
  4.    TextView mTextView;
  5.    @BindView(R.id.btn)
  6.    Button mButton;
  8.    @Override
  9.    protected void onCreate(Bundle savedInstanceState) {
  10.        super.onCreate(savedInstanceState);
  11.         setContentView(R.layout.activity_main);
  12.        BindViewTools.bind(this);
  13.         mTextView.setText("bind TextView success");
  14.         mButton.setText("bind Button success");
  15.    }
  16. }
运行的结果想必大家都知道了，不够为了证明这个BindView的功能完成了，我还是把图贴出来
生成的代码
上面的功能一直在完成一件事情，那就是生成Java代码，那么生成的代码在哪？ 在app/build/generated/source/apt中可以找到生成的Java文件对应的代码（之前已经贴过了）：
  1. public class MainActivity_ViewBinding {
  2.    public void bind(com.example.gavin.apttest.MainActivity host) {
  3.         host.mButton = (android.widget.Button) (((android.app.Activity) host).findViewById(2131165218));
  4.         host.mTextView = (android.widget.TextView) (((android.app.Activity) host).findViewById(2131165321));
  5.    }
  6. }
通过javapoet生成代码
上面在ClassCreatorProxy中，通过StringBuilder来生成对应的Java代码。这种做法是比较麻烦的，还有一种更优雅的方式，那就是javapoet。
先添加依赖
  1. dependencies {
  2.     implementation 'com.squareup:javapoet:1.10.0'
  3. }
然后在ClassCreatorProxy中
  1. public class ClassCreatorProxy {
  2.    //省略部分代码...
  4.    /**
  5.      * 创建Java代码
  6.      * @return
  7.      */
  8.    public TypeSpec generateJavaCode2() {
  9.        TypeSpec bindingClass = TypeSpec.classBuilder(mBindingClassName)
  10.                .addModifiers(Modifier.PUBLIC)
  11.                .addMethod(generateMethods2())
  12.                .build();
  13.        return bindingClass;
  15.    }
  17.    /**
  18.      * 加入Method
  19.      */
  20.    private MethodSpec generateMethods2() {
  21.        ClassName host = ClassName.bestGuess(mTypeElement.getQualifiedName().toString());
  22.        MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("bind")
  23.                .addModifiers(Modifier.PUBLIC)
  24.                .returns(void.class)
  25.                .addParameter(host, "host");
  27.        for (int id : mVariableElementMap.keySet()) {
  28.            VariableElement element = mVariableElementMap.get(id);
  29.            String name = element.getSimpleName().toString();
  30.            String type = element.asType().toString();
  31.             methodBuilder.addCode("host." + name + " = " + "(" + type + ")(((android.app.Activity)host).findViewById( " + id + "));");
  32.        }
  33.        return methodBuilder.build();
  34.    }
  36.    public String getPackageName() {
  37.        return mPackageName;
  38.    }
  39. }
最后在 BindViewProcessor中
  1.    @Override
  2.    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
  3.        //省略部分代码...
  4.        //通过javapoet生成
  5.        for (String key : mProxyMap.keySet()) {
  6.            ClassCreatorProxy proxyInfo = mProxyMap.get(key);
  7.            JavaFile javaFile = JavaFile.builder(proxyInfo.getPackageName(), proxyInfo.generateJavaCode2()).build();
  8.            try {
  9.                //　生成文件
  10.                 javaFile.writeTo(processingEnv.getFiler());
  11.            } catch (IOException e) {
  12.                 e.printStackTrace();
  13.            }
  14.        }
  15.         mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ...");
  16.        return true;
  17.    }
相比用StringBuilder拼Java代码，明显简洁和很多。最后生成的代码跟之前是一样的，就不贴出来了。
https://github.com/Gavin-ZYX/APTTest

 
 本网站文章均为原创内容，并可随意转载，但请标明本文链接
如有任何疑问可在文章底部留言。为了防止恶意评论，本博客现已开启留言审核功能。但是博主会在后台第一时间看到您的留言，并会在第一时间对您的留言进行回复！欢迎交流！
本文链接: https://leetcode.jp/你对apt了解吗？/ 
 
   
  
   
 
 
 Categories:   Android 
 
 
 
   admin: 
 
 
      
  
   
  
  
 
 
 Leave a Comment 
 
 
 
 Related Post 
     
      
     
  1.  
     Android编程-深入探索Android卡顿优化 
     
    2.  
  2.  
     Android编程-经过一顿骚操作，项目编译打包速度提升一倍！ 
     
    3.  
  3.  
     Android编程-（建议精读）灵魂之力—提升学习效率 99% 的私藏秘籍全公开 
     
    4.