Android中注解處理器APT用法示例

更新時(shí)間：2023年12月02日 10:44:33 作者：靜水紅陽

APT全稱Annotation Processing Tool,即注解處理器,APT是一種處理注釋的工具, 它對(duì)源代碼文件進(jìn)行檢測找出其中的注解,并使用注解進(jìn)行額外的處理,給我們自動(dòng)生成代碼,簡化使用,很多流行框架都使用到了APT技術(shù),如 ButterKnife,Retrofit,Arouter,EventBus 等等

APT，Annotation Processing Tool，即注解處理器，是一種用來處理注解的工具，常用在編譯時(shí)掃描和處理注解，最終生成處理注解邏輯的Java文件。APT技術(shù)在目前的很多框架上都有著使用，如ButterKnife，ARouter，GreenDAO等框架上都有著APT技術(shù)的影子。

APT作用

使用APT可以在編譯時(shí)來處理編譯時(shí)注解，生成額外的Java文件，有如下效果：

可以達(dá)到減少重復(fù)代碼手工編寫的效果。

如ButterKnife，我們可以直接使用注解來減少findviewbyid這些代碼，只需要通過注解表示是哪個(gè)id就夠了。
功能封裝。將主要的功能邏輯封裝起來，只保留注解調(diào)用。
相對(duì)于使用Java反射來處理運(yùn)行時(shí)注解，使用APT有著更加良好的性能。

Android基本編譯流程

Android中的代碼編譯時(shí)需要經(jīng)過：Java——>class ——> dex 流程，代碼最終生成dex文件打入到APK包里面。

APT是在編譯開始時(shí)就介入的，用來處理編譯時(shí)注解。

AOP（Aspect Oridnted Programming）是在編譯完成后生成dex文件之前，通過直接修改.class文件的方式，來對(duì)代碼進(jìn)行修改或添加邏輯。常用在在代碼監(jiān)控，代碼修改，代碼分析這些場景。

APT基本使用

基本使用流程主要包括如下幾個(gè)步驟：

創(chuàng)建自定義注解
創(chuàng)建注解處理器，處理Java文件生成邏輯
封裝一個(gè)供外部調(diào)用的API
項(xiàng)目中調(diào)用

本次以仿寫B(tài)utterKnife綁定View為例，省略findviewbyId的代碼，調(diào)用代碼如下：

public class AnnotationTestActivity extends AppCompatActivity {

    @BindView(R.id.tv_annotation_test1)
    TextView tvAnnotationTest1;

    @BindView(R.id.tv_annotation_test2)
    TextView tvAnnotationTest2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_annotation_test);
        BindViewTools.bind(this);
        tvAnnotationTest1.setText("測試文本");
        tvAnnotationTest1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Logger.toast(WorkDemoApplication.context,"控件1:"+R.id.tv_annotation_test1);
            }
        });
        tvAnnotationTest2.setText("另一個(gè)文本");
        tvAnnotationTest2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Logger.toast(WorkDemoApplication.context,"控件2:"+R.id.tv_annotation_test2);
            }
        });
    }
}

1、自定義注解

我們新建立一個(gè)Java lib，命名為annotationTest，用來承載自定義注解，代碼如下所示：

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

2、注解處理器

額外新建立一個(gè)Java lib，命名為processorTest，用來承載注解處理及Java文件生成邏輯。

主要包括如下幾個(gè)步驟：

添加注解處理器
注解處理器注冊(cè)
添加java代碼生成邏輯

需要注意的是，當(dāng)前的注解處理器lib需要引入注解lib——annotationTest,在當(dāng)前Module的build.gradle文件中配置：

    implementation project(':annotationTest')//依賴剛剛創(chuàng)建的annotation模塊

注解處理器

注解處理器代碼如下：

public class BindViewProcessor extends AbstractProcessor {

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

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

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

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

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        mMessager.printMessage(Diagnostic.Kind.NOTE, "processing...");
        mProxyMap.clear();
        //得到所有的注解
        Set<? extends Element> 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，創(chuàng)建java文件
        for (String key : mProxyMap.keySet()) {
            ClassCreatorProxy proxyInfo = mProxyMap.get(key);
            JavaFile javaFile = JavaFile.builder(proxyInfo.getPackageName(),proxyInfo.generateJavaCode2()).build();
            try {
                //生成Java文件
                javaFile.writeTo(processingEnv.getFiler());
            } catch (IOException e) {
                mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName() + "error");
            }
        }

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

此處為了代碼演示簡單起見，并沒有加入格式校驗(yàn)（如對(duì)注解修飾的類型等信息進(jìn)行校驗(yàn)），如果你實(shí)際運(yùn)用APT技術(shù)，請(qǐng)務(wù)必要對(duì)注解的使用規(guī)則進(jìn)行詳細(xì)的校驗(yàn)。

注解處理器注冊(cè)

自定義的注解處理器必須經(jīng)過注冊(cè)才能夠使用，即需要對(duì)注解處理器添加自動(dòng)主動(dòng)的注解。

我們可以使用Google autoService來進(jìn)行注解處理器的自動(dòng)注冊(cè)，首先需要在注解處理器所在的module的build.gradle文件添加autoService的包引入：

    //google autoService
    implementation "com.google.auto.service:auto-service:1.0-rc4"
    annotationProcessor "com.google.auto.service:auto-service:1.0-rc4"

然后將自動(dòng)注冊(cè)的注解添加到注解處理器上以實(shí)現(xiàn)自動(dòng)注冊(cè)效果：

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

java代碼生成

對(duì)于java代碼的生成存在有多種方式，如字符串拼接，JavaPoet等。
如果要使用JavaPoet，則需要在當(dāng)前的Module的build.gradle文件中引入：

    //javaPoet
    implementation "com.squareup:javapoet:1.13.0"

詳細(xì)代碼如下：

package com.example.shapetest.bindview;

import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;

import java.util.HashMap;
import java.util.Map;

import javax.lang.model.element.Modifier;
import javax.lang.model.element.PackageElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.util.Elements;

public class ClassCreatorProxy {
    private String mBindingClassName;
    private String mPackageName;
    private TypeElement mTypeElement;
    private Map<Integer, VariableElement> 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);
    }

    /**
     * 創(chuàng)建Java代碼  字符串拼接方式
     * @return
     */
    public String generateJavaCode() {
        StringBuilder builder = new StringBuilder();
        builder.append("package ").append(mPackageName).append(";\n\n");
        builder.append("import com.example..*;\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;
    }


    /**
     * 創(chuàng)建Java代碼   javapoet
     * @return
     */
    public TypeSpec generateJavaCode2() {
        TypeSpec bindingClass = TypeSpec
                //class名稱設(shè)置
                .classBuilder(mBindingClassName)
                //類為public
                .addModifiers(Modifier.PUBLIC)
                .addMethod(generateMethods2())
                .build();
        return bindingClass;

    }

    /**
     * 加入Method   javapoet
     */
    private MethodSpec generateMethods2() {
        ClassName host = ClassName.bestGuess(mTypeElement.getQualifiedName().toString());
        MethodSpec.Builder methodBuilder = MethodSpec
                //方法名稱
                .methodBuilder("bind")
                //方法為public
                .addModifiers(Modifier.PUBLIC)
                //返回值
                .returns(void.class)
                //方法參數(shù)
                .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 + "));\n");
        }
        return methodBuilder.build();
    }


    public String getPackageName() {
        return mPackageName;
    }

}

3. 對(duì)外調(diào)用

在完成了上述兩步之后，APT的實(shí)際工作已經(jīng)能夠正常運(yùn)行了，下面我們實(shí)現(xiàn)以下調(diào)用方法，以達(dá)到模仿butterknife的調(diào)用效果。

首先我們需要新建立一個(gè)Android lib的Module，命名為apt_lib。

當(dāng)前的對(duì)外lib需要引用注解處理器lib——processorTest,在當(dāng)前Module的build.gradle文件中進(jìn)行如下配置：

    implementation project(path: ':processorTest')

新建對(duì)外的調(diào)用方法，代碼如下：、

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();
        }
    }
}

其主要功能是為被注解綁定的Activity生成對(duì)應(yīng)的輔助類以實(shí)現(xiàn)apt被調(diào)用的效果。

4. 調(diào)用

在進(jìn)行了如下幾步之后，我們實(shí)際上已經(jīng)能夠正常的調(diào)用@BindView這個(gè)注解了.
我們?cè)谖覀兊闹鱉odule——app中調(diào)用APT，當(dāng)然此時(shí)的APT需要引入之前的lib工程，可以在app的build.gradle文件中進(jìn)行如下配置：

    implementation project(':annotationTest') // 添加依賴模塊
    implementation project(':apt_lib') // 添加依賴模塊

    implementation project(':processorTest') // 添加依賴模塊
    annotationProcessor project(':processorTest')

需要注意的是annotationProcessor這一注解處理工具是Java語言使用的，如果你使用的是kotlin語言，則需要使用kapt.

此時(shí)直接調(diào)用我們?cè)陂_頭的調(diào)用代碼，在編譯執(zhí)行后能夠正常運(yùn)行。

當(dāng)我們查看工程內(nèi)的build文件夾時(shí)能夠在如下路徑發(fā)現(xiàn)我們之前生成的文件：

看到里面的代碼如下：

package com.example.workdemo.activity;

public class AnnotationTestActivity_ViewBinding {
  public void bind(AnnotationTestActivity host) {
    host.tvAnnotationTest1 = (android.widget.TextView)(((android.app.Activity)host).findViewById( 2131231102));
    host.tvAnnotationTest2 = (android.widget.TextView)(((android.app.Activity)host).findViewById( 2131231103));
  }
}

這樣的話我們就完成了APT的一個(gè)簡單示例。

總結(jié)

本文主要對(duì)Android中的APT技術(shù)進(jìn)行了簡單說明。APT技術(shù)能夠利用編譯的技術(shù)直接生成Java邏輯代碼，在代碼重復(fù)度較高的場景中比較適用。

到此這篇關(guān)于Android中注解處理器APT用法示例的文章就介紹到這了,更多相關(guān)Android中注解處理器APT內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

Android 利用 APT 技術(shù)在編譯期生成代碼

欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Android中注解處理器APT用法示例

目錄

APT作用

Android基本編譯流程

APT基本使用

1、自定義注解

2、注解處理器

注解處理器

注解處理器注冊(cè)

java代碼生成

3. 對(duì)外調(diào)用

4. 調(diào)用

總結(jié)

相關(guān)文章

最新評(píng)論

大家感興趣的內(nèi)容

最近更新的內(nèi)容

常用在線小工具

欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Android中注解處理器APT用法示例

目錄

APT作用

Android基本編譯流程

APT基本使用

1、 自定義注解

2、注解處理器

注解處理器

注解處理器注冊(cè)

java代碼生成

3. 對(duì)外調(diào)用

4. 調(diào)用

總結(jié)

相關(guān)文章

最新評(píng)論

大家感興趣的內(nèi)容

最近更新的內(nèi)容

常用在線小工具

1、自定義注解

2、注解處理器