jdt之java源文件解析

本文涉及的产品
全局流量管理 GTM,标准版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 DNS,旗舰版 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,如需转载请自行联系原作者
相关文章
|
3天前
|
人工智能 自然语言处理 Java
FastExcel:开源的 JAVA 解析 Excel 工具,集成 AI 通过自然语言处理 Excel 文件,完全兼容 EasyExcel
FastExcel 是一款基于 Java 的高性能 Excel 处理工具,专注于优化大规模数据处理,提供简洁易用的 API 和流式操作能力,支持从 EasyExcel 无缝迁移。
44 9
FastExcel:开源的 JAVA 解析 Excel 工具,集成 AI 通过自然语言处理 Excel 文件,完全兼容 EasyExcel
|
10天前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性,但不能保证原子性。它通过内存屏障实现,避免指令重排序,确保线程间数据一致。相比`synchronized`,`volatile`性能更优,适用于简单状态标记和某些特定场景,如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念,包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
Java 并发编程——volatile 关键字解析
|
8天前
|
Java 数据库连接 Spring
反射-----浅解析(Java)
在java中,我们可以通过反射机制,知道任何一个类的成员变量(成员属性)和成员方法,也可以堆任何一个对象,调用这个对象的任何属性和方法,更进一步我们还可以修改部分信息和。
|
30天前
|
存储 算法 Java
Java内存管理深度解析####
本文深入探讨了Java虚拟机(JVM)中的内存分配与垃圾回收机制,揭示了其高效管理内存的奥秘。文章首先概述了JVM内存模型,随后详细阐述了堆、栈、方法区等关键区域的作用及管理策略。在垃圾回收部分,重点介绍了标记-清除、复制算法、标记-整理等多种回收算法的工作原理及其适用场景,并通过实际案例分析了不同GC策略对应用性能的影响。对于开发者而言,理解这些原理有助于编写出更加高效、稳定的Java应用程序。 ####
|
30天前
|
存储 监控 算法
Java虚拟机(JVM)垃圾回收机制深度解析与优化策略####
本文旨在深入探讨Java虚拟机(JVM)的垃圾回收机制,揭示其工作原理、常见算法及参数调优方法。通过剖析垃圾回收的生命周期、内存区域划分以及GC日志分析,为开发者提供一套实用的JVM垃圾回收优化指南,助力提升Java应用的性能与稳定性。 ####
|
2月前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性,极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是spring.factories文件的解析源码API机制。
86 2
|
3月前
|
缓存 Java 程序员
Map - LinkedHashSet&Map源码解析
Map - LinkedHashSet&Map源码解析
87 0
|
3月前
|
算法 Java 容器
Map - HashSet & HashMap 源码解析
Map - HashSet & HashMap 源码解析
68 0
|
9天前
|
存储 设计模式 算法
【23种设计模式·全精解析 | 行为型模式篇】11种行为型模式的结构概述、案例实现、优缺点、扩展对比、使用场景、源码解析
行为型模式用于描述程序在运行时复杂的流程控制,即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务,它涉及算法与对象间职责的分配。行为型模式分为类行为模式和对象行为模式,前者采用继承机制来在类间分派行为,后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象行为模式比类行为模式具有更大的灵活性。 行为型模式分为: • 模板方法模式 • 策略模式 • 命令模式 • 职责链模式 • 状态模式 • 观察者模式 • 中介者模式 • 迭代器模式 • 访问者模式 • 备忘录模式 • 解释器模式
【23种设计模式·全精解析 | 行为型模式篇】11种行为型模式的结构概述、案例实现、优缺点、扩展对比、使用场景、源码解析
|
9天前
|
设计模式 存储 安全
【23种设计模式·全精解析 | 创建型模式篇】5种创建型模式的结构概述、实现、优缺点、扩展、使用场景、源码解析
结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式,前者采用继承机制来组织接口和类,后者釆用组合或聚合来组合对象。由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象结构型模式比类结构型模式具有更大的灵活性。 结构型模式分为以下 7 种: • 代理模式 • 适配器模式 • 装饰者模式 • 桥接模式 • 外观模式 • 组合模式 • 享元模式
【23种设计模式·全精解析 | 创建型模式篇】5种创建型模式的结构概述、实现、优缺点、扩展、使用场景、源码解析

推荐镜像

更多