在Eclipse中建设新的重组成果
当前位置：以往代写 > JAVA 教程 >在Eclipse中建设新的重组成果

在Eclipse中建设新的重组成果

2019-06-14

在Eclipse中建设新的重组成果

在Eclipse中建设新的重组成果

副标题#e#

1 先容

重构在现代软件开拓进程中饰演着重要的脚色，它可以或许减轻软件开拓人员的 事情承担，提高软件开拓的出产效率。为了阐发重构的重要性，我们在这里引用 了developerWorks上David Carew提供的关于重构的教程中的一段话：

此刻，一个开拓者的事情大部门在于对现有的代码举办修改，而不是起草写 新的代码。简朴的修改大概包罗对现有代码举办添加。然而，多样化的修改或扩 展的改变会使软件内部布局开始恶化。重构改变软件的内部布局使得软件更容易 领略而且在不需要改变其显著的行为的环境下使得修改的价钱也更小。

在Java软件开拓进程中，通过利用Eclipse提供的重构东西，我们至少得到了 以下长处：

1. 最终产物更为结实：我们对措施代码的修改将不太大概堕落，呈现漏掉修 改的大概变少，纵然呈现问题也可以或许通过Undo成果回退到重构前的状态。

2. 提高了出产效率。凡是一次重构可以或许完成对措施代码的多处窜改。最为明 显的例子大概是Eclipse提供的Rename重构，它可以或许在修更名称的同时相应的更 改所有的引用。

Eclipse 为我们提供了多种实用的重组成果，在软件开拓进程中利用这些重 构可以或许给我们带来极大的长处。然而，针对每个开拓人员的非凡需要，总有一些 急切需要的成果是不能通过已有的重构来得到的。这个时候，我们可以对 Eclipse平台举办一些扩展，建设适应我们本身需要的重构。假如这个重构刚好 可以或许切合大大都人的需要，我们也可以像其他Eclipse的contributor一样，将我 们的重构孝敬给Eclipse社区。

接下来，我们将通过一个例子来展示如安在Eclipse中建设新的重组成果。我 们这里建设的重构将用于迁移JUnit的测试用例。我们知道，在当前版本的 JUnit中，一个用于测试的函数必需以字符串"test"作为要领名称的开始。而在 即未来到的JUnit 4中，一个"@Test"的Annotation被用于标明要领是一个测试方 法。我们将要建设的重构将完成这个迁移事情，即在所有的以"test"开始的要领 之前加上"@Test"标志。@Test Annotation还可以包括一个timeout属性用来划定 要领的最大执行时间，我们在领导中提供了一个页面供用户选择是否需要 timeout属性。

2 功效预览

为了给读者一个直观的感觉，我们下面首先先容本文中例子的实际运行结果 。在阅读完本文之后，读者伴侣也可以或许顺利的完成雷同的成果。

启动例子措施提供的Refactor之后，我们得到了一个由三个页面构成的领导 。在第一个页面中，用户可以选择是否需要timeout参数，而且用户可以或许配置 timeout参数的值。

图 1 输入参数

在Eclipse中建树新的重构成就

当用户输入参数完毕之后，通过单击Next按钮我们将进入下一个页面。领导 将举办初始条件查抄和最终条件查抄，并将查抄的功效反馈给用户。在图 2中我 们可以看到，初始条件和最终条件都正常，因此我们可以进入下一步。

图 2 显示条件查抄

在Eclipse中建树新的重构成就


#p#副标题#e#

接下来是预览窗口（图 3），领导用直观的界面显示了在应用领导之后，我 们将会对源代码造成奈何的窜改。用户可以在这个页面中判定最终的修改是否符 合本身的需要。别的，用户也可以或许选择性的打消对某些文件的修改。

在Eclipse中建树新的重构成就

当用户查抄预览页面确认没有问题之后，用户可以按下Finish按钮从而完成 重构。这个时候，源代码会产生修改，最后的功效如下所示：

清单 1

package　main;
public　class　TestSomething　{
　 @Test(timeout=500)
　 public　void　testSomething(){

　 }
}

3 总体布局和流程

在Eclipse中，一个重构操纵主要由以下三个部门构成：

1. RefactoringWizard类：RefactoringWizard提供了领导式的用户界面来引 导用户完成重构事情。不需要我们做任何事情，Eclipse已经通过 RefactoringWizard为我们提供了预览页面、条件查抄页面以及Undo/Redo等成果 。我们需要担任这个类从而为重构进程提供特定的用户界面。

2. Refactoring类：Refactoring类完成详细的定位和修改代码成果。为了建 立新的Refactoring，我们需要担任这个类并实现重构的逻辑部门。

3. AST和ASTParser：在Refactoring类中，我们需要对代码举办定位和修改 ，这可以通过AST机制来完成。AST是abstract syntax tree的简称，它可以或许将 Java代码理会成为一个树形布局。在操作了AST树之后，对源代码的修改酿成了 对AST树的遍历、变动节点属性，以及插入和删除节点等。

一个典范的重构操纵流程如下所示：

1. 用户选择要举办重构的工具，通过菜单项或按钮启动重构操纵。

2. 建设详细的Refactoring类，弹出RefactoringWizard。

3. RefactoringWizard与用户交互，引导用户输入须要的参数； RefactoringWizard挪用Refactoring类的函数举办条件查抄。

#p#分页标题#e#

4. Refactoring类建设AST，并操作其对源代码举办定位和修改。这里举办的 修改并不直策应用到源代码上，而是被生存成Change工具，供Refactoring框架 利用。

5. RefactoringWizard挪用Refactoring类的函数，得到重构内容的具体描写 信息（即第4步生成的Change工具），显示在预览界面上，待用户确认。

6. 用户确认后Refactoring框架将修改代码，重构操纵竣事。

接下来，我们将具体先容新建重构范例的各个步调。

#p#副标题#e#

4 建设插件工程

在各人对整个系统构架有了一个或许的相识之后，我们的先容就从建设工程 开始。各人都知道Eclipse提供了很好的扩展性，通过建设插件就能把我们要添 加的重组成果无缝的插入到Eclipse平台中。建设插件工程的要领在许多处所都 有先容，这里不再具体讲授。假如需要基本的插件开拓常识，我们可以参考《 开拓 Eclipse 插件》，树立根基的插件开拓意识。

通过菜单 File -> New-> Project，选择Plug-in Project。点击Next ，呈现对话框，输入项目名称manage.annotation，接管其他选项的默认值。点 击Next，呈现插件属性配置的对话框，继承接管默认值。点击Next，呈现选择插 件模板对话框，该工程要在Refactor菜单中添加一个新的菜单项，所以这里我们 回收"Hello,World"的插件模板。点击Next，修改"Action类名称"的值为 AnnotationManageAction，点击 Finish按钮。至此，一个最根基Eclipse事情台 的插件工程就被建设出来了。

插件工程建设后，缺省进入Plug-in开拓透视图，Plug-in Manifest编辑器自 动打开，显示这个插件工程的根基信息，如对其他插件的依赖，扩展点，构建 (build)的设置信息等等。由于该工程需要用到其他插件的成果，必需为其添加 到其他插件的依赖。在Plug-in Manifest编辑器点击Dependencies页面，在该页 面中的Required Plug-ins列表中通过Add按钮添加如下的插件：

清单 2

org.eclipse.jface.text
org.eclipse.ltk.core.refactoring
org.eclipse.ltk.ui.refactoring
org.eclipse.jdt
org.eclipse.jdt.core

可能也可以通过直接修改MANIFEST.MF文件完成。操纵完成后察看 MANIFEST.MF文件，留意Require-Bundle列表中是否呈现了新添加的这几项。 MANIFEST.MF文件如下：

清单 3

Manifest-Version:　1.0
Bundle-ManifestVersion:　2
Bundle-Name:　Annotation　Plug-in
Bundle-SymbolicName:　manage.annotation;　singleton:=true
Bundle-Version:　1.0.0
Bundle-Activator:　manage.annotation.AnnotationPlugin
Bundle-Localization:　plugin
Require-Bundle:　org.eclipse.ui,
　 org.eclipse.core.runtime,
　 org.eclipse.jface.text,
　 org.eclipse.ltk.core.refactoring,
　 org.eclipse.ltk.ui.refactoring,
　 org.eclipse.jdt,
　 org.eclipse.jdt.core
Eclipse-AutoStart:　true

在Plug-in Manifest编辑器中打开插件清单文件plugin.xml，可以看到，这 个插件扩展了org.eclipse.ui.actionSets扩展点，这是一个根基的Eclipse事情 台的扩展点，通过扩展它，插件可以很简朴得对Eclipse的菜单、东西条举办扩 展。这个plugin.xml 是"Hello,World"插件模板的清单文件，我们把它改成适合 这个工程的文件。清单如下：

清单 4

<?xml　version="1.0"　encoding="UTF-8"?>
<?eclipse　version="3.0"?>
<plugin>
　　 <extension
　　　　　 point="org.eclipse.ui.actionSets">
　　　 <actionSet
　　　　　　 label="Annotation　Action　Set"
　　　　　　 visible="true"
　　　　　　 id="manage.annotation.actionSet">
　　　　　　　　　　　 <menu
　　　　　　　　 label="%Refactoring.menu.label"
　　　　　　　　 path="source"
　　　　　　　　 id="org.eclipse.jdt.ui.refactoring.menu">
　　　　　　 <separator　name="reorgGroup"/>
　　　　　 </menu>
　　　　　 <action
　　　　　　　　 class="manage.annotation.actions.AnnotationManageAction"
　　　　　　　　 icon="icons/sample.gif"
　　　　　　　　 id="manage.annotation.actions.AnnotationManageAction"
　　　　　　　　 label="%Annotation.manage"
　　　　　　　　 menubarPath="org.eclipse.jdt.ui.refactoring.menu/reorgGroup"
　　　　　　　　 toolbarPath="reorgGroup"
　　　　　　　　 tooltip="Manage　Annotation　in　Java　 Project"/>
　　　 </actionSet>
　　 </extension>
</plugin>

#p#副标题#e#

#p#分页标题#e#

该清单文件表白，在Refactor菜单中添加了一个新菜单项"Annotation Manage"，并在东西条上相应添加了一个按钮。点击菜单项可能按钮的事件由 类"manage.annotation.actions.AnnotationManageAction"处理惩罚。

最后需要修改的就是manage.annotation.actions.AnnotationManageAction 类。它担任了 org.eclipse.ui.IWorkbenchWindowActionDelegate接口，该接口 用于处理惩罚各类通过扩展点添加的操纵。当菜单项可能按钮被点击时，这个类就被 Eclipse事情台装载进来，处理惩罚转发过来的请求以及接下来的操纵。

AnnotationManageAction 被建设后，一旦用户的选择部门有所改变，接口的 selectionChanged函数就会被触发，奉告用户所选择的部门，可以在这个函数中 按照用户的选择相应的修改操纵的可用性可能其他显示属性。譬喻在本文的工程 中，我们但愿只有当用户选择了一个Java模子元素时才气利用这个操纵，那么就 需要在 selectionChanged中添加如下的代码：

清单 5

public　void　selectionChanged(IAction　action,　 ISelection　selection)　{
　 if　(selection.isEmpty())
　　 select　=　null;
　 else　if　(selection　instanceof　IStructuredSelection)　{
　　 IStructuredSelection　strut　=　((IStructuredSelection)　 selection);
　　 if　(strut.size()　!=　1)
　　 select　=　null;
　　 if　(strut.getFirstElement()　instanceof　IJavaElement)
　　 select　=　(IJavaElement)　strut.getFirstElement();
　 }　else
　　 select　=　null;

　 action.setEnabled(select　!=　null);
　 }

selectionChanged 函数的参数selection记录了用户选择的部门，我们首先 判定它的选择部门的数目是否为一，然后判定这个独一的选择部门是否为Java模 型元素，这两个条件任何一个不满意城市导致action.setEnabled(false)的执行 ，这时会弹出如下的对话框说明操纵不行用，同时菜单项和按钮城市显示成灰色 ，直到用户选择了符合的部门时，菜单项和按钮才会实显，就可以举办详细的操 作了。

图 4 表白Action今朝不能执行的对话框

在Eclipse中建树新的重构成就

操纵的执行是在AnnotationManageAction的run函数中实现的，譬喻在本文的 工程中，就是弹出RefactoringWizard对话框，指导用户完成重构的事情，这些 我们将在下面的章节中报告。

5 扩展Refactoring类

通过前面系统构架的先容，各人知道了Refactoring和RefactoringWizard是 完成EClipse重组成果的基本类。在建设好插件工程后，我们就通过扩展 Refactoring来实现详细的成果。

Refactoring是所有支持代码转化的类的抽象父类，它在整个流程中与 RefactoringWizard交互以完成重构的成果，起着很是重要的浸染。这些类需要 提供以下两类要领：

用于条件查抄的要领，判定重构操纵概略而言可否执行，以及详细的转化能 否完成；

建设Change工具的要领，Change工具描写了所有将要执行的对当前代码的修 改操纵。

Refactoring类的典范流程如下所示：

1. 详细的Refactoring类被建设。

2. 得到用户选择的要举办重构的工具，初始化该Refactoring类。这个由具 体的实现类给出相应的要领。

3. 在重构操纵开始执行时，首先挪用Refactoring的 checkInitialConditions(IProgressMonitor) 基于用户选择的工具做一个的初 始查抄，这个凡是由界面自动执行。返回RefactoringStatus.FATAL表白初始检 查没有通过，重构操纵不能继承。

4. 得到举办重构的其他参数，好比，对重定名操纵来说就是指新名字。这个 凡是是由界面按照用户的输入提供的。由详细的实现类给出相应的要领。

5. 得到用户输入参数后，挪用Refactoring的checkFinalConditions (IProgressMonitor)举办剩下的查抄，这个凡是由界面自动执行，返回 RefactoringStatus.FATAL表白最后的查抄没有通过，重构操纵不能继承。

6. 挪用Refactoring的createChange(IProgressMonitor)得到Change工具， 这个凡是由界面自动执行，界面可以按照Change工具显示预览界面。

#p#副标题#e#

#p#分页标题#e#

基于以上的先容，为了实现本文工程中的重构操纵，我们需要扩展 Refactoring类，为它增加一个结构函数，而且详细实现 checkInitialConditions、checkFinalConditions和createChange三个函数。

首先通过菜单File -> New->Class弹出建设类的对话框，输入包名 manage.annotation.refactor，类名 AnnotationRefactoring，输入父类 org.eclipse.ltk.core.refactoring.Refactoring，选中"担任抽象要领"复选框 ，点击完成按钮，一个扩展了Refactoring的最根基的类AnnotationRefactoring 就被建设出来了。

首先为其增加结构函数，以用户选择的Java模子元素作为参数。Refactoring 阐明这个参数以获得所有相关的可写Java文件，作为重构操纵的工具，假如该模 型元素包括在Java文件中，则找到包括它的文件节点；假如该模子元素包括Java 文件，则找到它的所有子Java文件。结构函数代码如下：

清单 6

public　AnnotationRefactoring(IJavaElement　element) 　{
　 while　(element.getElementType()　>　 IJavaElement.COMPILATION_UNIT)　{
　　 element　=　element.getParent();
　　 if　(element　==　null)
　　 return;
　 }
　 if　(element.getElementType()　==　IJavaElement.COMPILATION_UNIT)　 {
　　 if　(!element.isReadOnly())
　　 compilationUnits.add(element);
　 }
　 if　(element.getElementType()　<　 IJavaElement.COMPILATION_UNIT)
　　 findWritableCompilationUnits(element);
　 }

接着完成checkInitialConditions函数，实现初始查抄的详细操纵。作为示 例，在本文工程中我们不举办任何详细的查抄操纵，只简朴得给出初始查抄乐成 的信息，返回RefactoringStatus.

INFO以使重构操纵继承执行。checkInitialConditions函数代码如下：

清单 7

public　RefactoringStatus　checkInitialConditions (IProgressMonitor　pm)
　　 throws　CoreException,　OperationCanceledException　{
　 return　RefactoringStatus.createInfoStatus("Initial　Condition　 is　OK!");
　 }

接着完成checkFinalConditions函数，实现得到用户输入参数后的后续查抄 操纵。在本文工程中，我们首先收集所有需要添加注释的以test 开头的要领， 判定是否不存在这样的要领，假如不存在给出堕落信息，返回 RefactoringStatus.FATAL以竣事重构操纵；假如存在这样的要领，则给出后续 查抄乐成的信息，返回RefactoringStatus.

INFO。checkFinalConditions函数代码如下：

清单 8

public　RefactoringStatus　checkFinalConditions (IProgressMonitor　pm)
　　 throws　CoreException,　OperationCanceledException　{
　 collectChanges();
　 if　(fChangeManager.size()　==　0)
　　 return　RefactoringStatus
　　　 .createFatalErrorStatus("No　testing　methods　found!");
　 else　return　RefactoringStatus.createInfoStatus("Final　 condition　is　OK!");
　 }

最后，建设Change工具的createChange函数是整个重构操纵中最焦点的代码 ，它的实现将在下面章节中先容。

6 利用AST结构Change工具

#p#副标题#e#

当我们找到了修改的位置时，我们有两个选择：

1. 通过IScanner接口扫描代码，然后通过IBuffer接口直接修改代码

2. 通过遍历和编辑AST树举办布局化的修改

DeveloperWorks提供的文章《扩展Eclipse的Java开拓东西》中，给出了利用 IBuffer接口的例子。此刻我们要报告利用AST来遍历和修改Java源代码的要领。

AST是abstract syntax tree的缩写。它是Eclipse中的Java开拓情况(JDT)为 我们提供的极为强大的源代码理会和编辑东西。

在利用AST树提供的成果之前，我们首先要建设AST树。由于AST树的构建是一 项费时的操纵，JDT缺省环境下不将源代码理会为AST树。下面的代码演示了得到 一个ICompilationUnit对应的AST树的进程。在JDT提供的API中， ICompilationUnit接口用于暗示一个可以被编译的源代码文件。在我们提供的例 子措施中，我们通过下面的代码将整个文件理会成为了一颗AST树。

清单 9

ASTParser　parser　=　ASTParser.newParser (AST.JLS3);
　 parser.setSource(cu);
　 ASTNode　root　=　parser.createAST(null);

AST树中的每个节点都是ASTNode范例，通过Visit模式，我们可以会见一个 ASTNode包括的所有节点。下面的代码演示了会见一个AST节点并得到个中所有的 MethodDeclaration节点的要领。

清单 10

private　void　getMethods(ASTNode　cuu,　final　 List　methods)　{
　 cuu.accept(new　ASTVisitor()　{
　　 public　boolean　visit(MethodDeclaration　node)　{
　　 methods.add(node);
　　 return　false;
　　 }
　 });
　 }

#p#分页标题#e#

在收集到了所有的MethodDeclaration节点之后，我们就可以通过向AST树中 插入和删除节点可能修改已有的节点的要领来修改AST树了。下面的代码演示了 利用AST东西为要领添加@Test Annotation的成果。

清单 11

private　boolean　collectChanges(CompilationUnit　 root,
　　 MethodDeclaration　method)　{
　 if　(method.getName().getFullyQualifiedName().startsWith("test")) 　{
　　 AST　ast　=　method.getAST();
　　 if　(needTimeout)　{
　　 NormalAnnotation　na　=　ast.newNormalAnnotation();
　　 na.setTypeName(ast.newSimpleName("Test"));
　　 MemberValuePair　pair　=　ast.newMemberValuePair();
　　 pair.setName(ast.newSimpleName("timeout"));
　　 pair.setValue(ast.newNumberLiteral("500"));
　　 na.values().add(pair);
　　 method.modifiers().add(0,　na);
　　 }　else　{
　　 MarkerAnnotation　na　=　ast.newMarkerAnnotation();
　　 na.setTypeName(ast.newSimpleName("Test"));
　　 method.modifiers().add(0,　na);
　　 }
　　 return　true;
　 }
　 return　false;
　 }

在 Refactoring框架中，我们要求对AST树的修改并不立即反应到源代码中。 相反，我们需要一个能记录整个修改进程的Change工具。Refactoring框架将利 用这个Change工具来显示Priveiw窗口、举办Undo和Redo等操纵。大抵上，我们 记录对一个AST树的修改从而生成Change工具的进程如以下代码所示。

清单 12

root.recordModifications();

　　 //在这里修改AST树…
　 TextEdit　edits　=　root.rewrite(document,　cu.getJavaProject()
　　 .getOptions(true));
　 TextFileChange　change　=　new　TextFileChange("",　(IFile)　 cu
　　 .getResource());
　 change.setEdit(edits);

#p#副标题#e#

最后，由于Refactoring类的createChange要领仅返回一个Change工具，假如 我们需要对多个源代码文件举办修改，我们可以操作 CompositeChange类将多个 Change工具封装成一个Change工具。这个进程大概雷同如下代码所执行的流程

清单 13

public　Change　createChange(IProgressMonitor　pm) 　throws　CoreException,
　　 OperationCanceledException　{
　 Change[]　changes　=　new　Change[fChangeManager.size()];
　 System.arraycopy(fChangeManager.toArray(),　0,　changes,　0,
　　 fChangeManager.size());
　 CompositeChange　change　=　new　CompositeChange(
　　 "Add　@Override　Annotation",　changes);
　 return　change;
　 }

7 扩展RefactoringWizard 框架

Eclipse中的RefactoringWizard框架扩展了Eclipse的Wizard框架，关于 Wizard框架的先容可以在Eclipse的辅佐系统中找到，这里我们仅从OO设计和架 构的角度探讨一下RefactoringWizard框架。

我们从Wizard相关的几个类开始：

1. WizardPage类

WizardPage是一个包括了多个界面元素（好比文本框Text，按钮Button）的 一个界面组合部门。各个Page之间是独立的，是可以动态加载的。WizardPage类 的职责有：

组合SWT界面元素，结构出一个界面页。

界说自己界面元素的操纵行为。

在 RefactoringWizard框架中预设了两个通用的属性页：PreviewWizardPage 和ErrorWizardPage。PreviewWizardPage类是用来预览重构后的修改，比拟代码 或其他资源的变革。ErrorWizardPage类是用来处理惩罚条件查抄及错误状态通知的 。我们只需扩展RefactoringWizard框架就可以自动获取这两项强大的成果。

2. Wizard类

一个Wizard就是一个装载一系列WizardPage页的容器，Wizard类的职责有：

装载一系列WizardPage，结构出一个巨大的界面。

装载规模类来处理惩罚详细业务逻辑。(在RefactoringWizard框架中这个类就是 Refactoring类)

维护WizardPage页之间以及页与规模类之间的数据通报和状态共享。（在这 里要增补一点，其实在详细RefactoringWizard框架的实现中有专门的类来分管 这部门职责。）

我们的界面行为可以千变万化(通过组合差异的WizardPage)，而认真处理惩罚业 务逻辑的规模类也可以独立的变革，你可以随意扩展Wizard的界面成果 (－对扩 展开放)，而不消修改现有RefactoringWizard框架(－对修改关闭)，这正是OO设 计的最根基原则－OCP(Open-Close Principle)。

3. WizardDialog类

这个对话框类的主要职责是结构一个完整的GUI界面以及操纵界面。它预设了 一些按钮（Back,Next,Finish,Cancel）等界面元素，它认真装载Wizard类，操 作时通过按钮Back、Next来在多个WizardPage之间切换。

下面我们给出RefactoringWizard框架的架构图：

图 5 Refactoring Wizard架构图

在Eclipse中建树新的重构成就

#p#副标题#e#

#p#分页标题#e#

从图 5中我们可以看到，假如我们把每一个WizardPage页看作一项业务，那 么Refactoring正是处理惩罚业务逻辑的节制中心，它封装了所有对业务逻辑的处理惩罚 ，虽然它可以在将处理惩罚任务委任出去。但请留意，它并不认真实现业务流程，也 就是说各业务(各个Page界面)之间的逻辑顺序干系不由它维护。

RefactoringWizard 框架充实思量到了应用的可扩展性，它在SWT的MVC(模子 －视图－节制)元架构模式的基本上，添加了一些新的架构元素。MVC模式促使业 务逻辑与界面疏散，界面与节制行为疏散，而RefactoringWizard框架加强了界 面自己疏散的特性，它将一个完整的界面分拆成多个页面，用户可以动态组合这 些页面或添加新的页面来扩展界面行为。这种特性－界面的动态组合，低耦合， 高内聚，封装精采的接口－让我们明确到了OO设计的精华。

下面我们通过以下几个步调来扩展RefactoringWizard框架：

扩展RefactoringWizardPage

扩展RefactoringWizard

启动RefactoringWizard

第一步，扩展RefactoringWizardPage：首先我们新建一个类 AnnotationRefactoringWizardPage，它需要担任UserInputWizardPage类(其父 类是RefactoringWizardPage，而RefactoringWizardPage最终实现了 IDialogPage接口)。接下来就是实现IDialogPage接口的createControl(…)要领 ，在这个要领里实现你的界面行为，好比我们例子中的TimeOut文本框，代码清 单如下：

清单 14

/**
　 *　create　composite　to　add　UI　elements
　 */
　 public　void　createControl(Composite　parent)　{
　 //　define　UI　
　 Composite　composite　=　new　Composite(parent,　SWT.NONE);
　 GridLayout　lay　=　new　GridLayout();
　 lay.numColumns　=　2;
　 composite.setLayout(lay);
　 btnCheck　=　new　Button(composite,　SWT.CHECK);
　 btnCheck.setText("Add　timeout　parameter");
　 GridData　gdBtnCheck　=　new　GridData();
　 gdBtnCheck.horizontalSpan　=　2;
　 gdBtnCheck.horizontalAlignment　=　GridData.FILL;
　 btnCheck.setLayoutData(gdBtnCheck);
　 labName　=　new　Label(composite,　SWT.WRAP);
　 labName.setText("TimeOut:");
　 GridData　gdLabName　=　new　GridData();
　 gdLabName.horizontalAlignment　=　GridData.BEGINNING;
　 gdLabName.grabExcessHorizontalSpace　=　true;
　 labName.setLayoutData(gdLabName);
　 txtTimeOut　=　new　Text(composite,　SWT.SINGLE　|　 SWT.BORDER);
　 GridData　gdTxtTimeOut　=　new　GridData();
　 gdTxtTimeOut.horizontalAlignment　=　GridData.END;
　 gdLabName.grabExcessHorizontalSpace　=　true;
　 txtTimeOut.setLayoutData(gdTxtTimeOut);
　 txtTimeOut.setText("500");
　 //　init　status
　 labName.setEnabled(false);
　 txtTimeOut.setEnabled(false);
　 //　add　listener
　 defineListener();
　 //　将composite纳入框架的节制
　 setControl(composite);
　 Dialog.applyDialogFont(composite);
　 }

#p#副标题#e#

在这里我们要出格留意的一点是在界说完我们的界面元素后，需要将自界说 的Composite纳入框架的节制，就是这行代码："setControl(composite);"

在我们处理惩罚完输入数据查抄后进入下一页面之前，我们需要配置页面完成的 状态，以及通报输入数据到规模类Refactoring。我们用以下代码配置好页面完 成的状态后，下个页面ErrorWizardPage就会处理惩罚显示逻辑：

清单 15

private　void　notifyStatus(boolean　valid,　String 　message)　{
　 //配置错误信息
　 setErrorMessage(message);
　 //配置页面完成状态
　 setPageComplete(valid);
　 }

通报输入数据通过以下代码来处理惩罚：

清单 16

private　void　setRefactoring(boolean　selection,　 String　text)　{
　 AnnotationRefactoring　refactoring　=　(AnnotationRefactoring)　 getRefactoring();
　 refactoring.setNeedTimeout(true);
　 if(selection)　{
　　 refactoring.setTimeout(Integer.valueOf(txtTimeOut.getText ()).intValue());
　 }
　 }

个中getRefactoring()要领是担任自RefactoringWizardPage的要领，由于我 们的RefactoringWizard类装载了RefactoringWizardPage和Refactoring类，这 个要领是从RefactoringWizard类中得到的，这内里用到了 Observer设计模式。 至此，我们完成RefactoringWizardPage的扩展。

#p#分页标题#e#

第二步，扩展 RefactoringWizard：首先我们新建一个类 AnnotationRefactoringWizard，它需要担任 RefactoringWizard类，这个类中 我们只需要加载界说好的AnnotationRefactoringWizardPage类和 AnnotationRefactoring类，虽然巨大的处理惩罚已经有RefactoringWizard框架处理惩罚 好了。下面我们在结构函数中加载 Refactoring类：

清单 17

public　AnnotationRefactoringWizard(Refactoring　 refactoring)　{
　 super(refactoring,　WIZARD_BASED_USER_INTERFACE);
　 }

然后我们加载我们的AnnotationRefactoringWizardPage类，只需重载父类 RefactoringWizard的addUserInputPages()要领就可以：

清单 18

protected　void　addUserInputPages()　{
　 page　=　new　AnnotationRefactoringWizardPage("refactor　 annotation");
　 addPage(page);
　 }

第三步，启动RefactoringWizard。扩展好RefactoringWizard之后，就需要 在用户点击菜单项或是按钮时弹出这个对话框。RefactoringWizard最好利用 RefactoringWizardOpenOperation类来打开(虽然也可以用 RefactoringWizardDialog)。RefactoringWizardOpenOperation首先举办重构的 初始查抄，通事后才打开RefactoringWinzard对话框，不然就会打开错误对话框 。前面完成建设插件工程时我们提到，弹出RefactoringWizard对话框的代码应 该放到响应菜单操纵的类的run函数中。详细到本文工程中，就是把下面的代码 放到AnnotationManageAction的run函数中。这些代码首先依次结构Refactoring 和RefacoringWizard子类AnnotationRefactoring和 AnnotationRefactoringWizard，并将AnnotationRefactoring的引用通报给 AnnotationRefactoringWizard，然后用RefactoringWizardOpenOperation打开 AnnotationRefactoringWizard，弹出领导对话框。

清单 19

public　void　run(IAction　action)　{
　 Shell　shell　=　window.getShell();
　 AnnotationRefactoring　refactor　=　new　AnnotationRefactoring (select);
　 AnnotationRefactoringWizard　wizard　=　new　 AnnotationRefactoringWizard(
　　 refactor);
　 RefactoringWizardOpenOperation　op　=　new　 RefactoringWizardOpenOperation(
　　 wizard);
　 try　{
　 op.run(shell,　"Inserting　@Override　Annotation");
　 }　catch　(InterruptedException　e)　{
　 e.printStackTrace();
　 }
}

8 小结

在 Eclipse中有效的操作重构可以或许大大的减轻软件开拓人员的事情承担，提 高软件的结实性。然而，今朝重构仍然处在一个东西缺乏的时代。以Eclipse 为 例，只有JDT提供的重构东西最为完善，而针对其他语言譬喻C++、Python等的开 发情况，都缺乏对应的重组成果。

通过本文提供的要领，我们可以或许有效的操作Eclipse中的重构框架建设新的重 构，从而进一步提高已有开拓情况的效率。

    关键字：

在线提交作业