Android组件化系列之编译期注解手写注解、注解处理器、及注解工作流程

前言

为了熟悉组件化通信内部的实现原理,最终完成手写组件化通信,今天我们就需要了解注解、注解处理器他们是如何工作的,因为组件化通信就是利用注解和注解处理器帮助我们完成路由表、路由信息等代码的生成工作。简单说,注解就是一个标记,用来告诉注解处理器凡是用我这个注解标记过的类/属性/方法,这些地方是需要你来帮我做一些事情的,例如生成一些代码。举个通俗的例子,例如流水线上有一些残次品的手机,这时我可以给这些有着不同缺陷的手机分别贴上标签(注解),有的贴上屏幕划伤的标签、有的贴上无法开机的标签、有的贴上手机异常发热的标签等等各类标签(注解),那么我们工程师(注解处理器)就可以针对这些不同的标签,做一些特殊处理、加工。

参考博客:https://www.jianshu.com/p/7af58e8e3e18

https://blog.csdn.net/binbinqq86/article/details/79610980

介绍

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

注解的特性

  • 注解方法不能带有参数;

  • 注解方法返回值类型限定为:基本类型、String、Enums、Annotation或者是这些类型的数组;

  • 注解方法可以有默认值;

  • 注解本身能够包含元注解,元注解被用来注解其它注解。

作用

使用APT的优点就是方便、简单,可以少写很多重复的代码。用过ButterKnife、Dagger、EventBus等注解框架的同学就能感受到,利用这些框架可以少写很多代码,只要写一些注解就可以了。其实,他们不过是通过注解,生成了一些代码。

目标

通过APT实现一个功能,通过对View变量的注解,实现View的绑定(类似于ButterKnife中的@BindView)

创建项目

  • 创建Android Module命名为app 依赖 下面三个module

  • 创建Java library Module命名为 module_annotation

  • 创建Java library Module命名为 module_processor

  • 创建Android library Module 命名为module_library依赖 module_annotation、auto-service

结构如下

Android组件化系列之编译期注解手写注解、注解处理器、及注解工作流程_第1张图片

功能主要分为三个部分

  • module_annotation:自定义注解,存放@BindView

  • module_processor:注解处理器,根据module_annotation中的注解,在编译期生成xxxActivity_ViewBinding.java代码

  • module_library:工具类,调用xxxActivity_ViewBinding.java中的方法,实现View的绑定。

关系如下

Android组件化系列之编译期注解手写注解、注解处理器、及注解工作流程_第2张图片

一:module_annotation -- 自定义注解

  • 创建注解类BindView
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface BindView {
    int value();
}
  • @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。

二:module_processor -- 注解处理器 (重点部分)

(1)在Module中添加依赖

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.google.auto.service:auto-service:1.0-rc6'
    annotationProcessor 'com.google.auto.service:auto-service:1.0-rc6'
    implementation 'com.squareup:javapoet:1.10.0'
    implementation project(':module_annotation')
}

auto-service库可以帮我们去生成META-INF等信息。这里重点说明下,需要手动引入annotationProcessor,否则高版本的gradle无法生成META-INF文件,具体可看这篇文章

介绍下依赖库auto-service

在使用注解处理器需要先声明,步骤:

  • 需要在 processors 库的 main 目录下新建 resources 资源文件夹;

  • 在 resources文件夹下建立 META-INF/services 目录文件夹;

  • 在 META-INF/services 目录文件夹下创建 javax.annotation.processing.Processor 文件;

  • 在 javax.annotation.processing.Processor 文件写入注解处理器的全称,包括包路径;

这样声明下来也太麻烦了?这就是用引入auto-service的原因。

通过auto-service中的@AutoService可以自动生成AutoService注解处理器是Google开发的,用来生成 META-INF/services/javax.annotation.processing.Processor 文件

(2)创建BindViewProcessor

下面来看具体注解处理器怎么去写,首先就是要继承AbstractProcessor,在类的顶部加入注解:@AutoService(Processor.class),主要是用来自动生成 META-INF 信息。然后覆盖其中的几个方法,分别是:

  • public synchronized void init(ProcessingEnvironment processingEnvironment)
  • public SourceVersion getSupportedSourceVersion()

  • public Set getSupportedAnnotationTypes()

  • public boolean process(Set set, RoundEnvironment roundEnvironment)

其中init方法用来初始化一些变量信息,如下:

  • Filer mFileUtils; 跟文件相关的辅助类,生成JavaSourceCode.

  • Elements mElementUtils; 跟元素相关的辅助类,帮助我们去获取一些元素相关的信息。

  • Messager mMessager; 跟日志相关的辅助类。

@AutoService(Processor.class)
public class BindViewProcessor extends AbstractProcessor {

    private Messager mMessager;
    private Elements mElementUtils;
    private Map mProxyMap = new HashMap<>();

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        mMessager = processingEnv.getMessager();
        mElementUtils = processingEnv.getElementUtils();
    }

    @Override
    public Set getSupportedAnnotationTypes() {
        HashSet supportTypes = new LinkedHashSet<>();
        supportTypes.add(BindView.class.getCanonicalName());
        return supportTypes;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    @Override
    public boolean process(Set set, RoundEnvironment roundEnv) {
        //根据注解生成Java文件
        return false;
    }
}
  • init:初始化。可以得到ProcessingEnviroment,ProcessingEnviroment提供很多有用的工具类Elements, Types 和 Filer

  • getSupportedAnnotationTypes:指定这个注解处理器是注册给哪个注解的,这里说明是注解BindView

  • getSupportedSourceVersion:指定使用的Java版本,通常这里返回SourceVersion.latestSupported()

  • process:可以在这里写扫描、评估和处理注解的代码,生成Java文件(process中的代码下面详细说明)

下面就是我们最后一个方法了,也是今天的主角,所有的注解处理都是在这里完成的。process方法的实现需要分为两个步骤走:

  • 需要生成的类的所有信息的收集

  • 根据收集的信息生成具体的java代码

(3)需要生成的类的所有信息的收集

@AutoService(Processor.class)
public class BindViewProcessor extends AbstractProcessor {

    private Messager mMessager;
    private Elements mElementUtils;
    private Map mProxyMap = new HashMap<>();

    @Override
    public boolean process(Set set, RoundEnvironment roundEnvironment) {
        mMessager.printMessage(Diagnostic.Kind.NOTE, "processing...");
        mProxyMap.clear();
        //得到所有的注解
        Set elements = roundEnvironment.getElementsAnnotatedWith(BindView.class);
        for (Element element : elements) {
            VariableElement variableElement = (VariableElement) element;
            TypeElement classElement = (TypeElement) variableElement.getEnclosingElement();
            String fullClassName = classElement.getQualifiedName().toString();
            ClassCreatorProxy proxy = mProxyMap.get(fullClassName);
            if (proxy == null) {
                proxy = new ClassCreatorProxy(mElementUtils, classElement);
                mProxyMap.put(fullClassName, proxy);
            }
            BindView bindAnnotation = variableElement.getAnnotation(BindView.class);
            int id = bindAnnotation.value();
            proxy.putElement(id, variableElement);
        }
        //通过遍历mProxyMap,创建java文件
        for (String key : mProxyMap.keySet()) {
            ClassCreatorProxy proxyInfo = mProxyMap.get(key);
            try {
                mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName());
                JavaFileObject jfo = processingEnv.getFiler().createSourceFile(proxyInfo.getProxyClassFullName(), proxyInfo.getTypeElement());
                Writer writer = jfo.openWriter();
                writer.write(proxyInfo.generateJavaCode());
                writer.flush();
                writer.close();
            } catch (IOException e) {
                mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName() + "error");
            }
        }

        mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ...");
        return true;
    }
}

通过roundEnvironment.getElementsAnnotatedWith(BindView.class)得到所有注解elements,然后将elements的信息保存到mProxyMap中,最后通过mProxyMap创建对应的Java文件,其中mProxyMap是ClassCreatorProxy的Map集合。

(4)根据收集的信息生成具体的java代码

生成java代码有两种方式 :1、StringBuilder拼接;2、使用JavaPoet库

  • ClassCreatorProxy是创建Java代码的代理类,使用string拼接的方式生成java代码如下:
public class ClassCreatorProxy {
    private String mBindingClassName;
    private String mPackageName;
    private TypeElement mTypeElement;
    private Map mVariableElementMap = new HashMap<>();

    public ClassCreatorProxy(Elements elementUtils, TypeElement classElement) {
        this.mTypeElement = classElement;
        PackageElement packageElement = elementUtils.getPackageOf(mTypeElement);
        String packageName = packageElement.getQualifiedName().toString();
        String className = mTypeElement.getSimpleName().toString();
        this.mPackageName = packageName;
        this.mBindingClassName = className + "_ViewBinding";
    }

    public void putElement(int id, VariableElement element) {
        mVariableElementMap.put(id, element);
    }

    /**
     * 创建Java代码
     * @return
     */
    public String generateJavaCode() {
        StringBuilder builder = new StringBuilder();
        builder.append("package ").append(mPackageName).append(";\n\n");
        builder.append("import com.example.gavin.apt_library.*;\n");
        builder.append('\n');
        builder.append("public class ").append(mBindingClassName);
        builder.append(" {\n");

        generateMethods(builder);
        builder.append('\n');
        builder.append("}\n");
        return builder.toString();
    }

    /**
     * 加入Method
     * @param builder
     */
    private void generateMethods(StringBuilder builder) {
        builder.append("public void bind(" + mTypeElement.getQualifiedName() + " host ) {\n");
        for (int id : mVariableElementMap.keySet()) {
            VariableElement element = mVariableElementMap.get(id);
            String name = element.getSimpleName().toString();
            String type = element.asType().toString();
            builder.append("host." + name).append(" = ");
            builder.append("(" + type + ")(((android.app.Activity)host).findViewById( " + id + "));\n");
        }
        builder.append("  }\n");
    }

    public String getProxyClassFullName()
    {
        return mPackageName + "." + mBindingClassName;
    }

    public TypeElement getTypeElement()
    {
        return mTypeElement;
    }
}

这里提一下Element这个类的几个子类:

  • TypeElement  代表类

  • VariableElement  代表变量

  • ExecutableElement  代表方法

上面的代码主要就是从Elements、TypeElement得到想要的一些信息,如package name、Activity名、变量类型、id等,通过StringBuilder一点一点拼出Java代码,每个对象分别代表一个对应的.java文件。

没想到吧!Java代码还可以这样写~~

提前看下生成的代码(不大整齐,被我格式化了)

public class ClassCreatorProxy {
public class MainActivity_ViewBinding {
    public void bind(com.example.gavin.apttest.MainActivity host) {
        host.mButton = (android.widget.Button) (((android.app.Activity) host).findViewById(2131165218));
        host.mTextView = (android.widget.TextView) (((android.app.Activity) host).findViewById(2131165321));
    }
}

缺陷

通过StringBuilder的方式一点一点来拼写Java代码,不但繁琐还容易写错~~

更好的方案,使用JavaPoet库生成java代码方式如下:

上面在ClassCreatorProxy中,通过StringBuilder来生成对应的Java代码。这种做法是比较麻烦的,还有一种更优雅的方式,那就是javapoet。

先添加依赖

dependencies {
    implementation 'com.squareup:javapoet:1.10.0'
}

然后在ClassCreatorProxy中

public class ClassCreatorProxy {
    //省略部分代码...

    /**
     * 创建Java代码
     * @return
     */
    public TypeSpec generateJavaCode2() {
        TypeSpec bindingClass = TypeSpec.classBuilder(mBindingClassName)
                .addModifiers(Modifier.PUBLIC)
                .addMethod(generateMethods2())
                .build();
        return bindingClass;

    }

    /**
     * 加入Method
     */
    private MethodSpec generateMethods2() {
        ClassName host = ClassName.bestGuess(mTypeElement.getQualifiedName().toString());
        MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("bind")
                .addModifiers(Modifier.PUBLIC)
                .returns(void.class)
                .addParameter(host, "host");

        for (int id : mVariableElementMap.keySet()) {
            VariableElement element = mVariableElementMap.get(id);
            String name = element.getSimpleName().toString();
            String type = element.asType().toString();
            methodBuilder.addCode("host." + name + " = " + "(" + type + ")(((android.app.Activity)host).findViewById( " + id + "));");
        }
        return methodBuilder.build();
    }


    public String getPackageName() {
        return mPackageName;
    }
}

最后在 BindViewProcessor中

@Override
    public boolean process(Set set, RoundEnvironment roundEnvironment) {
        //省略部分代码...
        //通过javapoet生成
        for (String key : mProxyMap.keySet()) {
            ClassCreatorProxy proxyInfo = mProxyMap.get(key);
            JavaFile javaFile = JavaFile.builder(proxyInfo.getPackageName(), proxyInfo.generateJavaCode2()).build();
            try {
                // 生成文件
                javaFile.writeTo(processingEnv.getFiler());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ...");
        return true;
    }

通过javapoet可以更加简单得生成这样的Java代码。代码目录如下:

Android组件化系列之编译期注解手写注解、注解处理器、及注解工作流程_第3张图片

三、module_library 工具类

完成了Processor的部分,基本快大功告成了。在BindViewProcessor中创建了对应的xxxActivity_ViewBinding.java,我们改怎么调用?当然是反射啦!!!

  • 创建注解工具类BindViewTools
public class BindViewTools {

    public static void bind(Activity activity) {

        Class clazz = activity.getClass();
        try {
            Class bindViewClass = Class.forName(clazz.getName() + "_ViewBinding");
            Method method = bindViewClass.getMethod("bind", activity.getClass());
            method.invoke(bindViewClass.newInstance(), activity);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

apt-library的部分就比较简单了,通过反射找到对应的ViewBinding类,然后调用其中的bind()方法完成View的绑定。

到目前为止,所有相关的代码都写完了,终于可以拿出来溜溜了

Android组件化系列之编译期注解手写注解、注解处理器、及注解工作流程_第4张图片

四、app 主工程

添加对三个子module的依赖:

dependencies {
    implementation project(':module_annotation')
    implementation project(':module_library')
    annotationProcessor project(':module_processor')
}

Android Gradle 插件 2.2 版本的发布,Android Gradle 插件提供了名为 annotationProcessor的功能来完全代替 android-apt

五、使用

在MainActivity中,在View的前面加上BindView注解,把id传入即可

public class MainActivity extends AppCompatActivity {

    @BindView(R.id.tv)
    TextView mTextView;
    @BindView(R.id.btn)
    Button mButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        BindViewTools.bind(this);
        mTextView.setText("bind TextView success");
        mButton.setText("bind Button success");
    }
}

下面就是注解的运行效果:第二行即为本篇博客的效果,上面点击第一条textView会弹出一个toast,是运行时注解,将在下一篇中分享,动态或者说是运行时注解要比编译注解简单很多,省略了生成java代码的繁琐步骤,但是运行效率会差一些。

Android组件化系列之编译期注解手写注解、注解处理器、及注解工作流程_第5张图片

生成的代码

上面的功能一直在完成一件事情,那就是生成Java代码,那么生成的代码在哪?

在app/build/generated/source/apt中可以找到生成的Java文件

Android组件化系列之编译期注解手写注解、注解处理器、及注解工作流程_第6张图片

对应的代码(之前已经贴过了):

public class MainActivity_ViewBinding {
    public void bind(com.example.gavin.apttest.MainActivity host) {
        host.mButton = (android.widget.Button) (((android.app.Activity) host).findViewById(2131165218));
        host.mTextView = (android.widget.TextView) (((android.app.Activity) host).findViewById(2131165321));
    }
}

文章源码地址如下:

https://github.com/buder-cp/base_component_learn/tree/master/annotation_learn

你可能感兴趣的:(Android组件化插件化)