基于jdt的源码搜索

Eclipse 为程序员提供了强大的文本搜索功能，程序员可以方便 的在工作空间中搜索到需要的 JAVA 代码或者文本。但是有时候，程序员希望在 .class 文件源码或者普通文本文件中搜索某个字符串，而这些文件包含于 Jar 文件中，此时 Eclipse 就无法满足要求。比如，用户试图寻找 UI 上显示的某 字符串的定义位置，这就需要在 Jar 文件内的普通文本文件 , 以及 .class 文 件源码中搜索。这些 Jar 文件包含于项目类路径中，这个功能在 RCP 开发中是 经常需要的，而 Eclipse 目前还未提供这个特性。本文通过使用 JDT（Java Development Toolkit）中与 Jar 相关的接口，解决了这个问题，并给出示例及 程序。
Eclipse 中搜索的原理
Eclipse 采用 Lucene 技术开发其搜索内核， 该内核通过对关键字进行索引，快速定位目标文件。例如，Eclipse 会对 JAVA 源文件中的类名、字段名、方法名等进行索引，当程序员使用 Open Type 功能 （快捷键：CTRL+SHIFT+T）进行类搜索时，便可以通过类名这个索引字段进行快 速搜索 ; 在使用 JAVA 搜索（Java Search）功能时，Eclipse 也会让用户指定 具体的索引字段（Search For），如可以选择方法名、类名、字段名、包名、构 造器名等，Eclipse 会根据选择的索引字段与用户的输入，快速搜索到源代码。
Eclipse 在提供 Jar 源代码搜索方面的限制
Eclipse 提供了文 件搜索（File Search）的功能，用来搜索指定范围 ( 项目、工作空间等 ) 内 的文本文件。这个功能并没有根据某些特殊关键字进行索引。因为对于任意字符 串的搜索，是无法找到特定关键字进行索引的。因此为了提高搜索效率， Eclipse 对于任意字符串的搜索范围仅限于用户编写的文本文件，而没有对项目 所依赖的 Jar 文件中的类的源代码进行搜索。因为 Jar 源代码的数量往往数量 庞大，搜索它们将是一个相当费时的操作。但是在很多情况下，程序员有必要进 行类源代码的搜索，通过查看需要的源代码解决一些问题，Eclipse 目前提供的 搜索功能就无法满足这样的需求。
JDT 中 Jar 文件相关的类结构图分析
下面两图展示了 JDT 中与 Jar 文件处理相关的类，从图中，可以清晰 的了解它们的层次、包含和对应关系。
图 1. JDT 中与 Jar 文件相关的 UML 类结构图
图 2. JDT 中与 Jar 文件相关的类结构对应图

上图描述了各个节点之间的层次、包含和对应关系，了解这些信息， 对文章下一部分的阅读是必要的。Java 项目，Jar 文件，Jar 文件中的包，Jar 文件中的普通文件夹，class 文件和非 class 文件分别对应于 IJavaProject， JarPackageFragmentRoot，JarPackageFragment，JarEntryDirectory， IClassFile 以及 JarEntryFile。IJavaProject 包含了多个 JarPackageFragmentRoot。而每个 JarPackageFragmentRoot 包含多个的 JarPackageFragment、JarEntryDirectory 和 JarEntryFile。类似的， JarPackageFragment 包含多个的 IClassFile 和 JarEntryFile；每个 JarEntryDirectory 包含多个的 JarEntryFile 和 JarEntryDirectory。
Jar 源代码搜索解决方案
本文将用一个例子程序，逐步介绍如何 实现 Jar 源代码的搜索，进一步了解 JDT 提供的 API。解决方案的主要逻辑为 ：遍历工作空间下的所有 JAVA 项目，并且逐一获得项目所依赖的 Jar 文件列 表。然后遍历该列表获得每个 Jar 文件中的 class 文件源码和非 class 文件 的文本内容，使用正则表达式进行匹配查找。最后输出结果的类名、文件路径、 匹配的起始位置和匹配的字符串长度等信息。
结合这个逻辑以及 JDT 中 Jar 文件相关的类结构，上述解决方案中的主要技术问题包括：
ResourcesPlugin.getWorkspace().getRoot().getProjects() 可以获得 工作空间下的所有项目，类型为 IProject。那么如何将 IProject 对象转换为 JAVA 项目对应的 IJavaProject 对象？（文中步骤 1 解决该问题）
获 得 IJavaProject 对象后，如何获得它所依赖的 Jar 文件列表，也就是 JarPackageFragmentRoot 对象列表？（文中步骤 2 解决该问题）
获得 JarPackageFragmentRoot 对象后，如何获得它下面的包（JarPackageFragment ），又如何获得包下的 class 文件（IClassFile）和非 class 文本文件 （JarFileEntry）？（文中步骤 3、5 解决该问题）
如何获得 IClassFile 的源代码，又如何获得 JarFileEntry 的文本内容？（文中步骤 4 、6 解决该问题）
下面将对各个步骤逐一地进行分析，并且一一解决上 面提到的问题。

步骤 1. 转换 IProject 为 IJavaProject
Eclipse 工作空间下，可能存在许多类型的项目，有 JAVA 项目也有非 JAVA 项目，为了获得项目依赖的 Jar 文件，该项目必须是 Java 类型的项目。以下代码通过调用 JDT 提供的接口，获得 JAVA 项目列表。
清单 1. 获得工作空间下的所有 JAVA 项目
/*　获得工作 空间下的所有项目　*/
　IProject[]　projects　=　 ResourcesPlugin.getWorkspace().getRoot()
　　　　　　　　　　　　 .getProjects();
　if　(projects　!=　null)
　{
　　　　 for　(IProject　p　:　projects)
　　　　{
　　　　　　　/*　 尝试转换普通项目为　JAVA　项目　*/
　　　　　　　IJavaProject　 create　=　JavaCore.create(p);
　　　　　　　/*　判断项目是否是　 JAVA　项目　*/
　　　　　　　if　(create　!=　null　&&　 create.exists())
　　　　　　　{
　　　　　　　　　　/*　操 作　JAVA　项目　*/
　　　　　　　　　　…
　　　　　　 　}
　　　　}
　}
步骤 2. 获得依赖的 JarPackageFragmentRoot 列表
获得 IJavaProject 对象后，需要得到它 所依赖的 Jar 文件列表。在 JDT 中，Jar 文件对应的类为 JarPackageFragmentRoot，下面一段程序用于获得 Jar 文件列表。
清单 2. 获得 JAVA 项目依赖的 Jar 文件列表的代码
IJavaProject　 project=　…
　IJavaElement[]　children　=　 project.getChildren();
　if　(children　!=　null)
　{
　　/*　遍历　project　下的　Java　元素　*/
　　for　 (IJavaElement　ele　:　children)
　　{
　　　　/*　判断是否 是　JarPackageFragmentRoot　对象　*/
　　　　if　(ele　instanceof 　JarPackageFragmentRoot)
　　　　{
　　　　　　　/*　操作此 　jar　文件　*/
　　　　　　　　　　…
　　　　}
　}
　}
大多数时候程序员想要搜索的范围并不包含 JRE 库的源代码，因此为了提高搜索效率，需要屏蔽 JRE 库源代码的搜索，下面一 段程序展示如何实现这个需求。
清单 3. 屏蔽 JRE 库的源码搜索
JarPackageFragmentRoot　jarFile　=　…　;
　 IJavaProject　project　=　…　;
　/**
　*　判断此　Jar 　是否在　JRE　库中。如果是，将其屏蔽　,　以提高效率
　*/
　 IClasspathEntry　rawClasspathEntry　=　jarFile.getRawClasspathEntry ();
　IClasspathContainer　classpathContainer　=　 JavaCore.getClasspathContainer(
　　　　　　　　　 rawClasspathEntry.getPath(),　project);
　/*　判断此　jar　是否属 于项目默认的　JRE　库。如果是，不检查该　jar*/
　if　 (classpathContainer.getKind()　==　 IClasspathContainer.K_DEFAULT_SYSTEM)
　{
　　　/*　跳过此　 jar　的搜索　*/
　}

步骤 3. 获得 JarPackageFragmentRoot 中的 IClassFile 列表
如果想获得 .class 文 件的源码，就需要获得 .class 文件对应的 IClassFile 对象，下面的程序展示 了如何从 JarPackageFragmentRoot 对象开始遍历，获得其包含的 PackageFragment 对象，又从 PackageFragment 对象中获得 IClassFile 对象 列表。
清单 4. 获取所有类文件的代码
JarPackageFragmentRoot　root　=　…
　 IJavaElement[]　children　=　root.getChildren();
　if　(children 　!=　null)
　{
　　　/*　遍历　JarPackageFragmentRoot　下的 所有包元素　*/
　　　for　(IJavaElement　ele　:　children)
　　　{
　　　　　　if　(ele　instanceof　PackageFragment)
　　　　　　{
　　　　　　　　IJavaElement[]　classes　=　 ((PackageFragment)　ele).getChildren();
　　　　　　　　/*　遍历 　PackageFragment　下的所有类元素　*/
　　　　　　　　for　 (IJavaElement　cls　:　children)
　　　　　　　　{
　　　　 　　　　　　if　(ele　instanceof　IClassFile)
　　　　　　　　　 　{
　　　　　　　　　　　　/*　获得　IClassFile　对象进行操作　 */
　　　　　　　　　　｝
　　　　　　　　｝
　　　　　 　｝
　　　｝
　}
需要注意的是，JDT 中 Jar 文件 中的包（package）对应的类为 JarPackageFragment，但是该类为 default 类 型，无法引用，可以先将它转换为它的父类 PackageFragment，然后进行处理。
步骤 4. 获得 IClassFile 源代码并比较
得到 IClassFile 对象 后，需要获得其源码 .IClassFile 提供了非常方便的接口： getSource。应用 该方法可以获得源码字符串。如果该方法的输出值为 null，说明这个类还未绑 定源代码。这种情况下可以通过双击 .class 文件，点击 Change Attached Source 按钮进行源代码的绑定。下面的程序展示了如何根据用户输入的正则表 达式进行比较搜索。
清单 5. 获取类文件源码并比较
IClassFile　cf　=　…　;
　Pattern　 searchPattern　=　Pattern.compile("用户输入的正则表达式");
　/*　 获得　IClassFile　源码　*/
　String　source　=　cf.getSource ();
　if　(source　!=　null)
　{
　　Matcher　matcher　 =　searchPattern.matcher(source);
　　while　(matcher.find())
　　{
　　　　/*　获得偏移量　*/
　　　　int　offset　=　 matcher.start();
　　　　String　group　=　matcher.group();
　　　　/*　获得长度　*/
　　　　int　length　=　group.length ();
　　}
　}

步骤 5. 获得 JarPackageFragmentRoot 中的非 JAVA 资源
Jar 文件中 JAVA 资源主要 是 .java 文件和 .class 文件。Jar 文件中非 JAVA 的资源，对应的类为 IJarEntryResource，比如 Jar 中的 .properties 文件、META-INF 文件夹、 META-INF 文件夹下的 MANIFEST.MF 等，都属于非 JAVA 资源，这些非 JAVA 资 源可以存放于 JarPackageFragmentRoot 下，也可以存放于 JarPackageFragment 下。下面的程序展示如何遍历获得 JarPackageFragmentRoot 下的所有非 JAVA 资源。
清单 6. 获得非类文 件的资源
/*　注：ele　也可以是　PackageFragment,　它们都拥 有　getNonJavaResources　方法　*/
　JarPackageFragmentRoot　ele　 =　…　;
　Object[]　nonjavares　=　 ele.getNonJavaResources();
　if　(nonjavares　!=　null)
　 {
　　　for　(Object　o　:　nonjavares)
　　　{
　　　 　　　　/*　JarEntryDirectory　相当于　META-INF　文件夹　*/
　　 　　　　　if　(o　instanceof　JarEntryDirectory)
　　　　　　　 {
　　　　　　　　　JarEntryDirectory　ff　=　 (JarEntryDirectory)o;
　　　　　　　　　IJarEntryResource[]　 children　=　ff.getChildren();
　　　　　　　　　for　 (IJarEntryResource　e　:　children)
　　　　　　　　　{
　　 　　　　　　　　　if　(e　instanceof　JarEntryDirectory)
　　　　 　　　　　　　{
　　　　　　　　　　　　　　　/*　这里需要递归处 理　*/
　　　　　　　　　　　　}
　　　　　　　　　　　　 else　if　(e　instanceof　JarEntryFile)
　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　/*　处理该文本文件　*/
　 　　　　　　　　　　　}
　　　　　　　　　　}
　}
　/* 　JarEntryFile　相当于　META-INF　文件夹下的　MANIFEST.MF　或者 　.properties　文件等　*/
　　　　　　　else　if　(o　instanceof 　JarEntryFile)
　　　　　　　{
　　　　　　　　　 JarEntryFile　ff　=　(JarEntryFile)　o;
　/*　处理该文本文件　 */
　　　　　　　}
　　　　}
　}
步骤 6. 获得非 JAVA 资源的源代码并比较
在本文的代码示例中只展示从 JarEntryFile 获得源代码的方法，如果需要使用其他类型的非 JAVA 资源的获 取方法，请查看附件中的源码。
清单 7. 获得非类文件的文本内容并且 比较
/**
　*　该方法用于获得　JarEntryFile　源代码并 且比较获得结果　
　*/
　private　void　cooperate (JarEntryFile　ff,　Pattern　searchPattern)
　　{
　　　　 ByteArrayInputStream　contents;
　　　　try　
　　　　{
　　　　　　contents　=　(ByteArrayInputStream)　ff.getContents ();
　　　　　　byte[]　bs　=　new　byte[contents.available ()];
　　　　　　contents.read(bs);
　　　　　　String　con 　=　new　String(bs);
　　　　　　Matcher　matcher　=　 searchPattern.matcher(con);
　　　　　　while　(matcher.find())
　　　　　　{
　/*　获得结果的偏移和长度　*/
　　　　 　　　　int　start　=　matcher.start();
　　　　　　　　int　 length　=　matcher.group().length();
　　　　　　}
　　　 　}
　　　　catch　(Exception　e)
　　　　{
　　　　}
　}

步骤 7. 输出结果
为了简单，程序会将结果打 印到控制台上，包括结果中的偏移量、长度、以及查找到源代码路径。
具体应用环境 ---RCP 中查找源码
在 RCP 二次开发中，有时候非常需要 查看已有 UI 的源码，供程序员参考使用。下面将使用前面开发的例子搜索包含 UI 上某字符串的源文件或源代码。一般来说，界面上的字符串都被存放于 .properties 文件，方便修改和多语言处理。由于 .properties 中可能出现占 位符，界面显示的是处理占位符后的结果，所以需要选取合适的字符串进行搜索 。搜索到 .properties 文件后，就根据该 .properties 文件所在的包名，和自 身的文件名，搜索引用该 properties 文件的类。如对于 com.ibm.wise.A_zh_CN.propertis 文件，搜索 com.ibm.wise.A 即可，具体原 因可以搜索 ResourceBundle 的相关资料进行查阅。下面展示这一搜索过程。
步骤 1. 根据 UI 上的字符串获得其 properties 文件所在
图 3. 要搜索的 UI 字符串
例子将试图搜索包含“This section provides general information about” 字符串的 properties 文件，如果未搜索到，可以 适当缩短字符串长度。
图 4. 输入 UI 字符串的程序界面
点击 OK 就可以进行搜索。
图 5. 属性文件搜索结果（用时 3.23 秒）
结果显示了包含该字符串的 properties 文件路径，以及字符串在该文件中 出现的起始位置和长度信息。该文件包含于 Jar 文件中。根据搜索到的路径， 打开文件查看源码。
图 6. 属性文件源代码
图中灰色背景部分就是需要查找的字符串。

步骤 2. 根据 properties 文件名获得引用该 properties 文件的类
在获得 properties 文件名之后，根据搜索到的 properties 文件名（在本文的例子中 是 gui.properties），搜索引用该属性文件的 java 类 , 输入查询的字符串为 ：com.ibm.btools.blm.ui.attributesview.resource.gui。
图 7. 输入 使用属性文件的字符串程序界面
图 8. 类搜索结果（用时 2.43 秒）
通过 Open Type 功能，输入 BLMAttributesviewMessageKeys，就可 以找到此 .class 文件，打开 .class 文件就可以查看它的源代码。
其 他接口简单介绍
这里简单的介绍了 JDT 中与 Jar 相关的类的其他有用 接口，如表 1 所示。
表 1. 其他接口介绍

类接口IClassFileisClass():boolean 判断是否是 class 类型
isInterface():boolean 判断是否是 interface 类型PackageFragmentcreateCompilationUnit ():ICompilationUnit 新建 JAVA 文件
delete():void 删除此包
getClassFile():IClassFile 得到包下某个 class 文件
getClassFiles():IClassFile[] 得到包下所有 class 文件
getCompilationUnit():ICompilationUnit 得到包下某个 java 文件
getCompilationUnits():ICompilationUnit[] 得到包下所有 java 文件
rename():void 重命名JarPackageFragmentRootgetJar():ZipFile 得到 jar 文件对应的 ZipFile
getKind ():int 可以是 IPackageFragmentRoot.K_SOURCE 或者 IPackageFragmentRoot.K_BINARY，表示是源代码类型还是二进制类型
isArchive():boolean 判断是否是压缩文件
isReadOnly():boolean 判 断是否只读

结束语
在进行二次开发时，通 过查看源代码可以很好的帮助程序员了解原有系统，同时对于查找和分析代码漏 洞也有很大的帮助。该文章简单的介绍了如何使用 JDT 提供的接口进行源代码 的搜索，文章内容仅供参考，有兴趣的朋友可以参考该文章的实现，进行进一步 的优化，提高搜索效率，或者做成实用的插件发布，相信会受到很多 Java 程序 员的喜爱。
原文地址：http://www.ibm.com/developerworks/cn/opensource/os-ecl- jdtsearch/