JDK的Parser来解析Java源代码详解

本文介绍了如何使用JDK自带的编译API解析Java源代码,提取变量和类信息。通过具体示例展示了如何访问和打印Java源文件中的变量名、类型及注解。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

在JDK中,自带了一套相关的编译API,可以在Java中发起编译流程,解析Java源文件然后获取其语法树,在JDK的tools.jar(OSX下可以在/Library/Java/JavaVirtualMachines/jdk_version/Contents/Home/lib中找到)中包含着这整套API,但是这却不是Oracle和OpenJDK发布中的公开API,因此对于这套API,并没有官方的正式文档来进行说明。但是,也有不少项目利用了这套API来做了不少事情,例如大名鼎鼎的lombok使用了这套API在Annotation Processing阶段修改了源代码中的语法树,最终结果相当于直接在源文件中插入了新的代码!

由于这套API目前缺少相关文档,使用起来比较困难,例如,解析源代码中的所有变量,并打印出来:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class JavaParser {
  
  private static final String path = "User.java" ;
  
  private JavacFileManager fileManager;
  private JavacTool javacTool;
  
  public JavaParser() {
   Context context = new Context();
   fileManager = new JavacFileManager(context, true , Charset.defaultCharset());
   javacTool = new JavacTool();
  }
  
  public void parseJavaFiles() {
   Iterable<!--? extends JavaFileObject--> files = fileManager.getJavaFileObjects(path);
   JavaCompiler.CompilationTask compilationTask = javacTool.getTask( null , fileManager, null , null , null , files);
   JavacTask javacTask = (JavacTask) compilationTask;
   try {
    Iterable<!--? extends CompilationUnitTree--> result = javacTask.parse();
    for (CompilationUnitTree tree : result) {
     tree.accept( new SourceVisitor(), null );
  
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
  
  static class SourceVisitor extends TreeScanner< void , void = "" > {
  
   private String currentPackageName = null ;
  
   @Override
   public Void visitCompilationUnit(CompilationUnitTree node, Void aVoid) { 
    return super .visitCompilationUnit(node, aVoid);
   }
  
   @Override
   public Void visitVariable(VariableTree node, Void aVoid) {
    formatPtrln( "variable name: %s, type: %s, kind: %s, package: %s" ,
      node.getName(), node.getType(), node.getKind(), currentPackageName);
    return null ;
   }
  }
  
  public static void formatPtrln(String format, Object... args) {
   System.out.println(String.format(format, args));
  }
  
  public static void main(String[] args) {
  
   new JavaParser().parseJavaFiles();
  }
}</ void ,>

其中 User.java的代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.ragnarok.javaparser;
  
import com.sun.istack.internal.Nullable;
import java.lang.Override;
  
public class User {
  
  @Nullable
  private String foo = "123123" ;
  private Foo a;
  
  public void UserMethod() {}
  
  static class Foo {
   private String fooString = "123123" ;
  
   public void FooMethod() {}
  }
}

执行上面的JavaParser结果如下:

?
1
2
3
variable: foo, annotaion: Nullable
variable name: foo, type: String, kind: VARIABLE, package : com.ragnarok.javaparser
variable name: a, type: Foo, kind: VARIABLE, package : com.ragnarok.javaparser

这里我们是首先通过JavaCompiler.CompilationTask解析了源文件之后,再使用自定义的SourceVisitor(继承自TreeScanner)来对源代码的结构进行访问,在SourceVisitor类中,通过重载visitVariable来对一个编译单元(单个源代码文件)进行解析,访问其中的所有的变量,这里可以看出,我们没有办法拿到这个变量类型的全限定名(包含包名),只能拿到的对应的简单名字,因此,类型的确定需要外部实现自行确定,例如可以通过记录类所在的包名,递归的搜索整个源代码目录来跟踪所有类的全限定名,查找import中是否包含对应的类型等。

TreeScanner中除了visitVariable方法外,还包含了大量其他的visitXYZ方法,例如,可以遍历所有的import,方法定义,Annotation等,更具体可以查看OpenJDK中关于这个的源代码

这里再来看下另外一个例子,重载visitClass方法,访问所有的内部类以及类本身:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override
public Void visitClass(ClassTree node, Void aVoid) {
  formatPtrln( "class name: %s" , node.getSimpleName());
  for (Tree member : node.getMembers()) {
   if (member instanceof VariableTree) {
    VariableTree variable = (VariableTree) member;
    List<!--? extends AnnotationTree--> annotations = variable.getModifiers().getAnnotations();
    if (annotations.size() > 0 ) {
     formatPtrln( "variable: %s, annotaion: %s" , variable.getName(), annotations.get( 0 ).getAnnotationType());
    } else {
     formatPtrln( "variable: %s" , variable.getName());
    }   
   }
  }
  return super .visitClass(node, aVoid);
  }

这里简单的打印了类名以及变量的名称,类型,annotation类型,执行上面的代码,结果如下:

?
1
2
3
4
5
class name: User
variable: foo, annotaion: Nullable
variable: a
class name: Foo
variable: fooString

可以看出我们把类名以及类中的变量都打印了出来。而在visitClass方法中,我们可以通过getMembers方法拿到类中所有的成员,包括变量,方法,annotation等,分别对应着不同的类型,例如变量就对应着VariableTree类型,方法就对应的MethodTree类型。

总得来说,虽然实际上使用并不算特别复杂,但是由于缺少文档,对使用造成了很大的障碍,而且目前所介绍的只是这套API的一少部分,后续我将会继续研究这套API的相关函数。


转自:http://www.jb51.net/article/92989.htm

java精神(基于函数式组合子逻辑的javaparser框架) 一。 释名。 为什么叫精神? 如果你熟悉c++,那么你可能知道一个叫做”spirit”的parser库。它利用c++的模板元编程能力,使用c++语言本身提供了一个递归下降文法解析的框架。 我这里介绍的jparsec库,就是一个java里面的递归下降文法解析框架。 不过,它并非是spirit的java版本。 Jparsec的蓝本来自Haskell语言的parsec库。Parsec是一个基于monad的parser组合子库。 这个库的目的是要在java中提供一个类似parsec, spirit的库,这种组合子库并非c++的专利,java/c#也可以做到。这个库还将在java5.0上被改写,类型安全上它将也不再逊色于c++。 那么,为什么叫“函数式”呢?java是面向对象的嘛。 如果你使用过haskell, lisp等语言,这个函数式不用解释你也知道是怎么回事了。 如果你是一个老牌的c++/java程序员,那么这里还要稍微解释一下。当然如果您对这些虚头八脑的名词不感兴趣,那么,你尽可以跳过这一章,不知道什么是“函数式”,并不会影响你对这个库的理解的。 C++这几年随着gp的普及,“函数式”这个老孔乙己逐渐又被人从角落里面拽了出来。一个c++程序员所熟悉的“函数式”很可能是stl的for_each, transform,count_if这些函数。 怎么说呢,就象我不能否定str.length()这个调用属于OO一样,我也无法说for_each, transform不是函数式。 但是,“函数式”的精髓不在于此。 一般归纳起来,就像我们说OO是什么多态,封装,继承一样,“函数式”的特征被总结为: 1。无副作用。 2。高阶函数。 3。延迟计算 而最最有意义的(至少我认为如此),是基于高阶函数的函数组合能力。一些人把这叫做glue。 简短地说,什么让函数式编程如此强大?是用简单的函数组合出复杂函数的能力。 我可以想象,说到这里,你还是一头雾水。“什么是组合?1+1不是也把两个1组合成2了吗?new A(new B(), new C())不也是从B和C组合成A了?”
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值