自定義一個注解處理器可以按照如下步驟進行：
1.

創建一個java library（注意不要創建Android library），我們定義名稱為kunio-annotation，如下所示：

注解工程.png

其中build.gradle文件如下：

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

}

sourceCompatibility = "8"
targetCompatibility = "8"

在工程下新建一個我們自定義的注解：

package com.kunio.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Kunio {
    String value() default "";
}

2.

創建我們自己的注解處理器module（同樣也是java library），命名為kunio-processor，如下所示:

注解處理器.png

build.gradle文件如下：

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation project(':kunio-annotation')
    implementation 'com.google.auto.service:auto-service:1.0-rc2'
//    implementation 'com.squareup:javapoet:1.7.0'
    // gradle大于5之后需要自己加上以下代碼,我自己現在的版本是5.4.1
   // distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip
    annotationProcessor 'com.google.auto.service:auto-service:1.0-rc2'
}
// 當前的版本與annotation的版本保持一致
sourceCompatibility = "8"
targetCompatibility = "8"

然后我們創建自定義的Processor

package com.kunio.processor;

import com.google.auto.service.AutoService;
import com.kunio.annotation.Kunio;

import java.util.Collections;
import java.util.Set;
import java.util.logging.Logger;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;

@AutoService(Processor.class)
//@SupportedAnnotationTypes({"com.kunio.annotation.Kunio"})
//@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class KunioProcessor extends AbstractProcessor {

    private Messager messager;

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        messager.printMessage(Diagnostic.Kind.NOTE, "startProcessor----kunio");
        return true;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        // 也可以在；類上加上該注解，注解內定義當前版本
        // @SupportedSourceVersion(SourceVersion.RELEASE_8)
        return SourceVersion.latestSupported();
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        // 也可以在類上加上該注解，注解內定義當前支持的我們自定義注解的路徑
        // @SupportedAnnotationTypes({"com.kunio.annotation.Kunio"})
        return Collections.singleton(Kunio.class.getCanonicalName());
    }

    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        messager = processingEnvironment.getMessager();
    }
}

現在我們已經定義好了我們的注解與注解處理器，現在需要在我們的工程里面去使用它；
新建一個Android module，命名為sample：

工程.png

build.gradle如下所示:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.3"

    defaultConfig {
        applicationId "com.kunio.sample"
        minSdkVersion 21
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
    //  我們在這里面依賴了之前定義好的annotation和processor
    annotationProcessor  project(path: ':kunio-processor')
    implementation project(path: ':kunio-annotation')
}

新建一個類使用我們的自定義注解：

package com.kunio.sample;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import com.kunio.annotation.Kunio;

@Kunio
public class MainActivity extends AppCompatActivity {

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

然后我們點擊Build->Rebuild Project,之后我們就可以在task中看到我們的輸出日志了：

> Task :sample:mergeDebugAssets
> Task :sample:mergeDebugResources
> Task :sample:processDebugResources

> Task :sample:compileDebugJavaWithJavac
Gradle may disable incremental compilation as the following annotation processors are not incremental: kunio-processor.jar (project :kunio-processor), auto-service-1.0-rc2.jar (com.google.auto.service:auto-service:1.0-rc2).
Consider setting the experimental feature flag android.enableSeparateAnnotationProcessing=true in the gradle.properties file to run annotation processing in a separate task and make compilation incremental.
// 這里就是我們的輸出日志，對應于KunioProcessor的process方法中的實現
?: startProcessor----kunio
?: startProcessor----kunio

> Task :sample:compileDebugSources
> Task :sample:processDebugJavaRes NO-SOURCE
> Task :sample:transformClassesWithDexBuilderForDebug

好了，最基本的方式我們已經知道怎么去定義一個自己的注解處理器了，一些比較復雜的也是基于這些方式，只是在process方法中具體的實現邏輯不一樣。