前言
本文我们来看一下javax.lang.model.util中的类,这是javax.lang.model中的最后一个子包了.这部分的代码不太好理解.
解析
Elements
操作java源程序元素的工具方法.
兼容性提醒:本类中的方法可能会在未来的版本中添加.
public interface Elements {
/**
* 返回指定全限定名所对应的PackageElement.如果指定的是"",则返回未命名包.如果没有找到对应的,则返回null.
*
*/
PackageElement getPackageElement(CharSequence name);
/**
* 返回指定规范名称对应的TypeElement,如果没有对应的,则返回null.
*
*/
TypeElement getTypeElement(CharSequence name);
/**
* 返回该注解的元素所对应的值,包括默认值
*/
Map<? extends ExecutableElement, ? extends AnnotationValue>
getElementValuesWithDefaults(AnnotationMirror a);
/**
* 返回该元素所对应的Javadoc.
* 该元素对应的文档注释是有/**开头的,以*/结尾的,忽略空格。因此，文档注释包含至少三
* 个“*”字符。文档注释返回的文本是在源代码中出现的注释的处理形式.开头的“/**”和结尾
* 的“*/”被删除.对于在初始“/**”之后开始的注释行，前导空白字符将被丢弃，而在空白之后
* 或开始该行时出现的任何连续的“*”字符也被丢弃。然后将处理后的行连接在一起（包括行终止符）并返回。
*/
String getDocComment(Element e);
/**
* 如果指定的元素是deprecated,则返回true,否则,返回false.
*/
boolean isDeprecated(Element e);
/**
* 返回指定元素所对应的二进制名称.
* 关于这部分内容,可以参阅 JLS 13.1 二进制形式
*/
Name getBinaryName(TypeElement type);
/**
* 返回指定元素所对应的包,如果指定的元素是包,则返回自己
*/
PackageElement getPackageOf(Element type);
/**
* 返回指定元素的内部成员,包括继承和直接声明的.
* 对于一个类来说,包含构造器,但是不包含本地或者匿名类
* 请注意，某些类型的元素可以使用ElementFilter中的方法进行过滤。
*/
List<? extends Element> getAllMembers(TypeElement type);
/**
* 返回该元素所对应的所有注解,不管是直接声明的还是继承的
*/
List<? extends AnnotationMirror> getAllAnnotationMirrors(Element e);
/**
* 如果第一个Element隐藏了第二个Element,则返回true
*/
boolean hides(Element hider, Element hidden);
/**
* 测试第一个方法,作为制定类型的成员,复写了第二个方法
* 当一个非抽象的方法复写了抽象的方法,这也叫实现.
* 在最简单和最典型的用法中，类型参数的值只是含有复写方法的类或接口。举例:m1代表的是
* String.hashCode,m2代表的是Object.hashCode.我们可以通过如下方式来测试是否String
* 中的m1的方法复写了m2:
* assert elements.overrides(m1, m2,
* elements.getTypeElement("java.lang.String"));
* 以下示例可说明更有趣的情况，其中类型A中的方法不重写类型B中的同名方法：
* class A { public void m() {} } }
interface B { void m(); } }
...
m1 = ...; // A.m
m2 = ...; // B.m
assert ! elements.overrides(m1, m2, elements.getTypeElement("A"));
* 当有第三个类型c时,A中的方法就复写了B中的方法:
* assert elements.overrides(m1, m2,
* elements.getTypeElement("C"));
*/
boolean overrides(ExecutableElement overrider, ExecutableElement overridden,
TypeElement type);
/**
* 返回表示原始类型值或字符串的常量表达式的文本。返回的文本格式适合于表示源代码中的值。
* 参数value是 原始类型的值或者是String
*/
String getConstantExpression(Object value);
/**
* 按指定的顺序将元素的表示打印到给定的Writer。这种方法的主要目的是用于诊断。未指定输出的确切格式，并有可能更改这种输出格式。
*/
void printElements(java.io.Writer w, Element... elements);
/**
* 返回指定参数所对应的Name
*/
Name getName(CharSequence cs);
/**
* 如果给定的类是函数接口,则返回true
*/
boolean isFunctionalInterface(TypeElement type);
}
Types
操作类型的工具方法的接口
public interface Types {
/**
* 返回与类型对应的元素。类型可以是声明类型或类型变量。如果类型不是具有相应元素的类型，则返回null
*/
Element asElement(TypeMirror t);
/**
* 测试是否2个对象代表的是同一个类型.
* 警告：如果此方法的任何一个参数表示通配符，则此方法将返回false。因此，通配符不是与自
* 身相同的类型。这可能首先令人惊讶，但一旦你认为这样的例子必须被编译器拒绝，才有意义：
* List<?> list = new ArrayList<Object>();
* list.add(list.get(0));
* 由于注释仅是与类型相关联的元数据，所以在计算两个TypeMirror对象是否为相同类型时，
* 不考虑两个参数上的注释集。特别地，两个类型的反射对象可以具有不同的注释，并且仍然被
* 认为是相同的
*/
boolean isSameType(TypeMirror t1, TypeMirror t2);
/**
* 测试是否第一个TypeMirror是第二个TypeMirror的子类型.任何类型都被认为是它自身的子类型
*/
boolean isSubtype(TypeMirror t1, TypeMirror t2);
/**
* 测试一种类型是否可分配给另一种类型。
* 这部分的内容可以参考 JLS 5.2 Assignment Conversion
*/
boolean isAssignable(TypeMirror t1, TypeMirror t2);
/**
* 如果第一个参数包含第二个参数则返回true
*/
boolean contains(TypeMirror t1, TypeMirror t2);
/**
* 测试是否第一个参数是第二个参数的子签名
*/
boolean isSubsignature(ExecutableType m1, ExecutableType m2);
/**
* 返回类型的直接超类型。接口类型（如果有的话）将出现在列表中的最后一个。
*/
List<? extends TypeMirror> directSupertypes(TypeMirror t);
/**
* 返回指定类型擦除后的TypeMirror.
*/
TypeMirror erasure(TypeMirror t);
/**
* 返回指定类型的包装类型
*/
TypeElement boxedClass(PrimitiveType p);
/**
* 返回指定包装类型所对应的原始类型
*/
PrimitiveType unboxedType(TypeMirror t);
/**
* 对指定类型进行捕获转换
*/
TypeMirror capture(TypeMirror t);
/**
* 返回指定TypeKind所对应的PrimitiveType
*/
PrimitiveType getPrimitiveType(TypeKind kind);
/**
* 返回NullType-->代表null的类型
*/
NullType getNullType();
/**
* 返回没有实际类型时使用的伪类型。返回的类型可以是TypeKind#VOID，也可以是TypeKind#NONE。对于包，使用 Elements.getPackageElement(CharSequence).asType()。
*/
NoType getNoType(TypeKind kind);
/**
* 返回具有指定组件类型的数组类型.
*/
ArrayType getArrayType(TypeMirror componentType);
/**
* 返回一个新的通配符类型参数。通配符的边界可以指定，或者两者都不，但不是两者都有。
*/
WildcardType getWildcardType(TypeMirror extendsBound,
TypeMirror superBound);
/**
* 返回与类型元素和实际类型参数相对应的类型。例如，给定Set的类型元素和String的TypeMirror
* ，此方法可用于获得参数化类型Set<String>。
* 类型参数的数目必须等于TypeElement的形式类型参数的数目，或者必须为零。如果为零，如
* 果类型元素是泛型，则返回类型元素的原始类型
* 如果正在返回参数化类型，则其类型元素不能包含在泛型外部类中。例如，参数化类型
* Outer<String>.Inner<Number>，可以通过首先使用此方法获得类型Outer<String>，然
* 后调用getDeclaredType(DeclaredType、TypeElement、TypeMirror)来构造。
*
*/
DeclaredType getDeclaredType(TypeElement typeElem, TypeMirror... typeArgs);
/**
* 返回与类型元素和实际类型参数相对应的类型，给定包含成员类型的成员类型。例如，可以通过
* 首先使用getDeclaredType(TypeElement，TypeMirror)获得类型Outer<String>，然
* 后调用此方法来构造参数化类型Outer<String>.Inner<Number>。
* 如果包含的类型是参数化类型，则类型参数的数量必须等于typeElem的形式类型参数的数量。
* 如果它不是参数化的，或者它是空的，那么这个方法就等同于getDeclaredType(typeElem, typeArgs)
*/
DeclaredType getDeclaredType(DeclaredType containing,
TypeElement typeElem, TypeMirror... typeArgs);
/**
* 当元素被视为给定类型的成员或直接包含时，返回元素的类型。
* 当第一个参数是Set<String>,第二个参数是Set.add方法时,则返回一个参数为String的ExecutableType
*/
TypeMirror asMemberOf(DeclaredType containing, Element element);
}
接下来我们来看一下AbstractTypeVisitor6的继承结构中涉及到的类或接口,如图:
AbstractTypeVisitor6
具有默认行为的类型的访问者，适用于jdk 1.6.
警告：该类实现的Type EvestIdor接口可能会在将来添加一些方法，以适应添加到Java编程语言未来版本的新的、目前未知的语言结构。因此，名称以“visit”开头的方法将来可能会被添加到这个类中；为了避免不兼容，扩展这个类的类不应声明任何以“visit”开头的实例方法。
当添加了这种新的访问方法时，此类中的默认实现将调用visitUnknown方法。还将引入一个新的抽象类型访问者类来对应新版本的语言；该访问者中的访问方法具有不同的默认行为。当新访问者被引入时，该类中的一部分或者全部都将被废弃.
注意，在访问者界面中添加一个新的访问方法的默认实现，而不是直接在访问者界面中添加一个默认方法，因为Java SE 8语言特征不能用于这个版本的API，因为这个版本需要在Java SE 7上运行。仅在Java SE 8和以后运行的API的未来版本可能会在这种情况下利用默认方法。
泛型参数 R –> 该visit方法的返回值类型
泛型参数 P –> visit方法额外添加的参数
public abstract class AbstractTypeVisitor6<R, P> implements TypeVisitor<R, P> {
protected AbstractTypeVisitor6() {}
public final R visit(TypeMirror t, P p) {
return t.accept(this, p);
}
public final R visit(TypeMirror t) {
return t.accept(this, null);
}
public R visitUnion(UnionType t, P p) {
return visitUnknown(t, p);
}
public R visitIntersection(IntersectionType t, P p) {
return visitUnknown(t, p);
}
public R visitUnknown(TypeMirror t, P p) {
throw new UnknownTypeException(t, p);
}
}
AbstractTypeVisitor7
用于jdk1.7的type visitor。
public abstract class AbstractTypeVisitor7<R, P> extends AbstractTypeVisitor6<R, P> {
protected AbstractTypeVisitor7() {
super();
}
public abstract R visitUnion(UnionType t, P p);
}
AbstractTypeVisitor8
用于jdk1.8的type visitor。
public abstract class AbstractTypeVisitor8<R, P> extends AbstractTypeVisitor7<R, P> {
protected AbstractTypeVisitor8() {
super();
}
public abstract R visitIntersection(IntersectionType t, P p);
}
SimpleElementVisitor6
对应jdk1.6的简单的visitor.
当visit方法是与jdk1.6的语法结构相关的,则会调用defaultAction方法.对应在jdk1.7或者之后的语法结构,则调用visitUnknown方法.
@SupportedSourceVersion(RELEASE_6)
public class SimpleElementVisitor6<R, P> extends AbstractElementVisitor6<R, P> {
/**
* defaultAction 方法默认的返回值
*/
protected final R DEFAULT_VALUE;
protected SimpleElementVisitor6(){
DEFAULT_VALUE = null;
}
protected SimpleElementVisitor6(R defaultValue){
DEFAULT_VALUE = defaultValue;
}
protected R defaultAction(Element e, P p) {
return DEFAULT_VALUE;
}
public R visitPackage(PackageElement e, P p) {
return defaultAction(e, p);
}
public R visitType(TypeElement e, P p) {
return defaultAction(e, p);
}
public R visitVariable(VariableElement e, P p) {
// 如果VariableElement的种类不是RESOURCE_VARIABLE,则调用defaultAction方法,
// ElementKind.RESOURCE_VARIABLE 对应jdk1.7的资源变量
if (e.getKind() != ElementKind.RESOURCE_VARIABLE)
return defaultAction(e, p);
else
return visitUnknown(e, p);
}
public R visitExecutable(ExecutableElement e, P p) {
return defaultAction(e, p);
}
public R visitTypeParameter(TypeParameterElement e, P p) {
return defaultAction(e, p);
}
}
SimpleElementVisitor7
对应jdk1.7的简单的visitor.
当visit方法是与jdk1.7和之前版本的语法结构相关的,则会调用defaultAction方法.
@SupportedSourceVersion(RELEASE_7)
public class SimpleElementVisitor7<R, P> extends SimpleElementVisitor6<R, P> {
protected SimpleElementVisitor7(){
super(null);
}
protected SimpleElementVisitor7(R defaultValue){
super(defaultValue);
}
// 可以看到在SimpleElementVisitor6还需判断是否是jdk1.7中的ElementKind.RESOURCE_VARIABLE,在这里就直接调用defaultAction了.
@Override
public R visitVariable(VariableElement e, P p) {
return defaultAction(e, p);
}
}
SimpleElementVisitor8
对应jdk1.7的简单的visitor.
当visit方法是与jdk1.7和之前版本的语法结构相关的,则会调用defaultAction方法.
@SupportedSourceVersion(RELEASE_8)
public class SimpleElementVisitor8<R, P> extends SimpleElementVisitor7<R, P> {
protected SimpleElementVisitor8(){
super(null);
}
protected SimpleElementVisitor8(R defaultValue){
super(defaultValue);
}
}TypeKindVisitor6
一个类型的Visitor，其默认行为适用于jdk1.6。对于可能具有多种类型的XYZ类型，该类中的visitXYZ方法委托给与第一个参数的类型相对应的visitXYZKind方法。visitXYZKind方法调用defaultAction方法，将它们的参数传递给defaultAction的相应参数。
@SupportedSourceVersion(RELEASE_6)
public class TypeKindVisitor6<R, P> extends SimpleTypeVisitor6<R, P> {
protected TypeKindVisitor6() {
super(null);
}
protected TypeKindVisitor6(R defaultValue) {
super(defaultValue);
}
@Override
public R visitPrimitive(PrimitiveType t, P p) {
TypeKind k = t.getKind();
switch (k) {
case BOOLEAN:
return visitPrimitiveAsBoolean(t, p);
case BYTE:
return visitPrimitiveAsByte(t, p);
case SHORT:
return visitPrimitiveAsShort(t, p);
case INT:
return visitPrimitiveAsInt(t, p);
case LONG:
return visitPrimitiveAsLong(t, p);
case CHAR:
return visitPrimitiveAsChar(t, p);
case FLOAT:
return visitPrimitiveAsFloat(t, p);
case DOUBLE:
return visitPrimitiveAsDouble(t, p);
default:
throw new AssertionError("Bad kind " + k + " for PrimitiveType" + t);
}
}
public R visitPrimitiveAsBoolean(PrimitiveType t, P p) {
return defaultAction(t, p);
}
public R visitPrimitiveAsByte(PrimitiveType t, P p) {
return defaultAction(t, p);
}
public R visitPrimitiveAsShort(PrimitiveType t, P p) {
return defaultAction(t, p);
}
public R visitPrimitiveAsInt(PrimitiveType t, P p) {
return defaultAction(t, p);
}
public R visitPrimitiveAsLong(PrimitiveType t, P p) {
return defaultAction(t, p);
}
public R visitPrimitiveAsChar(PrimitiveType t, P p) {
return defaultAction(t, p);
}
public R visitPrimitiveAsFloat(PrimitiveType t, P p) {
return defaultAction(t, p);
}
public R visitPrimitiveAsDouble(PrimitiveType t, P p) {
return defaultAction(t, p);
}
@Override
public R visitNoType(NoType t, P p) {
TypeKind k = t.getKind();
switch (k) {
case VOID:
return visitNoTypeAsVoid(t, p);
case PACKAGE:
return visitNoTypeAsPackage(t, p);
case NONE:
return visitNoTypeAsNone(t, p);
default:
throw new AssertionError("Bad kind " + k + " for NoType" + t);
}
}
public R visitNoTypeAsVoid(NoType t, P p) {
return defaultAction(t, p);
}
public R visitNoTypeAsPackage(NoType t, P p) {
return defaultAction(t, p);
}
public R visitNoTypeAsNone(NoType t, P p) {
return defaultAction(t, p);
}
}
TypeKindVisitor7
适用于jdk1.7的visitor.
@SupportedSourceVersion(RELEASE_7)
public class TypeKindVisitor7<R, P> extends TypeKindVisitor6<R, P> {
protected TypeKindVisitor7() {
super(null);
}
protected TypeKindVisitor7(R defaultValue) {
super(defaultValue);
}
@Override
public R visitUnion(UnionType t, P p) {
return defaultAction(t, p);
}
}
TypeKindVisitor8
适用于jdk1.8的visitor.
@SupportedSourceVersion(RELEASE_8)
public class TypeKindVisitor8<R, P> extends TypeKindVisitor7<R, P> {
protected TypeKindVisitor8() {
super(null);
}
protected TypeKindVisitor8(R defaultValue) {
super(defaultValue);
}
@Override
public R visitIntersection(IntersectionType t, P p) {
return defaultAction(t, p);
}
}
接下来看一下AbstractElementVisitor6的继承结构,如图
AbstractElementVisitor6
适用于jdk 1.6的Element Visitor.
@SupportedSourceVersion(RELEASE_6)
public abstract class AbstractElementVisitor6<R, P> implements ElementVisitor<R, P> {
protected AbstractElementVisitor6(){}
public final R visit(Element e, P p) {
return e.accept(this, p);
}
public final R visit(Element e) {
return e.accept(this, null);
}
public R visitUnknown(Element e, P p) {
throw new UnknownElementException(e, p);
}
}
AbstractElementVisitor7
适用于jdk 1.7的Element Visitor.
@SupportedSourceVersion(RELEASE_7)
public abstract class AbstractElementVisitor7<R, P> extends AbstractElementVisitor6<R, P> {
protected AbstractElementVisitor7(){
super();
}
}
AbstractElementVisitor8
适用于jdk 1.8的Element Visitor.
@SupportedSourceVersion(RELEASE_8)
public abstract class AbstractElementVisitor8<R, P> extends AbstractElementVisitor7<R, P> {
protected AbstractElementVisitor8(){
super();
}
}ElementScanner6
一个具有默认行为的程序元素的Scanner，适用于jdk1.6。这个类中的visitXYZ方法通过调用对它们所包围的元素、参数等对应的scan方法来扫描它们的组件元素.子类可以通过覆盖visitXYZ方法来控制访问的顺序元素。注意，Scanner的客户端可以获得所期望的行为，即调用感兴趣的根对象上的v.scan(e, p)而不是v.visit(e, p).
当子类重写visitXYZ方法时，新方法通过调用super.visitXYZ来扫描其所包围的元素，具体访问者可以控制关于附加处理的组件元素遍历的顺序；例如，在重写方法开始时始终调用super.visitXYZ将产生先序遍历，等等。如果选用按照其他顺序进行遍历,则按照需要的顺序调用对应的visit方法,而不是适用
super.visitXYZ.
@SupportedSourceVersion(RELEASE_6)
public class ElementScanner6<R, P> extends AbstractElementVisitor6<R, P> {
protected final R DEFAULT_VALUE;
protected ElementScanner6(){
DEFAULT_VALUE = null;
}
protected ElementScanner6(R defaultValue){
DEFAULT_VALUE = defaultValue;
}
public final R scan(Iterable<? extends Element> iterable, P p) {
R result = DEFAULT_VALUE;
for(Element e : iterable)
result = scan(e, p);
return result;
}
public R scan(Element e, P p) {
return e.accept(this, p);
}
public final R scan(Element e) {
return scan(e, null);
}
public R visitPackage(PackageElement e, P p) {
return scan(e.getEnclosedElements(), p);
}
public R visitType(TypeElement e, P p) {
return scan(e.getEnclosedElements(), p);
}
public R visitVariable(VariableElement e, P p) {
if (e.getKind() != ElementKind.RESOURCE_VARIABLE)
return scan(e.getEnclosedElements(), p);
else
return visitUnknown(e, p);
}
public R visitExecutable(ExecutableElement e, P p) {
return scan(e.getParameters(), p);
}
public R visitTypeParameter(TypeParameterElement e, P p) {
return scan(e.getEnclosedElements(), p);
}
}
ElementScanner7
适用于jdk1.7的 ElementScanner.
@SupportedSourceVersion(RELEASE_7)
public class ElementScanner7<R, P> extends ElementScanner6<R, P> {
protected ElementScanner7(){
super(null);
}
protected ElementScanner7(R defaultValue){
super(defaultValue);
}
@Override
public R visitVariable(VariableElement e, P p) {
return scan(e.getEnclosedElements(), p);
}
}
ElementScanner8
适用于jdk1.8的 ElementScanner.
@SupportedSourceVersion(RELEASE_8)
public class ElementScanner8<R, P> extends ElementScanner7<R, P> {
protected ElementScanner8(){
super(null);
}
protected ElementScanner8(R defaultValue){
super(defaultValue);
}
}ElementKindVisitor6
程序元素类型的 visitor,适用于jdk1.6.
@SupportedSourceVersion(RELEASE_6)
public class ElementKindVisitor6<R, P>
extends SimpleElementVisitor6<R, P> {
protected ElementKindVisitor6() {
super(null);
}
protected ElementKindVisitor6(R defaultValue) {
super(defaultValue);
}
@Override
public R visitPackage(PackageElement e, P p) {
assert e.getKind() == PACKAGE: "Bad kind on PackageElement";
return defaultAction(e, p);
}
@Override
public R visitType(TypeElement e, P p) {
ElementKind k = e.getKind();
switch(k) {
case ANNOTATION_TYPE:
return visitTypeAsAnnotationType(e, p);
case CLASS:
return visitTypeAsClass(e, p);
case ENUM:
return visitTypeAsEnum(e, p);
case INTERFACE:
return visitTypeAsInterface(e, p);
default:
throw new AssertionError("Bad kind " + k + " for TypeElement" + e);
}
}
public R visitTypeAsAnnotationType(TypeElement e, P p) {
return defaultAction(e, p);
}
public R visitTypeAsClass(TypeElement e, P p) {
return defaultAction(e, p);
}
public R visitTypeAsEnum(TypeElement e, P p) {
return defaultAction(e, p);
}
public R visitTypeAsInterface(TypeElement e, P p) {
return defaultAction(e, p);
}
/**
@Override
public R visitVariable(VariableElement e, P p) {
ElementKind k = e.getKind();
switch(k) {
case ENUM_CONSTANT:
return visitVariableAsEnumConstant(e, p);
case EXCEPTION_PARAMETER:
return visitVariableAsExceptionParameter(e, p);
case FIELD:
return visitVariableAsField(e, p);
case LOCAL_VARIABLE:
return visitVariableAsLocalVariable(e, p);
case PARAMETER:
return visitVariableAsParameter(e, p);
case RESOURCE_VARIABLE:
return visitVariableAsResourceVariable(e, p);
default:
throw new AssertionError("Bad kind " + k + " for VariableElement" + e);
}
}
public R visitVariableAsEnumConstant(VariableElement e, P p) {
return defaultAction(e, p);
}
public R visitVariableAsExceptionParameter(VariableElement e, P p) {
return defaultAction(e, p);
}
public R visitVariableAsField(VariableElement e, P p) {
return defaultAction(e, p);
}
public R visitVariableAsLocalVariable(VariableElement e, P p) {
return defaultAction(e, p);
}
public R visitVariableAsParameter(VariableElement e, P p) {
return defaultAction(e, p);
}
public R visitVariableAsResourceVariable(VariableElement e, P p) {
return visitUnknown(e, p);
}
@Override
public R visitExecutable(ExecutableElement e, P p) {
ElementKind k = e.getKind();
switch(k) {
case CONSTRUCTOR:
return visitExecutableAsConstructor(e, p);
case INSTANCE_INIT:
return visitExecutableAsInstanceInit(e, p);
case METHOD:
return visitExecutableAsMethod(e, p);
case STATIC_INIT:
return visitExecutableAsStaticInit(e, p);
default:
throw new AssertionError("Bad kind " + k + " for ExecutableElement" + e);
}
}
public R visitExecutableAsConstructor(ExecutableElement e, P p) {
return defaultAction(e, p);
}
public R visitExecutableAsInstanceInit(ExecutableElement e, P p) {
return defaultAction(e, p);
}
public R visitExecutableAsMethod(ExecutableElement e, P p) {
return defaultAction(e, p);
}
public R visitExecutableAsStaticInit(ExecutableElement e, P p) {
return defaultAction(e, p);
}
@Override
public R visitTypeParameter(TypeParameterElement e, P p) {
assert e.getKind() == TYPE_PARAMETER: "Bad kind on TypeParameterElement";
return defaultAction(e, p);
}
}
ElementKindVisitor7
程序元素类型的 visitor,适用于jdk1.7.
@SupportedSourceVersion(RELEASE_7)
public class ElementKindVisitor7<R, P> extends ElementKindVisitor6<R, P> {
protected ElementKindVisitor7() {
super(null);
}
protected ElementKindVisitor7(R defaultValue) {
super(defaultValue);
}
@Override
public R visitVariableAsResourceVariable(VariableElement e, P p) {
return defaultAction(e, p);
}
}ElementKindVisitor8
程序元素类型的 visitor,适用于jdk1.8.
@SupportedSourceVersion(RELEASE_8)
public class ElementKindVisitor8<R, P> extends ElementKindVisitor7<R, P> {
protected ElementKindVisitor8() {
super(null);
}
protected ElementKindVisitor8(R defaultValue) {
super(defaultValue);
}
}
接下来我们来看下AbstractAnnotationValueVisitor6的继承结构,如图:
AbstractAnnotationValueVisitor6
注解值的visitor,用于jdk 1.6
@SupportedSourceVersion(RELEASE_6)
public abstract class AbstractAnnotationValueVisitor6<R, P>
implements AnnotationValueVisitor<R, P> {
protected AbstractAnnotationValueVisitor6() {}
public final R visit(AnnotationValue av, P p) {
return av.accept(this, p);
}
public final R visit(AnnotationValue av) {
return av.accept(this, null);
}
public R visitUnknown(AnnotationValue av, P p) {
throw new UnknownAnnotationValueException(av, p);
}
}
AbstractAnnotationValueVisitor7
注解值的visitor,用于jdk 1.7
@SupportedSourceVersion(RELEASE_7)
public abstract class AbstractAnnotationValueVisitor7<R, P> extends AbstractAnnotationValueVisitor6<R, P> {
protected AbstractAnnotationValueVisitor7() {
super();
}
}AbstractAnnotationValueVisitor8
注解值的visitor,用于jdk 1.8
@SupportedSourceVersion(RELEASE_8)
public abstract class AbstractAnnotationValueVisitor8<R, P> extends AbstractAnnotationValueVisitor7<R, P> {
/**
* Constructor for concrete subclasses to call.
*/
protected AbstractAnnotationValueVisitor8() {
super();
}
}SimpleAnnotationValueVisitor6
针对jdk 1.6的注解值的visitor。所有的visit方法都会调用defaultAction方法.
@SupportedSourceVersion(RELEASE_6)
public class SimpleAnnotationValueVisitor6<R, P>
extends AbstractAnnotationValueVisitor6<R, P> {
protected final R DEFAULT_VALUE;
protected SimpleAnnotationValueVisitor6() {
super();
DEFAULT_VALUE = null;
}
protected SimpleAnnotationValueVisitor6(R defaultValue) {
super();
DEFAULT_VALUE = defaultValue;
}
protected R defaultAction(Object o, P p) {
return DEFAULT_VALUE;
}
public R visitBoolean(boolean b, P p) {
return defaultAction(b, p);
}
public R visitByte(byte b, P p) {
return defaultAction(b, p);
}
public R visitChar(char c, P p) {
return defaultAction(c, p);
}
public R visitDouble(double d, P p) {
return defaultAction(d, p);
}
public R visitFloat(float f, P p) {
return defaultAction(f, p);
}
public R visitInt(int i, P p) {
return defaultAction(i, p);
}
public R visitLong(long i, P p) {
return defaultAction(i, p);
}
public R visitShort(short s, P p) {
return defaultAction(s, p);
}
public R visitString(String s, P p) {
return defaultAction(s, p);
}
public R visitType(TypeMirror t, P p) {
return defaultAction(t, p);
}
public R visitEnumConstant(VariableElement c, P p) {
return defaultAction(c, p);
}
public R visitAnnotation(AnnotationMirror a, P p) {
return defaultAction(a, p);
}
public R visitArray(List<? extends AnnotationValue> vals, P p) {
return defaultAction(vals, p);
}
}
SimpleAnnotationValueVisitor7
针对jdk 1.7的注解值的visitor。所有的visit方法都会调用defaultAction方法.
@SupportedSourceVersion(RELEASE_7)
public class SimpleAnnotationValueVisitor7<R, P> extends SimpleAnnotationValueVisitor6<R, P> {
protected SimpleAnnotationValueVisitor7() {
super(null);
}
protected SimpleAnnotationValueVisitor7(R defaultValue) {
super(defaultValue);
}
}SimpleAnnotationValueVisitor8
针对jdk 1.8的注解值的visitor。
@SupportedSourceVersion(RELEASE_8)
public class SimpleAnnotationValueVisitor8<R, P> extends SimpleAnnotationValueVisitor7<R, P> {
protected SimpleAnnotationValueVisitor8() {
super(null);
}
protected SimpleAnnotationValueVisitor8(R defaultValue) {
super(defaultValue);
}
}
ElementFilter
过滤器，用于从元素集合中选择感兴趣元素。返回的集合和列表是新集合，并使用该参数作为后备存储。该类中的方法不保证防止参数的并发修改。返回的集合和列表是可变的，但对于并发访问来说是不安全的。返回集具有与方法的参数相同的迭代顺序。
如果将包含NULL的迭代项和集合作为参数传递给该类中的方法，则将引发NullPointerException异常。
注意，静态导入语句可以使对该类中的方法的调用文本更加简洁；举例:
import static javax.lang.model.util.ElementFilter.*;
...
List<VariableElement> fs = fieldsIn(someClass.getEnclosedElements());代码如下:
public class ElementFilter {
private ElementFilter() {} // Do not instantiate.
private static final Set<ElementKind> CONSTRUCTOR_KIND =
Collections.unmodifiableSet(EnumSet.of(ElementKind.CONSTRUCTOR));
private static final Set<ElementKind> FIELD_KINDS =
Collections.unmodifiableSet(EnumSet.of(ElementKind.FIELD,
ElementKind.ENUM_CONSTANT));
private static final Set<ElementKind> METHOD_KIND =
Collections.unmodifiableSet(EnumSet.of(ElementKind.METHOD));
private static final Set<ElementKind> PACKAGE_KIND =
Collections.unmodifiableSet(EnumSet.of(ElementKind.PACKAGE));
private static final Set<ElementKind> TYPE_KINDS =
Collections.unmodifiableSet(EnumSet.of(ElementKind.CLASS,
ElementKind.ENUM,
ElementKind.INTERFACE,
ElementKind.ANNOTATION_TYPE));
public static List<VariableElement>
fieldsIn(Iterable<? extends Element> elements) {
return listFilter(elements, FIELD_KINDS, VariableElement.class);
}
public static Set<VariableElement>
fieldsIn(Set<? extends Element> elements) {
return setFilter(elements, FIELD_KINDS, VariableElement.class);
}
public static List<ExecutableElement>
constructorsIn(Iterable<? extends Element> elements) {
return listFilter(elements, CONSTRUCTOR_KIND, ExecutableElement.class);
}
public static Set<ExecutableElement>
constructorsIn(Set<? extends Element> elements) {
return setFilter(elements, CONSTRUCTOR_KIND, ExecutableElement.class);
}
public static List<ExecutableElement>
methodsIn(Iterable<? extends Element> elements) {
return listFilter(elements, METHOD_KIND, ExecutableElement.class);
}
public static Set<ExecutableElement>
methodsIn(Set<? extends Element> elements) {
return setFilter(elements, METHOD_KIND, ExecutableElement.class);
}
public static List<TypeElement>
typesIn(Iterable<? extends Element> elements) {
return listFilter(elements, TYPE_KINDS, TypeElement.class);
}
/**
public static Set<TypeElement>
typesIn(Set<? extends Element> elements) {
return setFilter(elements, TYPE_KINDS, TypeElement.class);
}
public static List<PackageElement>
packagesIn(Iterable<? extends Element> elements) {
return listFilter(elements, PACKAGE_KIND, PackageElement.class);
}
public static Set<PackageElement>
packagesIn(Set<? extends Element> elements) {
return setFilter(elements, PACKAGE_KIND, PackageElement.class);
}
// Assumes targetKinds and E are sensible.
private static <E extends Element> List<E> listFilter(Iterable<? extends Element> elements,
Set<ElementKind> targetKinds,
Class<E> clazz) {
List<E> list = new ArrayList<E>();
for (Element e : elements) {
if (targetKinds.contains(e.getKind()))
list.add(clazz.cast(e));
}
return list;
}
// Assumes targetKinds and E are sensible.
private static <E extends Element> Set<E> setFilter(Set<? extends Element> elements,
Set<ElementKind> targetKinds,
Class<E> clazz) {
// Return set preserving iteration order of input set.
Set<E> set = new LinkedHashSet<E>();
for (Element e : elements) {
if (targetKinds.contains(e.getKind()))
set.add(clazz.cast(e));
}
return set;
}
}
总体说来,该类首先声明了5个set,分别对应构造器,字段,方法，包，类型.然后针对这5种类型的过滤分别声明了2种类型的api,一种是针对Iterable,一种是针对Set.方法的实现还是比较简单的…属于一看就懂的…