jdt之java源文件解析

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 DNS,旗舰版 1个月
全局流量管理 GTM,标准版 1个月
简介:
1、加入jdt的相关依赖
 
  1. <dependency> 
  2.             <groupId>org.eclipse.tycho</groupId> 
  3.             <artifactId>org.eclipse.jdt.core</artifactId> 
  4.             <version>3.6.2.v_A76_R36x</version> 
  5.         </dependency> 
  6.         <dependency> 
  7.             <groupId>org.eclipse.core</groupId> 
  8.             <artifactId>org.eclipse.core.jobs</artifactId> 
  9.             <version>3.5.0.v20100515</version> 
  10.         </dependency> 
  11.         <dependency> 
  12.             <groupId>org.eclipse.core</groupId> 
  13.             <artifactId>org.eclipse.core.contenttype</artifactId> 
  14.             <version>3.4.100.v20100505-1235</version> 
  15.         </dependency> 
  16.         <dependency> 
  17.             <groupId>org.eclipse.core</groupId> 
  18.             <artifactId>org.eclipse.core.resources</artifactId> 
  19.             <version>3.6.0.v20100526-0737</version> 
  20.         </dependency> 
  21.         <dependency> 
  22.             <groupId>org.eclipse.core</groupId> 
  23.             <artifactId>org.eclipse.core.runtime</artifactId> 
  24.             <version>3.6.0.v20100505</version> 
  25.         </dependency> 
  26.         <dependency> 
  27.             <groupId>org.eclipse.osgi</groupId> 
  28.             <artifactId>org.eclipse.osgi</artifactId> 
  29.             <version>3.6.0.v20100517</version> 
  30.         </dependency> 
原文解释为:
 
Method declaration AST node type. A method declaration is the union of a method declaration and a constructor declaration. For JLS2:
 MethodDeclaration:
    [ Javadoc ] { Modifier } ( Type | void ) Identifier (
        [ FormalParameter 
 		     { , FormalParameter } ] ) {[ ] }
        [ throws TypeName { , TypeName } ] ( Block | ; )
 ConstructorDeclaration:
    [ Javadoc ] { Modifier } Identifier (
 		  [ FormalParameter
 			 { , FormalParameter } ] )
        [throws TypeName { , TypeName } ] Block
 
For JLS3, type parameters and reified modifiers (and annotations) were added:
 MethodDeclaration:
    [ Javadoc ] { ExtendedModifier }
		  [ < TypeParameter { , TypeParameter } > ]
        ( Type | void ) Identifier (
        [ FormalParameter 
 		     { , FormalParameter } ] ) {[ ] }
        [ throws TypeName { , TypeName } ] ( Block | ; )
 ConstructorDeclaration:
    [ Javadoc ] { ExtendedModifier } Identifier (
 		  [ FormalParameter
 			 { , FormalParameter } ] )
 
3、代码样例
 
 
  1. import java.io.File; 
  2. import java.io.FileInputStream; 
  3. import java.io.IOException; 
  4. import java.util.List; 
  5.  
  6. import org.eclipse.jdt.core.dom.AST; 
  7. import org.eclipse.jdt.core.dom.ASTParser; 
  8. import org.eclipse.jdt.core.dom.CompilationUnit; 
  9. import org.eclipse.jdt.core.dom.FieldDeclaration; 
  10. import org.eclipse.jdt.core.dom.ImportDeclaration; 
  11. import org.eclipse.jdt.core.dom.MethodDeclaration; 
  12. import org.eclipse.jdt.core.dom.Modifier; 
  13. import org.eclipse.jdt.core.dom.PackageDeclaration; 
  14. import org.eclipse.jdt.core.dom.TypeDeclaration; 
  15. import org.eclipse.jdt.core.dom.VariableDeclarationFragment; 
 
  1. public static void main(String[] args) throws Exception { 
  2.       String content = read("D:\\HelloWorld.java"); //java源文件
  3.       //创建解析器  
  4.       ASTParser parsert = ASTParser.newParser(AST.JLS3); 
  5.       //设定解析器的源代码字符  
  6.       parsert.setSource(content.toCharArray()); 
  7.       //使用解析器进行解析并返回AST上下文结果(CompilationUnit为根节点)  
  8.       CompilationUnit result = (CompilationUnit) parsert.createAST(null); 
  9.  
  10.       //获取类型  
  11.       List types = result.types(); 
  12.       //取得类型声明  
  13.       TypeDeclaration typeDec = (TypeDeclaration) types.get(0); 
  14.  
  15.       //##############获取源代码结构信息#################  
  16.       //引用import  
  17.       List importList = result.imports(); 
  18.       //取得包名  
  19.       PackageDeclaration packetDec = result.getPackage(); 
  20.       //取得类名  
  21.       String className = typeDec.getName().toString(); 
  22.       //取得函数(Method)声明列表  
  23.       MethodDeclaration methodDec[] = typeDec.getMethods(); 
  24.       //取得函数(Field)声明列表  
  25.       FieldDeclaration fieldDec[] = typeDec.getFields(); 
  26.  
  27.       //输出包名  
  28.       System.out.println("包:"); 
  29.       System.out.println(packetDec.getName()); 
  30.       //输出引用import  
  31.       System.out.println("引用import:"); 
  32.       for (Object obj : importList) { 
  33.           ImportDeclaration importDec = (ImportDeclaration) obj; 
  34.           System.out.println(importDec.getName()); 
  35.       } 
  36.       //输出类名  
  37.       System.out.println("类:"); 
  38.       System.out.println(className); 
  39.       //循环输出函数名称  
  40.       System.out.println("========================"); 
  41.       System.out.println("函数:"); 
  42.       for (MethodDeclaration method : methodDec) { 
  43.          /* System.out.println(method.getName()); 
  44.           System.out.println("body:"); 
  45.           System.out.println(method.getBody()); 
  46.           System.out.println("Javadoc:" + method.getJavadoc()); 
  47.  
  48.           System.out.println("Body:" + method.getBody()); 
  49.  
  50.           System.out.println("ReturnType:" + method.getReturnType());*/ 
  51.           System.out.println("============="); 
  52.           System.out.println(method); 
  53.       } 
  54.  
  55.       //循环输出变量  
  56.       System.out.println("变量:"); 
  57.       for (FieldDeclaration fieldDecEle : fieldDec) { 
  58.           //public static  
  59.           for (Object modifiObj : fieldDecEle.modifiers()) { 
  60.               Modifier modify = (Modifier) modifiObj; 
  61.               System.out.print(modify + "-"); 
  62.           } 
  63.           System.out.println(fieldDecEle.getType()); 
  64.           for (Object obj : fieldDecEle.fragments()) { 
  65.               VariableDeclarationFragment frag = (VariableDeclarationFragment) obj; 
  66.               System.out.println("[FIELD_NAME:]" + frag.getName()); 
  67.           } 
  68.       } 
  69.   } 
  70.  
  71.   private static String read(String filename) throws IOException { 
  72.       File file = new File(filename); 
  73.       byte[] b = new byte[(int) file.length()]; 
  74.       FileInputStream fis = new FileInputStream(file); 
  75.       fis.read(b); 
  76.       return new String(b); 
  77.  
  78.   } 
运行代码:
 
  1. 函数: 
  2. ============= 
  3. /**  
  4.  * 测试相关类 jdt api测试 
  5.  * @param null 
  6.  * @expected 1 
  7.  */ 
  8. @Test public void test1(){ 
  9.   assertEquals(1,1); 
  10.  
  11. ============= 
  12. /**  
  13.  * 测试ignore情况 
  14.  */ 
  15. @Test @Ignore public void test2(){ 
  16.   assertEquals(1,1); 
4、结论:jdt的AST.JLS3已经满足对java method处理的需求,满足tc转换工具的使用要求。
 
5、jdt解析java文件的BlockComment、LineComment丢失


本文转自 tianya23 51CTO博客,原文链接:http://blog.51cto.com/tianya23/615291,如需转载请自行联系原作者
相关文章
|
4天前
|
安全 Java 测试技术
🎉Java零基础:全面解析枚举的强大功能
【10月更文挑战第19天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
95 60
|
4天前
|
Java 程序员 开发者
Java中的异常处理机制深度解析####
本文将深入浅出地探讨Java编程语言中异常处理的核心概念与实践策略,旨在帮助开发者更好地理解如何构建健壮的应用程序。通过剖析异常体系结构、掌握有效的异常捕获与处理技巧,以及学习最佳实践,读者能够提升代码质量,减少运行时错误,从而增强软件的稳定性和用户体验。 ####
|
3天前
|
存储 缓存 安全
🌟Java零基础:深入解析Java序列化机制
【10月更文挑战第20天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
13 3
|
2天前
|
算法 Java 数据库连接
Java连接池技术,从基础概念出发,解析了连接池的工作原理及其重要性
本文详细介绍了Java连接池技术,从基础概念出发,解析了连接池的工作原理及其重要性。连接池通过复用数据库连接,显著提升了应用的性能和稳定性。文章还展示了使用HikariCP连接池的示例代码,帮助读者更好地理解和应用这一技术。
11 1
|
4天前
|
设计模式 SQL 安全
Java编程中的单例模式深入解析
【10月更文挑战第24天】在软件工程中,单例模式是设计模式的一种,它确保一个类只有一个实例,并提供一个全局访问点。本文将探讨如何在Java中使用单例模式,并分析其优缺点以及适用场景。
8 0
|
21天前
|
缓存 Java 程序员
Map - LinkedHashSet&Map源码解析
Map - LinkedHashSet&Map源码解析
53 0
|
21天前
|
算法 Java 容器
Map - HashSet & HashMap 源码解析
Map - HashSet & HashMap 源码解析
47 0
|
21天前
|
存储 Java C++
Collection-PriorityQueue源码解析
Collection-PriorityQueue源码解析
50 0
|
21天前
|
安全 Java 程序员
Collection-Stack&Queue源码解析
Collection-Stack&Queue源码解析
60 0
|
1天前
|
消息中间件 缓存 安全
Future与FutureTask源码解析,接口阻塞问题及解决方案
【11月更文挑战第5天】在Java开发中,多线程编程是提高系统并发性能和资源利用率的重要手段。然而,多线程编程也带来了诸如线程安全、死锁、接口阻塞等一系列复杂问题。本文将深度剖析多线程优化技巧、Future与FutureTask的源码、接口阻塞问题及解决方案,并通过具体业务场景和Java代码示例进行实战演示。
16 3

推荐镜像

更多