1.定義註解

As裡新建一個Java Library module，必須是Java Library Module

此處命名為route-api

該module存放一些與純java類相關的檔案

1. 定義一個註解 Route

/**
* @param name 路由用的跳轉名字，該key與一個.Class關聯，若不填寫預設為Activity類名去掉“Activity”，如MainActivity為”Main“
* @param appCode app跳轉協議碼，為後臺或前端呼叫本地頁面跳轉的協議如“app://10000"跳轉到登入頁
* @param interceptors 攔截器，用於跳轉到當前目的頁面前先判斷某些條件是否成立，若不成立則攔截跳轉到其他頁面，
* 如，某些頁面需要登入才能跳轉到該頁面則新增一個登入的攔截器，如果沒有登入則跳轉到登入頁，反之，則跳轉到目的頁面
*/
 

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.BINARY)
annotation class Route(val name: String = "",
                    val appCode: Int = -1,
                    val interceptors: Array<KClass<*>> = emptyArray())

該註解用於標記該類自動配置到路由表中

2. 定義一個Config類用於配置自動生成類的包名，類名等

object
 
 RouteConfig {
   var routePackName = "com.tugo.decor"
   var routeSimpleName = "AutoRouter"
   var registerMethod = "registeredToRouter"
}

2.實現AbstractProcessor

另外新建一個java Library Module，命名為route-process

1.建立一個TypeElement處理類

class RouteAnnotationInfo(val element: TypeElement) {

    //全限定名，如com.tugou.andromeda.tgkit.MainActivity
 

    val targetQualifiedName = element.qualifiedName.toString();
    //簡單名，如MainActivity
    val targetName = element.simpleName.toString()

    //攔截器類集合
    val interceptors: List<ClassName>
    //Route註解類的變數，用於獲取某類的Route註解
    val annotation: Route

    init {
        annotation = element.getAnnotation(Route::class.java)
        interceptors = iniInterceptors()
    }

    //同Route的name
    val name: String
        get() {
            return if (annotation.name.isBlank()) {
                targetName.replace("Activity", "");
            } else {
                annotation.name
            }
        }
    //同Route的univCode
    val univCode: Int = annotation.univCode

    /**
     * 用於初始化攔截器的類，因為編譯時無法獲取Class檔案，只好通過字串獲取攔截器的類的全限定名以獲得其包名和類名，其他方法可參看 https://www.cnblogs.com/fuckingaway/p/6703021.html，感覺上面寫的太麻煩，我就沒有細看
     * 然後將其轉為ClassName物件，ClassName類為javapoet包下的宣告Class的類，用其可以自動匯入包名 ,關於javapoet介紹可看
     * @see <a href=" https://www.2cto.com/kf/201609/543893.html ">javapoet——會寫程式碼的“詩人”</a>
     */
    fun iniInterceptors(): List<ClassName> {
        val resultList = ArrayList<ClassName>();
        for (str in getInterceptorStrs(element.getAnnotation(Route::class.java))) {
            if (str.isNotBlank()) {
                resultList.add(generateClassName(str))
            }
        }
        return resultList;
    }

}

/**
 *用於將字串型別的去限定類類名轉換為ClassName類
 */
fun generateClassName(str: String): ClassName {
    val lastIndex = str.lastIndexOf(".")
    val pack = str.substring(0, lastIndex)
    val simpleName = str.substring(lastIndex + 1)
    return ClassName.get(pack, simpleName)
}

/**
 *用於獲取註解處理器類的字串
 */
fun getInterceptorStrs(annotation: Route): List<String> {
    val strs = annotation.toString()
            .substring(Route::class.java.name.length + 1)
            .replace("(", "").replace(")", "")
            .split(", ")
    for (s in strs) {
        if (s.contains("interceptors=")) {
            return s.substring("interceptors=".length).split(",")
        }
    }
    return emptyList()
}

2.建一個RouteProcess類繼承成AbstractProcessor

@AutoService(Processor::class)
class RouteProcess : AbstractProcessor() {
	/**
     *該方法用於表明該處理器處理那些註解
     */
    override fun getSupportedAnnotationTypes(): Set<String> {
        return setOf<String>(Route::class.java.getCanonicalName())
    }
    /**
     *該方法用於處理註解，並生成程式碼
     */
    override fun process(set: MutableSet<out TypeElement>?, roundEnv: RoundEnvironment): Boolean {
        //宣告一個Set集合用於儲存處理類
        val hashSet = HashSet<RouteAnnotationInfo>();
        //獲取所有被Route註解的元素
        val elements = roundEnv.getElementsAnnotatedWith(Route::class.java)
        for (annotatedElement: Element in elements) {
            if (annotatedElement.kind != ElementKind.CLASS) {
                processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "該註解只能用於類", annotatedElement)
                return false
            }
            val typeElement = annotatedElement as TypeElement
            hashSet.add(RouteAnnotationInfo(typeElement))

        }
        //準備寫程式碼
        //ParameterizedTypeName用於引數化類如List<T>，下面程式碼用於宣告一個List<TGPage>類
        val routeTypeList = ParameterizedTypeName.get(List::class.java, TGPage::class.java)//此處TGPage為定義路由表單項的一個類

        val methodProvidePagesBuilder = MethodSpec.methodBuilder("providePages")
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                .returns(List::class.java)
        //下面生成程式碼為List<TGPage> list=new ArrayList<>()
                .addStatement("\$T list = new \$T<>()", routeTypeList, ArrayList::class.java)

        //"開始寫方法內容"
        for (routeAnnotationInfo in hashSet) {

            methodProvidePagesBuilder.addCode("list.add(new \$T(\$S,\$T.class",
                    TGPage::class.java,
                    routeAnnotationInfo.name,
                    ClassName.get(routeAnnotationInfo.element)
            )

            //生成Class陣列的程式碼
            val codeBlock = CodeBlock.builder();
            codeBlock.add(",\$L", routeAnnotationInfo.univCode)

            if (routeAnnotationInfo.interceptors.isNotEmpty()) {
                codeBlock.add(",new \$T[]{", Class::class.java)
                for (clazz in routeAnnotationInfo.interceptors) {
//                methodProvidePagesBuilder.addComment("測試element：\$L",str)
                    if (routeAnnotationInfo.interceptors.indexOf(clazz) != 0) {
                        codeBlock.add(",")
                    }
                    codeBlock.add("\$T.class", clazz)
//                    methodProvidePagesBuilder.addComment("測試element：\$L", clazz)
                }
                codeBlock.add("}")
            }
            methodProvidePagesBuilder.addCode(codeBlock.build())
                    .addStatement("))")
        }

        methodProvidePagesBuilder.addStatement("return list")

        val registe = MethodSpec.methodBuilder(RouteConfig.registerMethod)
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                .addStatement("\$T.registerPages(\$N())", ClassName.get(RouteConfig.tgRouterPackName, RouteConfig.tgRouterSimpleName), "providePages")
                //tgRouterPackName和tgRouterSimpleName為路由跳轉的類，此處請忽略，該文只介紹如何自動生成路由表
                .build()
        //"開始寫類"

        val routeTable = TypeSpec.classBuilder(RouteConfig.routeSimpleName)
                .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
                .addMethod(methodProvidePagesBuilder.build())
                .addMethod(registe)
                .build();

        //"寫成java檔案"
        val javaFile: JavaFile = JavaFile.builder(RouteConfig.routePackName, routeTable)
                .build();
        try {
            //僅呼叫此方法會報錯但不影響生成程式碼，但會值中斷Run，所以用try—catch塊包裹住
            javaFile.writeTo(processingEnv.filer)
        } catch (e: IOException) {
            e.printStackTrace();
        }
        return false
    }
}    

MethodSpec用於是用於方法生成的類，通過MethodSpec.methodBuilder(methodName)生成一個MethodSpec的構造器，可以用構造方法

build.addModifiers用於宣告方法的修飾符如public static private等等，可以通過Modifier的列舉傳入

build.returns(Type returnType)宣告方法的返回型別，未宣告的則為void

build…addComment(String commen)用於生成註釋，當你的註解器可以自動生成程式碼時，你可以用其來進行測試資料

build.addStatement(String format, Object… args)為方法增加一行程式碼，會自動新增分號和換行

• format支援字串模板，同過$T或$S,$L,$N來表示一個佔位，args則為前面佔位的實際值，args的個數要與前面佔位符的個數相同

• $T表示Type型別--類或介面等型別的佔位符，物件可以傳.class物件或ClassName物件等，會對其自動導包，注意如果是MainActivity.class，生成的程式碼為MainActivity多以如果你需要生成MainActivity.class你需要在$T後面加上.class字串即“$T.class”

• $S代表字串型別的佔位符，物件必須為字串類；$L表示文字型別的字串，包含字串型別，也可以支援整數等型別，具體請自己嘗試

• $N表示方法名型別的佔位符，注意只會生成方法的名字，方法呼叫要自己加(),如“$N()”,“Main”,才表示呼叫了Main()

build.add(String format, Object… args)同上面類似，但不會換行也不會新增分號

CodeBlock是生成程式碼片段的類，方法等同MethodSpec的方法相同

TypeSpec用於生成類，介面等，TypeSpec.classBuilder(String name)可以生成一個TypeSpec的Builder 物件，該Builder 物件可以用於設定類的生成

build.addModifiers(Modifier.PUBLIC, Modifier.FINAL)用於宣告類的修飾符
build.addMethod(methodProvidePagesBuilder.build())用於為類新增方法，引數為MethodSpec型別

JavaFile為用於生成.java檔案JavaFile.builder(String packageName, TypeSpec typeSpec)，packageName為該java檔案的包名，typeSpec則為該java檔案的class

javaFile.writeTo(processingEnv.filer)則真正用於將檔案寫入到磁碟中

3.注意

1.要將註解處理器建立在JavaLibrary Module裡

Android的Library module不支援javax包下的檔案，而我們需要的AbstractProcessor確實javax包下的

2.auto-service使用，並用kapt進行註解處理

auto-service用於註冊處理器，compiler庫會生成一個jar，在jar中META-INF/services目錄需要新建一個特殊的檔案javax.annotation.processing.Processor，檔案裡的內容就是宣告你的處理器，而auto-service可以自動生成META-INF/services/javax.annotation.processing.Processor檔案

注意在kotlin中要用kapt "com.google.auto.service:auto-service:1.0-rc2"宣告@AutoService的直接處理器