注解处理器常用类说明

傷城~ 2023-01-17 13:55 78阅读 0赞

# 常见类 #

## `javax.lang.model.element.Element` ##

其子类可能表示为`源代码文件`构成的元素(`Represents a program element such as a package`).一般这个类结合一个工具类使用名叫`Elements`.

1.  `包`
2.  `类`
3.  `接口`
4.  `方法`
5.  `变量`
6.  `Doc文档`
7.  …略

注意是源代码,而非java语法中具体的感念.这一点需要区分.

举个例子:  
我们有一个文件如下:

package com.example.annotationprocessstudy; //PackageElement
    
    public class MyOne  //TypeElement
    <T extends String> {
          // TypeParameterElement
    
    	//VariableElement
        String test = "";
    
    	//ExecuteableElement
        void sayHalo() {
        
        }
    	//ExecuteableElement
        void sayHalo2() {
        
        }
    
    }

我们举例一个具体说明`String test`是一个变量的声明,在`element`他就是一个`VariableElement`,而我们并不管心他是什么类型的变量,比如他是String类型的变量,在element中他是无法获取的,如果你需要获取其变量类型,你需要其他体系.比如`TypeMirror`,`TypeMirror`表示的是具体的`java`程序语法中的类型,比如你想知道他的是什么类型的变量.

//element体系中只知道他是VariableElement,也就是一个变量声明,我们无法知道具体的变量类型.
    String test = "";

我们看下`Element`其部分子类图:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]

这里最好不用`instanceof`去判断是这个`Element`是一个类等操作,如下代码:

public class Main {
        
        public static void main(String[] args) {
        
            Element element = ...;
            
            if (element instanceof TypeElement) {
        
                System.out.printf("是一个类");    
            }
        }
    }

因为一个类实现可能会实现多个`Element`子接口.

class XxImple implements TypeElement, VariableElement{
        }

`element`中有一个`elemnet`层级树的概念如下图:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]  
这个比较好理解,比如有一个`包元素`就包含很多个`类元素`,而一个`类元素`可以包含很多`方法元素`

--------------------

*  公开函数  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]
 *  accept(ElementVisitor<R, P> v, P p)

`ElementVisitor`是一个访问者设计模式接口,p是一个初始化参数,你可以随意设置,两个泛型并没有实际意义.第一个R用于接口的返回值,具体可看下文案例.

当你调用`PackageElement.accept`,会回调`ElementVisitor`某个对应处理`PackageElement`的函数,

直接来个案例:

@MyAnnotation
    public class MyOne //TypeElement
    <T extends String> {
         
       //VariableElement
        @MyAnnotation
        String test = "";
        ExecuteableElement
        @MyAnnotation
        void sayHalo(
                int a, int b
        ) {
        
        }
    
    }

注意看我们上面有三个被注释的地方,看下源代码和输出:

override fun process(
            set: MutableSet<out TypeElement>,
            roundEnvironment: RoundEnvironment
        ): Boolean {
        
            if (set.isEmpty()) {
        
                return false
            }
            val elementsAnnotatedWith =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation::class.java)
    
            var visitor = object : ElementVisitor<Int, String> {
        
            	//是PackageElement类型就回调到这
                override fun visitPackage(e: PackageElement, p: String?): Int {
        
                    messager?.printMessage(
                        Diagnostic.Kind.NOTE,
                        "visitPackage 当前元素 ${e.javaClass}  ${e.simpleName} \n"
                    )
    
                    return 1;
                }
                //TypeElement回调到这
                 override fun visitType(e: TypeElement, p: String?): Int {
        
                    messager?.printMessage(
                        Diagnostic.Kind.NOTE,
                        "visitType 当前元素 ${e.javaClass}  ${e.simpleName} \n"
                    )
    
                    return 1;
                }
                //VariableElement回到到这
    			override fun visitVariable(e: VariableElement, p: String?): Int {
        
                    messager?.printMessage(
                        Diagnostic.Kind.NOTE,
                        "visitVariable 当前元素 ${e.javaClass}  ${e.simpleName} \n"
                    )
    
                    return 1;
                }
              //...略
    
            }
            //这里会有三个元素
            for (element in elementsAnnotatedWith) {
        
                messager?.printMessage( Diagnostic.Kind.NOTE,"当前遍历节点 ${element}\n")
                element.accept(visitor,"")
            }
            return false;
        }

//对应public class MyOne 
    注:当前遍历节点 com.example.annotationprocessstudy.MyOne
    注: visitType 当前元素 class com.sun.tools.javac.code.Symbol$ClassSymbol  MyOne 
    
    //对应String test = "";
    注: 当前遍历节点 test
    注: visitVariable 当前元素 class com.sun.tools.javac.code.Symbol$VarSymbol  test 
    
    //对应sayHalo(int,int){}函数
    注: 当前遍历节点 sayHalo(int,int)
    注: visitExecutable 当前元素 class com.sun.tools.javac.code.Symbol$MethodSymbol  sayHalo

--------------------

*  TypeMirror asType()

`TypeMirror`概念`element`类似,但是表示的却是Java程序的类型元素,这个类型我们后面在介绍,你可以用过`TypeMirror`获取一些具体element获取不到的信息,比如变量类型如`String`

--------------------

*  getEnclosingElement

返回包裹此元素的父元素,如果是`TypeElement`类型,那么就返回`PackageElement`,比较简单

--------------------

*  getEnclosedElements

反会当前元素的子元素,不包含二级子元素,  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]

比如上图`PackageElement.getEnclosedElements`仅返回`TypeElement`.但是不会返回下面二级子元素.

--------------------

*  getSimpleName

返回一个可以用来调试的名字,比如`com.example.annotationprocessstudy.MyOne`返回`MyOne`

--------------------

*  ElementKind getKind();

返回这个Element但是什么类型,比如`TypeElement`可以表示类和接口,但是我们无法确定但是类还是接口.通过ElementKind即可判断,ElementKind是一个枚举

public enum ElementKind {
        
    
        /** A package. */
        PACKAGE,
    
        // Declared types
        /** An enum type. */
        ENUM,
        /** A class not described by a more specific kind (like {@code ENUM}). */
        CLASS,
        /** An annotation type. */
        ANNOTATION_TYPE,
        /**
         * An interface not described by a more specific kind (like
         * {@code ANNOTATION_TYPE}).
         */
        INTERFACE,
    
        // Variables
        /** An enum constant. */
        ENUM_CONSTANT,
        /**
         * A field not described by a more specific kind (like
         * {@code ENUM_CONSTANT}).
         */
        FIELD,
        /** A parameter of a method or constructor. */
        PARAMETER,
        /** A local variable. */
        LOCAL_VARIABLE,
        /** A parameter of an exception handler. */
        EXCEPTION_PARAMETER,
    
        // Executables
        /** A method. */
        METHOD,
        /** A constructor. */
        CONSTRUCTOR,
        /** A static initializer. */
        STATIC_INIT,
        /** An instance initializer. */
        INSTANCE_INIT,
    
        /** A type parameter. */
        TYPE_PARAMETER,
    
        /**
         * An implementation-reserved element.  This is not the element
         * you are looking for.
         */
        OTHER,
    
        /**
         * A resource variable.
         * @since 1.7
         */
        RESOURCE_VARIABLE;
    
    
        /**
         * Returns {@code true} if this is a kind of class:
         * either {@code CLASS} or {@code ENUM}.
         *
         * @return {@code true} if this is a kind of class
         */
        public boolean isClass() {
        
            return this == CLASS || this == ENUM;
        }
    
        /**
         * Returns {@code true} if this is a kind of interface:
         * either {@code INTERFACE} or {@code ANNOTATION_TYPE}.
         *
         * @return {@code true} if this is a kind of interface
         */
        public boolean isInterface() {
        
            return this == INTERFACE || this == ANNOTATION_TYPE;
        }
    
        /**
         * Returns {@code true} if this is a kind of field:
         * either {@code FIELD} or {@code ENUM_CONSTANT}.
         *
         * @return {@code true} if this is a kind of field
         */
        public boolean isField() {
        
            return this == FIELD || this == ENUM_CONSTANT;
        }
    }

--------------------

*  Set getModifiers();

返回修饰符如public等,比较简单,注意不包含隐私的修饰符,比如`interface`的函数,自动包含public.为什么不包含隐式修饰符是因为`element`仅表示源文件的结构,而隐式修饰符是一个java语法特点.

--------------------

*  List<? extends AnnotationMirror> getAnnotationMirrors();

得到修饰这个`element`的注解,  
`AnnotationMirror`声明如下

public interface AnnotationMirror {
        
        DeclaredType getAnnotationType();
        Map<? extends ExecutableElement, ? extends AnnotationValue> getElementValues();
    }

如果你有需要可自行阅读此类

举个例子

//TypeElement
    @MyAnnotation1
    @MyAnnotation2
    public class MyOne{
        
    }

假设有一个`TypeElement`其表示的类为`MyOne`,

TypeElement element;
    //返回数量为2的map,内部含有MyAnnotation1和MyAnnotation2
    Map map=element.getAnnotationMirrors()

--------------------

*  `<A extends Annotation> A getAnnotation(Class<A> annotationType)`

传入一个注解类,如果当前element被修饰那么就返回对应的Annotation类,否则为null.你可用这个判断是否被某注解注释

举个例子

//TypeElement
    @MyAnnotation
    public class MyOne{
        
    }

假设有一个`TypeElement`其表示的类为`MyOne`,

TypeElement element;
    //返回一个Annotation对象
    element.getAnnotation(MyOne.class)
    //返回null
    element.getAnnotation(xxx.class)

--------------------

## `TypeMirror` ##

其子类表示`Java`程序语言中具体的类型,包括 数组 类 接口 泛型等,和`Element`概念高度相识,但是却有很大区别,比如`Element`无法获取变量类型.一般我们都会配合一个工具类`Types`去使用.

部分子类继承图:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 3]

注意:你同样不能用某个具体的子类去判断他就是一个类(`DeclaredType`),原因同`elemnet`

我们看下函数:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 4]

--------------------

*  `<R, P> R accept(TypeVisitor<R, P> v, P p);`  
    和`element`完全相同,根据`typeMirror`子类类型调用TypeVisitor某个对应函数.

--------------------

*  TypeKind getKind();

返回类型具体类别,比如是Bool还是String等.

public enum TypeKind {
        
        /**
         * The primitive type {@code boolean}.
         */
        BOOLEAN,
    
        /**
         * The primitive type {@code byte}.
         */
        BYTE,
    
        /**
         * The primitive type {@code short}.
         */
        SHORT,
    
        /**
         * The primitive type {@code int}.
         */
        INT,
    
        /**
         * The primitive type {@code long}.
         */
        LONG,
    
        /**
         * The primitive type {@code char}.
         */
        CHAR,
    
        /**
         * The primitive type {@code float}.
         */
        FLOAT,
    
        /**
         * The primitive type {@code double}.
         */
        DOUBLE,
    
        /**
         * The pseudo-type corresponding to the keyword {@code void}.
         * @see NoType
         */
        VOID,
    
        /**
         * A pseudo-type used where no actual type is appropriate.
         * @see NoType
         */
        NONE,
    
        /**
         * The null type.
         */
        NULL,
    
        /**
         * An array type.
         */
        ARRAY,
    
        /**
         * A class or interface type.
         */
        DECLARED,
    
        /**
         * A class or interface type that could not be resolved.
         */
        ERROR,
    
        /**
         * A type variable.
         */
        TYPEVAR,
    
        /**
         * A wildcard type argument.
         */
        WILDCARD,
    
        /**
         * A pseudo-type corresponding to a package element.
         * @see NoType
         */
        PACKAGE,
    
        /**
         * A method, constructor, or initializer.
         */
        EXECUTABLE,
    
        /**
         * An implementation-reserved type.
         * This is not the type you are looking for.
         */
        OTHER,
    
        /**
          * A union type.
          *
          * @since 1.7
          */
        UNION,
    
        /**
          * An intersection type.
          *
          * @since 1.8
          */
        INTERSECTION,
    
        /**
         * A pseudo-type corresponding to a module element.
         * @see NoType
         * @since 9
         * @spec JPMS
         */
        MODULE;
    
        /**
         * Returns {@code true} if this kind corresponds to a primitive
         * type and {@code false} otherwise.
         * @return {@code true} if this kind corresponds to a primitive type
         */
        public boolean isPrimitive() {
        
            switch(this) {
        
            case BOOLEAN:
            case BYTE:
            case SHORT:
            case INT:
            case LONG:
            case CHAR:
            case FLOAT:
            case DOUBLE:
                return true;
    
            default:
                return false;
            }
        }
    }

--------------------

## javax.lang.model.util.Elements ##

一个工具类用于更方便的操作`Element`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 5]

--------------------

*  PackageElement getPackageElement(CharSequence name);

用你给定的全限定名字构造一个`PackageElement`对象  
如:

Elements elements =///;
     PackageElement packageElement = elements.getPackageElement("com.fmy");

--------------------

*  TypeElement getTypeElement(CharSequence name);

用给定字符串构建一个`TypeElement`

Elements elements =///;
     TypeElement packageElement = elements.getTypeElement("com.fmy.Hello");

--------------------

*  Map<? extends ExecutableElement, ? extends AnnotationValue>  
    getElementValuesWithDefaults(AnnotationMirror a);

得到注解的上所写数值,如下代码:

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.FIELD, AnnotationTarget.FUNCTION])
    @Retention(AnnotationRetention.SOURCE)
    annotation class MyAnnotation(val value: Int = 20, val value2: Int = 40) {
        
    
    }
    
    //备修饰类
    @MyAnnotation(value = 10)
    public class MyOne {
        
      
    
    }

val elementsAnnotatedWith =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation::class.java)
            //@MyAnnotation(value = 10) public class MyOne
            //得到element
            val myOneElement = elementsAnnotatedWith.first()
            //得到MyAnnotation对应的AnnotationMirror
            val myAnnotation: AnnotationMirror = myOneElement.annotationMirrors.first()
    //        //得到value和value2的数值
            val elementValuesWithDefaults = elementUtils!!.getElementValuesWithDefaults(myAnnotation)!!
            messager?.printMessage(
                Diagnostic.Kind.NOTE,
                "\n ------: " + elementValuesWithDefaults.toString() + "----\n"
            );

输出:

------: {value()=10, value2()=40}----

这里也可以得到原始默认值,如果有需要读者需要自行参阅其api

--------------------

*  String getDocComment(Element e);

返回元素的文档注释

--------------------

*  boolean isDeprecated(Element e);  
    当前是否被标记为`@Deprecated`

--------------------

*  Name getBinaryName(TypeElement type);  
    返回二进制名,简单点就是`包名.类名`,等价于调用`TypeElement.getQualifiedName`

package com.example.annotationprocessstudy;
    
    @MyAnnotation(value = 10)
    public class MyOne

对于上面的`MyOne`的调用后输出`com.example.annotationprocessstudy.MyOne`

--------------------

*  PackageElement getPackageOf(Element type);  
    返回这个元素的对应的`PackageElement`(循环向上查找)

--------------------

*  default ModuleElement getModuleOf(Element type)

返回这个element对应所在的module,没有就返回null,`Android`不需要关心这个

--------------------

*  List<? extends Element> getAllMembers(TypeElement type);

得到当前成员的`element`

@MyAnnotation(value = 10)
    public class MyOne {
        
        String test = "";
    
        void sayHalo(
                int a, int b
        ) {
        
        }
    
    }

val elementsAnnotatedWith =
     roundEnvironment.getElementsAnnotatedWith(MyAnnotation::class.java)
    
     //得到element
     val myOneElement = elementsAnnotatedWith.first()
    
     messager?.printMessage(
         Diagnostic.Kind.NOTE,
         "\n ------: " + elementUtils?.getAllMembers(myOneElement as TypeElement) + "----\n"
     );

输出:

------: [getClass(), hashCode(), equals(java.lang.Object), clone(), toString(), notify(), notifyAll(), wait(), wait(long), wait(long,int), finalize(), MyOne(), test, sayHalo(int,int)]----

`getAllMembers`和`Element.getEnclosedElements`有点像,但是getAllMembers包含了从父亲继承的的public成员

--------------------

*  List<? extends AnnotationMirror> getAllAnnotationMirrors(Element e);

获取注释在元素的`注释`,和继承的父类而来的`注释`.这个不像写`demo`

@AppCompatDelegate.NightMode
    class MyParent {
        
       
    }
    
    @MyAnnotation(value = 10)
    public class MyOne extends MyParent{
        
        
    
    }

可以从`MyOne`获取到`MyAnnotation`和`AppCompatDelegate.NightMode`

--------------------

*  boolean hides(Element hider, Element hidden);  
    没理解,文档翻译过来`hider`隐藏了`hidden`

--------------------

*  boolean overrides(ExecutableElement overrider, ExecutableElement overridden,  
    TypeElement type);

判断`overrider`是否重写了`overridden`,`type`是`overrider`包裹类

如下代码

abstract class MyParent {
        
    
        @MyAnnotation3
        abstract void myFun();
    }
    
    @MyAnnotation(value = 10)
    public class MyOne extends MyParent {
        
    
        @Override
        @MyAnnotation2()
        void myFun() {
        
    
        }
    
    }

val classElement =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation::class.java).first()
    
            val overloadsFunElement =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation2::class.java).first()
    
            val abstractFun =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation3::class.java).first()
    
    
            //得到element
          val result=  elementUtils?.overrides(
                overloadsFunElement as ExecutableElement,
                abstractFun as ExecutableElement,
                classElement as TypeElement
            )

输出`true`

--------------------

*  String getConstantExpression(Object value);

传入基础类型或者字符串,返回对应字符串表示.感觉没啥用

比如传入`true`返回一个对应字符串 `true`

直接传入字符串"hello"返回 `"hello"` 注意返回的字符串有一对引用`""`.

--------------------

*  void printElements(java.io.Writer w, Element… elements);

将元素打印到指定的流中,主要是为了调试和诊断.

--------------------

*  Name getName(CharSequence cs);

Name类型是一个封装了字符串的对象,能便捷的在操作AST(抽象语法树中使用).

传入字符串序列,返回一个封装类Name

--------------------

*  boolean isFunctionalInterface(TypeElement type);  
    判断当前是否为函数式接口.

下面便是一个函数接口

interface Myfun{
        
        
        //仅有一个抽象方法
         fun hell():String;
      }

--------------------

## Types ##

主要用于操作`TypeMirror`工具类.

函数列表如下:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 6]

--------------------

*  Element asElement(TypeMirror t);  
    返回`TypeMirror`对应的`Element`

--------------------

*  boolean isSameType(TypeMirror t1, TypeMirror t2);

测试`t1`和`t2`是同一类型.注意如果是泛型通配符类型直接返回false

demo:

@MyAnnotation3
    abstract class MyParent {
        
        @MyAnnotation4
        int i = 2;
        @MyAnnotation2
        int j = 2;
    }
    
    @MyAnnotation(value = 10)
    public class MyOne extends MyParent {
        
    
    
    }

val classElement =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation::class.java).first()
            val classType = classElement.asType()
    
            val intElement =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation2::class.java).first()
            val intType = intElement.asType()
            val intTwoElement =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation4::class.java).first()
            val intTwoType = intTwoElement.asType()
    
            val parentClassElement =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation3::class.java).first()
            val parentClassType = parentClassElement.asType()
    
    		//返回 false,两个类不同
            val result = typeUtils?.isSameType(parentClassType, classType)
            //返回 true 都是int变量
            val result2 = typeUtils?.isSameType(intType, intTwoType)

--------------------

*  boolean isSubtype(TypeMirror t1, TypeMirror t2);

`t1`是`t2`的子类型才返回`true`

@MyAnnotation3
    abstract class MyParent {
        
    
    }
    
    @MyAnnotation(value = 10)
    public class MyOne extends MyParent {
        
    
    
    }

//子类
     val classElement =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation::class.java).first()
            val classType = classElement.asType()
      //父类
      val parentClassElement =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation3::class.java).first()
            val parentClassType = parentClassElement.asType()
    		//false
            val result = typeUtils?.isSubtype(parentClassType, classType)
            //true
            val result2 = typeUtils?.isSubtype(classType, parentClassType)

--------------------

*  boolean isAssignable(TypeMirror t1, TypeMirror t2);

`t1`是否可以赋值给`t2`,可以理解为t2是t1的父接口或者父类

@MyAnnotation3
    abstract class MyParent {
        
    
    }
    
    @MyAnnotation(value = 10)
    public class MyOne extends MyParent {
        
    
    }

val classElement =
        roundEnvironment.getElementsAnnotatedWith(MyAnnotation::class.java).first()
    val classType = classElement.asType()
    
    
    val parentClassElement =
        roundEnvironment.getElementsAnnotatedWith(MyAnnotation3::class.java).first()
    val parentClassType = parentClassElement.asType()
    //false
    val result = typeUtils?.isAssignable(parentClassType, classType)
    //true
    val result2 = typeUtils?.isAssignable(classType, parentClassType)

--------------------

*  boolean contains(TypeMirror t1, TypeMirror t2);

当t1包含t2时返回true,没找到例子…

--------------------

*  boolean isSubsignature(ExecutableType m1, ExecutableType m2);  
    判断m1的签名是否为m2函数的子签名

你可以用`javap -s 类` 查看函数签名

public class MyOne {
        
    
        @MyAnnotation()
        void testOne() {
        
    
        }
    
        @MyAnnotation3()
        void testOne2() {
        
    
        }
    
    }

将返回true

public class MyOne {
        
    
        @MyAnnotation()
        void testOne(int i) {
        
    
        }
    
        @MyAnnotation3()
        void testOne2() {
        
    
        }
    
    }

返回false

--------------------

*  List<? extends TypeMirror> directSupertypes(TypeMirror t);

返回当前类直接继承或者实现的父类.

abstract class MyParent {
        
    
    }
    interface MyParent2 {
        
    
    }
    
    @MyAnnotation()
    public class MyOne extends MyParent implements MyParent2{
        
    
    }

比如当前MyOne调用`directSupertypes`将返回`MyParent`和`MyParent2`

--------------------

*  TypeMirror erasure(TypeMirror t);

将一个`类/接口` 类型的`TypeMirror`进行擦除泛型后得到一个新的`TypeMirror`,新的`TypeMirror`将得不到泛型信息

@MyAnnotation()
    public class MyOne <T extends String>{

val classElement =
                roundEnvironment.getElementsAnnotatedWith(MyAnnotation::class.java).first()
            val classType = classElement.asType() as DeclaredType
    
    
            //返回数量为1 因为存在泛型
            val typeArguments: List<TypeMirror> = classType.typeArguments
            //擦除泛型信息
            val directSupertypes = typeUtils?.erasure(classType) as DeclaredType
            //返回0 因为被擦除
            val typeArguments1: List<TypeMirror> = directSupertypes.typeArguments

--------------------

*  TypeElement boxedClass(PrimitiveType p);

将基础类型转化为包装类型,简单点就是`int`转`integer`.比较简单就不举例了

--------------------

*  PrimitiveType unboxedType(TypeMirror t);  
    将一个包装类(如`integer`)转化为基础类型(如int).

--------------------

*  TypeMirror capture(TypeMirror t);

`Applies capture conversion to a type.`  
不理解先跳过,

--------------------

*  PrimitiveType getPrimitiveType(TypeKind kind);

传入一个kind类型转化为对应基础类型如(int),比较简单

--------------------

*  NullType getNullType();

获取一个空类型

--------------------

NoType getNoType(TypeKind kind);

将kind转化对应的`NoType`

`TypeKind.VOID` 对应void

`TypeKind.PACKAGE` 一个虚构的`PackageType`

`TypeKind.NONE` 用于其他情况, 如java.lang.Object的超类

--------------------

*  ArrayType getArrayType(TypeMirror componentType);

构造一个对应传入参数的数组类型,比如一个`int`可以转化为`int[]`对应的数组类型的Type.

--------------------

*  WildcardType getWildcardType(TypeMirror extendsBound,  
    TypeMirror superBound);

用传入的上下界构造一个泛型相关的`Type`

--------------------

*      DeclaredType getDeclaredType(TypeElement typeElem, TypeMirror... typeArgs);

用于构造一个相关类/接口.

下面我们构造一个Set的Type类型

val setElements = elementUtils?.getTypeElement("java.util.Set")
    
     val stringElements = elementUtils?.getTypeElement("java.lang.String")!!
    
       val declaredType =
           typeUtils?.getDeclaredType(setElements, stringElements.asType())

--------------------

*  DeclaredType getDeclaredType(DeclaredType containing,  
    TypeElement typeElem, TypeMirror… typeArgs);

和上面的`DeclaredType getDeclaredType(TypeElement typeElem, TypeMirror... typeArgs);`差不多,只不过是内部类

--------------------

*  TypeMirror asMemberOf(DeclaredType containing, Element element);

@MyAnnotation()
    public class MyOne {
        
    
        @MyAnnotation2()
        void test() {
        
    
        }
    
    }

--------------------

*  TypeMirror asMemberOf(DeclaredType containing, Element element);

不是太理解.  
`element`视为`containing`的成员子元素,然后返回element对应的`TypeMirror`

@MyAnnotation()
    public class MyOne {
        
    
        @MyAnnotation2()
        int i=23;
    
    }

//得到MyAnnotation
     val classElement = roundEnvironment.getElementsAnnotatedWith(MyAnnotation::class.java).first()
    val classType = classElement.asType() as DeclaredType
    
    //MyAnnotation2
    val classElement2 = roundEnvironment.getElementsAnnotatedWith(MyAnnotation2::class.java).first()
    //返回classElement2对应的TypeMirror
    val asMemberOf = typeUtils?.asMemberOf(classType, classElement2)

--------------------

## javax.annotation.processing.Filer ##

这个类用于生成文件相关操作.

为严谨性读者最好查阅自行官方文档[Filer官方文档][Filer]

*  这个接口的实现支持通过注解处理器创建一个新文件.
 *  这个接口的实现类(可以从处理器的工具类获取)可以知道这些被创建的文件,  
    因此工具类能更好的管理这些新生成文件.
 *  创建的`类文件`或者`源码文件` 在输出流(如`Writer`)的`close`方法后内容会写入到文件,并在可能在后一轮的处理中又被其他注解处理器处理.
 *  新生成文件分文三类: 源代码文件(如`Person.java`),类文件(编译后文件`Person.class`),资源文件(如`config.xml`)
 *  新生成的`源文件`和`类文件`会被放入不同的文件位置
 *  `Filer`类所提供的创建文件的方法都有一个可变参数,参数类型为`element`.这些`element`会被提供到`注解处理器`的相关类中,以便更好管理这些依赖或编译优化.这些`element`我们把它称为`originating element`(原始元素)
 *  `Filer`不允许修改其他注解处理器生成的类
 *  通过这种方式生成的类我们一般推荐添加注释`@Generated`,告诉其他开发者这个类是自动生成的

相关函数  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 7]

上面四个函数 可以分别用于创建 类文件,源代码文件,和资源文件,我们这里举例其中一个常用的为例:

*  createSourceFile  
    用于创建一个java源文件.

JavaFileObject createSourceFile(CharSequence name,
                                  Element... originatingElements)

*  第一个参数name:  
    类的全限定名,如`com.fmy.Hello`
 *  第二个参数originatingElements:  
    可为空,或者你传入关联这个类的element,可以让编译器做优化

//我们这里不需要elment,所以直接裸着写	
      val createSourceFile = filer?.createSourceFile("com.fmy.Hello")
    
      val writer = createSourceFile?.openWriter()
    
            writer?.apply {
        
                write("""package com.fmy;""")
                write("\n")
                write("class Hello{}")
                close()
            }

生成文件

package com.fmy;
    class Hello{
        }

# 参考 #

[自定义注解之编译时注解(RetentionPolicy.CLASS)（三）—— 常用接口介绍][RetentionPolicy.CLASS_]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: /images/20221021/001db4039c914246b9ded9a8193d8a95.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]: /images/20221021/70f19825cb4a45c7ae0087b8b7431f06.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]: /images/20221021/445c3ff505ac4142b3aca88bdce284b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 3]: /images/20221021/1155610406154cd5b1aab75964d0c687.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 4]: /images/20221021/8bbb851d77564ceb97bf63efa312eb60.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 5]: /images/20221021/1f166023d58e4b1cb1f0e4e6c4ab52d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 6]: /images/20221021/d98a154791694c4a83792f620494e008.png
[Filer]: https://docs.oracle.com/javase/7/docs/api/javax/annotation/processing/Filer.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 7]: /images/20221021/90444a6b40034977b19dd1493a2c45cc.png
[RetentionPolicy.CLASS_]: https://blog.csdn.net/github_35180164/article/details/52171135