Question

我正在尝试获取ClassTree-Object的超类的完全限定名称。目前我正在使用toString（） - 方法：

public class ClassScanner extends TreePathScanner<Object, Trees> {

    @Override
    public Object visitClass(ClassTree ct, Trees trees) {
        TreePath currentPath = getCurrentPath();
        TypeElement typeElement = (TypeElement) trees.getElement(currentPath);
        String s = typeElement.getSuperclass().toString();
        System.out.println(s);
        return super.visitClass(ct, trees);
    }
}

但这似乎不是未来的证明方法。另外，我必须自己提取名称，包，泛型类型......还有其他选择吗？

由于

Answer 1

怎么样

    Tree extendsClassTree = classTree.getExtendsClause();
    if (extendsClassTree != null) {
        superClassName = extendsClassTree.toString();
    } else {
        superClassName = "java.lang.Object";
    }

（借鉴here：））

Answer 2

好的，我找到了解决方法：

在处理器中，将rootElements存储在某处：

@SupportedSourceVersion(SourceVersion.RELEASE_8)
@SupportedAnnotationTypes("*")
public class AnnotationProcessor extends AbstractProcessor {

    private Trees trees;
    private List<TreeScanner<?, Trees>> scanners = new LinkedList<>();

    public void addScanner(TreeScanner<?, Trees> scanner) {
        scanners.add(scanner);
    }

    public void removeScanner(TreeScanner<?, Trees> scanner) {
        scanners.remove(scanner);
    }

    @Override
    public synchronized void init(final ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        trees = Trees.instance(processingEnvironment);
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (!roundEnv.processingOver()) {
            ASTUtils.setRootElements(roundEnv.getRootElements());
            for (final Element element : roundEnv.getRootElements()) {
                CompilationUnitTree compilationUnit = trees.getPath(element).getCompilationUnit();
                for (TreeScanner<?, Trees> scanner : scanners) {
                    scanner.scan(compilationUnit, trees);
                }
            }
        }
        return true;
    }
}

就我而言，我将它们存储在助手类ASTUtils：

中

public class ASTUtils {

    private static Set<? extends Element> rootElements = new HashSet<>();

    public static Set<? extends Element> getRootElements() {
        return rootElements;
    }

    public static void setRootElements(Set<? extends Element> rootElements) {
        ASTUtils.rootElements = rootElements;
    }
}

然后你可以确定TreePath：

public static TreePath find(Tree tree, Trees trees) {
    for (Element e : ASTUtils.getRootElements()) {
        CompilationUnitTree compilationUnit = trees.getPath(e).getCompilationUnit();
        TreePath path = TreePath.getPath(compilationUnit, tree);
        if (path != null) {
            Tree classTree = trees.getTree(trees.getElement(path));
            if (classTree != null && classTree.getKind() == kind) {
                return path;
            }
        }
    }
    return null;
}

现在可以使用超类的TreePath来获取相应的CompilationUnitTree并读取包或获取TypeElement并读取限定名称（参见之前的答案/初始帖子）。

Java编译器树API：获取完全限定的超类名称

2 个答案: