Eclipse 向导机制扩展 -- 实现可定制的向导

实现动态页数和树状拓扑结构的 Eclipse 向导

本文首先剖析了 Eclipse 向导机制的实现原理，包括页面的加载和注销，页面校验，向导执行流程，向导目标操作等。目前，Eclipse 向导页面内容是固定的，向导一经创建，其内容和顺序就无法改变。然而，在现实世界中，我们面对的逻辑往往是复杂多变的，固定的顺序的 Eclipse 向导经常无法满足用户需要，因而，文章从两个方面对当前 Eclipse 向导机制进行了扩展：具有动态页数的 Eclipse 向导以及树状拓扑结构的 Eclipse 向导。扩展后的 Eclipse 向导，可以很方便地被开发人员重用，进而提高开发效率。

0 评论

刘 力, 软件工程师, EMC

杜 冰冰, 软件工程师, IBM

2010 年 5 月 20 日

• 内容

在 IBM Bluemix 云平台上开发并部署您的下一个应用。

开始您的试用

引言

文章将对现有 Eclipse 向导机制进行一系列的扩展，并提供相应的参考实现，用户只需要在扩展的基础上增加自己的业务逻辑，便可以快捷地创建功能更为复杂的 Eclipse 向导。

如不做特殊说明，本文默认的开发和运行环境是：IBM JDK 1.6，Eclipse 3.4.x

Eclipse 向导机制介绍

在 Eclipse 中，向导是一种很好的辅助用户操作的机制，通常用于指导用户完成特定的业务操作，例如：创建一个 Java 工程，导入一个文件，导出一个 JAR 文件等等，在 Eclipse 中都有相应的向导辅助用户完成。此外，在 Eclipse 插件开发中，向导也用得非常普遍，Eclipse 提供的向导框架可以帮助用户快速创建自己的向导。

向导基本操作和运行机制

开始之前，我们先来了解一下 Eclipse 向导的实现机制。只有对 Eclipse 向导的实现机制有深入了解，才能实现合理的扩展。 Eclipse 向导由一系列的向导页组成，通常用户的操作会被分散到各个向导页，每个向导页用于配置操作所需的某一方面的信息，当所有向导页的配置完成之后，整个向导便可以执行最后的操作并结束。此外，在向导设计中，用户需要将当前向导页所有必需信息填好，“Next”按钮才生效，从而进入下一个向导页。当所有向导页的内容填充完毕并且到达最后一个向导页时，向导的“Finish”按钮才能有效，这时候点击“Finish”按钮开始执行向导的目标操作。

以 Eclipse 中创建一个工程的向导为例，打开 Eclipse 开发环境，选择“File->New->Project”，便会弹出一个创建新工程的向导，如图 1 所示。可以看到，该向导中有两个页面，第一个页面用于选择需要创建的工程类型，我们选择“General”中的“Project”创建一个 Eclipse 普通工程，第二个页面用于配置创建 Eclipse 普通工程所需要的信息：包括工程名，工程位置以及工程所属的工作集。只有在第一页中选好需要创建的工程类型之后，“Next”按钮才有效，进而进入第二页，当第二页中所有必填信息填完之后，“Finish”按钮才有效，点击它将开始创建一个 Eclipse 工程的操作。

图 1. Eclipse 中创建普通工程向导

在 Eclipse 中，向导必须实现接口 org.eclipse.jface.wizard.IWizard，Eclipse 提供的 org.eclipse.jface.wizard.Wizard 是 IWizard 的一个抽象实现。向导页必须实现接口 org.eclipse.jface.wizard.IWizardPage，org.eclipse.jface.wizard.WizardPage 是 IWizardPage 的一个抽象实现。用户如果想使用 Eclipse 提供的框架创建自己的向导，那么向导和向导页需要分别继承 Wizard 类和 WizardPage 类并重写相应方法。 
创建一个 Eclipse 向导后台发生的操作顺序大致如下，在这个过程中，我们需要重写第一步中向导的构造函数，以及第三步中添加向导页操作。 
1. 使用 IWizard 子类的构造函数创建 Eclipse 向导； 
2. 创建向导所在的 Shell； 
3. 添加向导页：addPages()，重写该方法给向导插入的向导页； 
4. 创建向导页容器：WizardDialog.createPageContainer(Composite parent)； 
5. 创建每个向导页对应的 Control：IWizard.createPageControls(Composite pageContainer)。Eclipse 调用它来实例化所有的向导页面。重写它给向导添加持续可视的窗体小部件； 
6. 显示起始向导页：调用 WizardDialog.showStartingPage()：重写该方法以获取向导第一个页面。

向导页定制

下面我们来看一下向导页的定制，向导页扩展了 WizardPage 类。开发人员为了定制自己的页面，必须重写下面一些方法：

• Constructor：实例化向导页面。
• dispose()：向导关闭时调用该方法清除向导页相关对象。
• createControl(Composite parent)：重写它来创建向导页控件。
• IWizard getWizard()：获取向导页所在的向导对象。
• setPageComplete：当该向导页中的所有必须的设置都完成之后，可以将该页的状态设置为结束，然后用户可以进入下一页。
• setTitle(String title)：设置向导页标题。
• setDescription(String description)：设置向导页的描述。
• setImageDescriptor(ImageDescriptor image)：提供页面右上方出现的图片。
• setMessage(String message)：设置向导页中的提示信息。
• setErrorMessage(String error)： 设置向导页中的错误提示信息。
• performHelp()：设置向导页的帮助信息。

当向导中有多个向导页时，我们可以在向导对话框最下方看到“Back”，“Next”，“Finish”和“Cancel”四个按钮。“Back”，“Next”按钮用于在多个向导页间进行跳转，当向导中只有一个向导页时，只有“Finish”和“Cancel”两个按钮。

• “Back”按钮：用于返回到前一个向导页。点击该按钮，将调用函数 IWizardPage getPreviousPage(IWizardPage previousPage)，返回前一个页面。
• “Next”按钮：用于进入下一个向导页。对于一个设计合理的向导，只有当前向导页中所有必填的信息设置完成之后，“Next”按钮才能变成有效状态，然后用户才被允许进入下一个页面。当用户填完页面中的必须信息时，程序将执行 setPageComplete(true) 方法将当前向导页状态设为完成状态；之后用户点击“Next”按钮，向导页 IWizardPage 的方法 getNextPage(IWizardPage nextPage) 被调用，返回下一个向导页。默认情况下，用户将进入向导类 Wizard 的 addPages() 方法所提供的数组中的下一个页面。如果我们要实现下一页有多种方案，必须重写该方法来计算后一个页面。
• “Finish”按钮：当所有向导页中的信息已经配好之后，用户点击 Finish 按钮，调用 performFinish() 函数来执行向导目标操作，用户需要重写它来实现向导的业务逻辑，如果 performFinish() 执行业务逻辑失败，则应该返回 false。
• “Cancel”按钮：在向导运行过程中，用户可以随时点击该按钮，退出向导。点击该按钮，将会调用 performCancel() 函数，取消当前向导操作，并将之前所做的操作回滚。

Eclipse 向导扩展

从对 Eclipse 向导机制分析可知，Eclipse 向导页的添加是线性的，向导页的内容也是固定的，页面内容和顺序一旦确定就无法改变。在实际应用中，我们面对的需求往往是复杂的，用户的操作步骤经常是有分支的，向导页的内容有时候根据用户的操作需要动态变化。下面我们从两个方面对当前 Eclipse 向导机制进行扩展：动态页数的 Eclipse 向导以及树状拓扑结构的 Eclipse 向导。

动态页数的 Eclipse 向导

实际中，我们经常遇到的一类问题是：某个向导页的存在与否依赖于用户在前面向导页中所做的选择。

举个例子：我们需要给某电影院实现一个电影票购票系统，观众能够通过该系统远程连接到电影院的服务器进行订票，订购电影票的用户有三种类型：普通用户，会员用户，以及 VIP 会员，不同的用户其订票流程是不同的。根据需求，我们使用 Eclipse 的 RCP 来实现该电影票购票系统，观众订票操作将通过 Eclipse 向导辅助完成，我们设计了四个向导页：A、B、C、D。向导页 A 供用户选择其用户类型：普通用户，普通会员或者 VIP 会员。假如观众是普通用户则直接进入向导页 B 填写其基本信息，包括姓名，电话号码等等，之后进入向导页 C 选择电影票，包括电影名字，时间，座位号等，然后选择确定，操作结束。假如观众是会员或者 VIP 会员时，观众在向导页 A 输入自己的会员 ID 和密码登录到系统，登录成功之后，直接进入向导页 C 选择电影票，操作和普通用户一样，当电影票选票结束之后，会员还将进入向导页 D，查看其历史记录，剩余余额等信息。四个向导页的具体描述如下：

表 1. 电影订票向导设计

向导页编号标题内容A用户类型选择选择用户类型：普通用户，普通会员，VIP 会员。如果是会员用户，需要输入自己的会员 ID 和密码进行登录B普通用户基本信息对于普通用户，填写其基本信息，包括用户名，电话号码C电影票信息用户选择其想看的电影，选择电影名字，放映时间，以及选择座位号D历史记录对于会员用户，操作结束之后，将显示其历史纪录

向导页顺序图如下，向导页是动态变化的。当用户为普通用户与，向导页 B 出现，D 不出现，当用户为会员用户，向导页 B 不出现，D 出现。

图 2. 电影订票动态向导顺序图

对于普通用户：在向导页 A 中选择普通用户类型，然后进入向导页 B，填写其基本信息，然后进入向导页 C 进行选票并结束。 见下图。

图 3. 普通用户电影订票流程

对于会员或者 VIP 会员用户：在向导页 A 中选择会员用户或者 VIP 会员，跳过向导页 B，直接进入向导页 C，选票结束之后，进入向导页 D，查看其历史纪录。见下图。

图 4. 会员用户以及 VIP 会员用户电影订票流程

为了实现向导页的动态增加或者减少功能，本文提供了一个动态向导的抽象类 DynamicPageWizard，供广大开发人员使用。用户使用时，只需要继承该抽象类，并重写向导页初始化，增加，修改，以及删除等方法，便可以方便地实现动态向导。该向导类继承了类 org.eclipse.jface.wizard.Wizard，在原 Wizard 的基础上进行扩展，使用变量 List<IWizardPage> pages 来存储向导中的所有向导页，类中所有对向导页的操作都是基于该变量进行，包括向导页的创建、注销、动态增加以及删除。详细的内容见下面清单。由于使用 pages 变量覆盖了原 org.eclipse.jface.wizard.Wizard 中的 pages 变量，因而父类方法中基于该变量的所有方法都需要重写，在下表中省略号部分是重写的代码，读者可以根据自己的 JDK 版本以及扩展需要，将内容补上。

清单 1. 动态页数向导父类 DynamicPageWizard

 public abstract class DynamicPageWizard extends Wizard {     /**      * 向导中的所有向导页，注意：指的是增加或者减少之后的向导页     */     private List<IWizardPage> pages = new ArrayList<IWizardPage>();     ...         /**      * 构造函数，创建一个空的向导     */     protected DynamicPageWizard() {         super();     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#addPage(org.eclipse.jface.wizard.IWizardPage)      */     public void addPage(IWizardPage page) {      // 重写父类方法，添加向导页，并将向导页的向导设置为当前对象     ...     }         /**      * 在指定的向导页前插入向导页     *      * @param page      * @param nextPage      * @return      */     public boolean addPage(IWizardPage page, IWizardPage nextPage) {      for(int i = 0; i < pages.size(); i++) {      if(pages.get(i) == nextPage) {      return addPage(page, i);      }      }      return false;     }         /**      * 在指定的位置插入向导页     *      * @param page      * @param location      */     public boolean addPage(IWizardPage page, int location) {      // Invalid location      if(location < 0 || location > pages.size())      return false;          // Create the new page list      List<IWizardPage> newPages = new ArrayList<IWizardPage>();      for(int i = 0; i < location; i++) {      newPages.add(pages.get(i));      }          page.setWizard(this);      newPages.add(page);          for(int i = location; i < pages.size(); i++) {      newPages.add(pages.get(i));      }          // Set the relationship      if(location != pages.size())      ((IWizardPage)newPages.get(location + 1)).setPreviousPage(page);          ((IWizardPage)page).setPreviousPage((IWizardPage)newPages.get(location - 1));      pages = newPages;      return true;     }         /**      * 删除指定位置的向导页     *      * @param number      */     public void removePage(int number) {      if(number < 0)      return;      if(number > pages.size() - 1)      return;      if(number == 0)      pages.remove(0);      else if(number == pages.size() - 1)      pages.remove(number);      else {      IWizardPage wizarPage = (IWizardPage)pages.get(number + 1);     wizarPage.setPreviousPage((IWizardPage)pages.get(number - 1));     pages.remove(number);      }     }         /**      * 删除指定的向导页     *      * @param page      */     public void removePage(IWizardPage page) {      int number = -1;      for(int i = 0; i < pages.size(); i++) {      if(pages.get(i) == page)      number = i;      }          removePage(number);     }             /**      * 删除向导中某种类名的所有向导页     *      * @param number      */     public void removePage(String className) {        for(int i = 0; i < pages.size(); i++) {      if(pages.get(i).getClass().getCanonicalName().equalsIgnoreCase(className))      removePage(i);      }     }      /*  * (non-Javadoc)  * @see org.eclipse.jface.wizard.Wizard#addPages()  */     public void addPages() {      // 重写父类方法     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#canFinish()      */     public boolean canFinish() {      // 重写父类方法，检测是否所有向导页的设置都结束     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#createPageControls      * (org.eclipse.swt.widgets.Composite)      */     public void createPageControls(Composite pageContainer) {      // 重写父类方法     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#dispose()      */     public void dispose() {      // 重写父类方法     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getDefaultPageImage()      */     public Image getDefaultPageImage() {      // 重写父类方法     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getNextPage      * (org.eclipse.jface.wizard.IWizardPage)      */     public IWizardPage getNextPage(IWizardPage page) {      // 重写父类方法，获取下一个向导页     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getPage(java.lang.String)      */     public IWizardPage getPage(String name) {      // 重写父类方法，获取指定名字的向导页     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getPageCount()      */     public int getPageCount() {      // 重写父类方法    }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getPages()      */     public IWizardPage[] getPages() {      // 重写父类方法    }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getPreviousPage      * (org.eclipse.jface.wizard.IWizardPage)      */     public IWizardPage getPreviousPage(IWizardPage page) {      // 重写父类方法，获取某个向导页之前的向导页    }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getStartingPage()      */     public IWizardPage getStartingPage() {      // 重写父类方法，获取起始向导页    }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#performCancel()      */     public boolean performCancel() {      // 重写父类方法    }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#needsPreviousAndNextButtons()      */     public boolean needsPreviousAndNextButtons() {      // 重写父类方法    }         /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#setForcePreviousAndNextButtons(boolean)      */     public void setForcePreviousAndNextButtons(boolean b) {      // 重写父类方法    }         /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#performFinish()      */     public abstract boolean performFinish();     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#setDefaultPageImageDescriptor      * (org.eclipse.jface.resource.ImageDescriptor)      */     public void setDefaultPageImageDescriptor(ImageDescriptor imageDescriptor) {      // 重写父类方法    }  }

树状拓扑结构的 Eclipse 向导

继续以电影票购票系统为例说明，现在用户对该系统提出了新的需求，要求除了预定电影票之外，订票者还能通过该系统申请成为会员，以及普通会员申请成为 VIP 会员。这样用户的操作出现了分支，我们需要在前面实现的向导基础上增加新的一个向导页，以供用户选择操作类型：电影票预订，申请成为会员或者升级为 VIP 会员。假如用户选择“电影票预订”，便进入上一节中实现的订票界面。假如用户选择“申请成为会员”或者“升级为 VIP 会员”，便分别进入另两条分支，进行相应操作。

根据上面分析，我们需要实现如下向导页。

向导页编号标题内容A操作类型选择选择用户操作类型：电影票预订，申请成为会员或者升级为 VIP 会员B用户类型选择选择用户类型：普通用户，普通会员，VIP 会员C申请成为会员普通用户申请成为会员操作D升级为 VIP 会员普通会员升级成为 VIP 会员操作E普通用户基本信息对于普通用户，填写其基本信息，包括用户名，电话号码F电影票信息用户选择其想看的电影，选择电影名字，放映时间，以及选择座位号G历史记录对于会员用户，操作结束之后，将显示其历史纪录

该向导的树型拓扑结构如下。需要特别指出的是，电影票预订操作，也就是第二级节点向导页 B 处的实现方式和前面是完全不同的，这里使用的是数状的拓扑结构，而前面采用的是页面动态增加或者减少方式。

图 5. 电影订票树状拓扑结构

首先在向导页 A 中选择操作类型，如果是电影票预订操作，则进入向导页 B，如果是申请成为会员，则进入向导页 C，如果是升级为 VIP 会员，则进入向导页 D，这是第一次分支；当用户选择电影票预订并进入向导页 B 之后，用户再选择其用户类型，这是该向导的第二次分支，如果用户是普通用户，则进入向导页 E 填写普通用户基本信息，然后进入向导页 F 进行选票并结束；如果用户是会员或者 VIP 会员，则直接进入向导页 F，选票结束之后，进入向导页 G，查看其历史纪录。

普通用户预定电影票操作：首先在向导页 A 中，选择电影票预订，进入订票分支；然后在向导页 B 中，选择普通用户，进入普通用户订票分支。见下图。

图 6. 普通用户电影订票流程

会员用户预定电影票操作：首先在向导页 A 中，选择电影票预订，进入订票分支；然后在向导页 B 中，选择会员用户，输入会员用户名和密码，进入会员用户订票分支。见下图。

图 7. 会员用户电影订票流程

申请成为会员操作：在向导页 A 中，选择申请成为会员，进入申请成为会员分支。见下图。

图 8. 申请成为会员流程

为了实现树状拓扑结构，文章提供了一个树状向导的抽象类 TreePageWizard，以及向导页类 TreeWizardPage 供开发人员使用。用户使用时，只需要将其向导类继承 TreePageWizard，向导页类继承 TreeWizardPage，重写这两个类中相应的方法，便可以方便地实现树状拓扑结构向导。

向导类 TreePageWizard 继承自类 org.eclipse.jface.wizard.Wizard，在原 Wizard 的基础上进行扩展，使用变量 TreeWizardPage rootPage 来存储树结构的根节点对应的向导页，树结构的根节点即是该向导的起始页。使用变量 Set<TreeWizardPage> pages 来存储树结构中的所有向导页。类中所有操作都是围绕这两个变量进行，包括树结构中节点的添加、删除、树结构分支的选择等等。和动态向导不同的是，pages 里面保存的向导页是向导中所有可能的页面，而 DynamicPageWizard 中存储的是当前向导中的页面，并且 pages 的类型是 Set<TreeWizardPage>，DynamicPageWizard 中类型是 List<IWizardPage>，详细的内容见下面清单。同样，由于 pages 变量覆盖了原 org.eclipse.jface.wizard.Wizard 中的 pages 变量，之前基于该变量的所有方法都需要重写，读者可以根据不同的 JDK 版本以及自己的需要，将必须重写部分内容补上。

清单 2. 树状拓扑向导父类 TreePageWizard

 public abstract class TreePageWizard extends Wizard {     /**      * 树型向导的起始页     * Root page.      */     private TreeWizardPage rootPage = null;         /**      * 向导中的所有向导页     * All the pages in the wizard.      */     private Set <TreeWizardPage> pages = new HashSet <TreeWizardPage>();     /**      * 构造函数     * Creates a new empty wizard.      */     protected TreePageWizard () {         super();     }     /**      * 构造函数     * Creates a new empty wizard.      */     protected TreePageWizard (IWizardPage page) {         super();      if(page instanceof TreeWizardPage) {      rootPage = (TreeWizardPage)page;      addPage(rootPage);      }     }         /**      * 设置树结构的根节点，以及向导的起始页     */     public void setRootPage(IWizardPage page) {      if(page instanceof TreeWizardPage) {      addPage((TreeWizardPage)page);      rootPage = (TreeWizardPage)page;      }     }         /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#addPage(org.eclipse.jface.wizard.IWizardPage)      */     public void addPage(IWizardPage page) {      // 判断是否 TreeWizardPage 类型的向导，如果不是，则返回     if(!(page instanceof TreeWizardPage))      return;          // 添加该向导页     pages.add((TreeWizardPage)page);      page.setWizard(this);          // 添加该向导页的所有子向导页     List <TreeWizardPage> children = ((TreeWizardPage)page).getChildren();      for(int i = 0; i  < children.size(); i++) {      addPage(children.get(i));      }     }         /**      * 插入向导页，第一个参数为待插入的向导页，第二个参数为插入位置之前的向导页     *      * @param page      * @param prviousPage      * @return      */     public void addPage(TreeWizardPage page, TreeWizardPage previousPage) {      boolean exist = pages.contains(previousPage);      if(!exist)      return;          if (previousPage.getChildren().add(page))      addPage(page);     }         /**      * 从向导中删除向导页     *      * @param page      * @return      */     public void removePage(TreeWizardPage page) {      pages.remove(page);      List <TreeWizardPage> children = page.getChildren();      for(int i = 0; i  < children.size(); i++) {      removePage(children.get(i));      }     }         /**      * 从向导中删除向导页，第一个参数为待删除的向导页，第二个参数为删除位置之前的向导页     *      * @param page      * @param prviousPage      * @return      */     public void removePage(TreeWizardPage page, TreeWizardPage previousPage) {      boolean exist = pages.contains(previousPage);      if(exist) {      if (previousPage.getChildren().remove(page))      removePage(page);      }     }         /**      * 从向导中删除向导页，第一个参数为待删除的向导页的类名，第二个参数为删除位置之前的向导页     *      * @param className      * @param previousPage      * @return      */     public boolean removePage(String className, TreeWizardPage previousPage) {      boolean exist = pages.contains(previousPage);      if(!exist)      return false;          List <TreeWizardPage> children = previousPage.getChildren();      for(int i = 0; i  < children.size(); i++) {      TreeWizardPage temp = children.get(i);      if(temp.getClass().getCanonicalName().equalsIgnoreCase(className)) {      if (children.remove(temp)) {      removePage(temp);          return true;          } else          return false;      }      }          return false;     }      /*  * (non-Javadoc)  * @see org.eclipse.jface.wizard.Wizard#addPages()  */     public void addPages() {     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#canFinish()      */     public boolean canFinish() {      // 检测是否所有向导页的设置都完成，整个向导可以结束     TreeWizardPage page = rootPage;      while (page != null) {      if(!page.isPageComplete())      return false;      page = page.getNextPage();      }         return true;     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#createPageControls      * (org.eclipse.swt.widgets.Composite)      */     public void createPageControls(Composite pageContainer) {      // 重写父类方法     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#dispose()      */     public void dispose() {      // 重写父类方法     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getDefaultPageImage()      */     public Image getDefaultPageImage() {      // 重写父类方法     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getPreviousPage      * (org.eclipse.jface.wizard.IWizardPage)      */     public IWizardPage getPreviousPage(IWizardPage page) {      // 获取特定向导页之前的页面        if(page == null)          return null;                 if(!(page instanceof TreeWizardPage))          return null;         return ((TreeWizardPage)page).getPreviousPage();     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getNextPage      * (org.eclipse.jface.wizard.IWizardPage)      */     public IWizardPage getNextPage(IWizardPage page) {      // 获取特定向导页之后的页面     if(page == null)      return null;          if(!(page instanceof TreeWizardPage))      return null;          return page.getNextPage();     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getPage(java.lang.String)      */     public IWizardPage getPage(String name) {      // 根据名字，获取特定向导页     Iterator <TreeWizardPage> iter = pages.iterator();      while(iter.hasNext()) {             IWizardPage page = (IWizardPage) iter.next();             String pageName = page.getName();             if (pageName.equals(name)) {  return page;  }         }         return null;     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getPageCount()      */     public int getPageCount() {      // 重写父类方法，获取该树型结构向导中所有的向导页的数目     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getPages()      */     public IWizardPage[] getPages() {      // 重写父类方法，获取该树型结构向导中所有的向导页     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#getStartingPage()      */     public IWizardPage getStartingPage() {      // 重写父类方法，获取起始向导页     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#performCancel()      */     public boolean performCancel() {      // 重写父类方法     ...     }     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#needsPreviousAndNextButtons()      */     public boolean needsPreviousAndNextButtons() {      // 重写父类方法     ...     }         /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#setForcePreviousAndNextButtons(boolean)      */     public void setForcePreviousAndNextButtons(boolean b) {      // 重写父类方法     ...     }         /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#performFinish()      */     public abstract boolean performFinish();     /*      * (non-Javadoc)      * @see org.eclipse.jface.wizard.Wizard#setDefaultPageImageDescriptor      * (org.eclipse.jface.resource.ImageDescriptor)      */     public void setDefaultPageImageDescriptor(ImageDescriptor imageDescriptor) {         // 重写父类方法        ...     }  }

我们再来看一下向导页类 TreeWizardPage 的实现，该类继承了类 org.eclipse.jface.wizard.WizardPage，树状向导中所有的向导页都必须继承此类，使用变量 List <TreeWizardPage> children 存储该树节点所有的孩子节点，使用变量 TreeWizardPage nextPage 存储当前向导页将要跳转到的下一向导页，nextPage 必须是 children 中的某一个向导页。TreeWizardPage 类中其他方法实现了对该向导页所有孩子节点的增加、删除、获取等操作，以及设置下一向导页等操作，完整内容见下面清单。

清单 3. 树状拓扑向导页父类 TreeWizardPage

public class TreeWizardPage extends WizardPage {    /**    * 当前向导页所有可能的下一个向导页   */    private List <TreeWizardPage> children = new ArrayList <TreeWizardPage>();    /**    * 当前向导的下一个向导页   */    private TreeWizardPage nextPage = null;    /**    * 构造函数   *    * @param pageName    */    protected TreeWizardPage(String pageName) {      super(pageName);    }    /**    * 构造函数   *    * @param pageName    * @param title    * @param titleImage    */    protected TreeWizardPage(String pageName, String title,          ImageDescriptor titleImage) {      super(pageName, title, titleImage);    }    /*    * (non-Javadoc)    *    * @see    * org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets    * .Composite)    */    public void createControl(Composite parent) {    }    /*    * (non-Javadoc)    *    * @see org.eclipse.jface.wizard.WizardPage#getNextPage()    */    public TreeWizardPage getNextPage() {      return nextPage;    }    /**    * 设置该向导的下一页   *    * @param nextPage    *            the nextPage to set    */    public void setNextPage(TreeWizardPage nextPage) {      for (int i = 0; i  < children.size(); i++) {        if (children.get(i) == nextPage) {          this.nextPage = nextPage;          updateContainerButton();        }      }      this.nextPage = null;    }    /**    * 设置该向导的下一页   *    * @param className    */    public void setNextPage(String className) {     int number = -1;      for (int i = 0; i  < children.size(); i++) {        if (children.get(i).getClass().getCanonicalName().equalsIgnoreCase(className))          number = i;      }      if (number != -1) {        this.nextPage = children.get(number);        updateContainerButton();      } else        this.nextPage = null;    }    /**    * 添加可能的下一个向导页   *    * @param page    */    public void addChild(TreeWizardPage page) {      if (page != null) {        children.add(page);        page.setPreviousPage(this);      }    }    /**    * 删除可能的下一个向导页   *    * @param page    */    public void removeChild(TreeWizardPage page) {      if (page != null) {        if (children.contains(page))          children.remove(page);      }    }    /**    * 获取所有可能的下一个向导页   *    * @return the children    */    public List <TreeWizardPage> getChildren() {      return children;    }    /**    * 更新向导中的按钮，包括上一步按钮，下一步按钮，结束按钮以及取消按钮   */    public void updateContainerButton() {      getContainer().updateButtons();    }  }

关于上文中两个例子的具体实现，读者可以在附件 EclipseWizardExtension.zip 中找到，考虑到不同 JDK 以及版权的问题，并没有将两种向导的父类 DynamicPageWizard 和 TreePageWizard 放在附件中，读者仅需要在 org.eclipse.expand.wizard 包中重建这两个类，并把文中省略部分补全即可。

小结

本文对 Eclipse 向导机制进行了两个方面的扩展，在原有 Eclipse 向导的基础上，扩展实现了一种动态页数的向导，以及一种具有树状拓扑结构的向导。动态页数向导支持在向导中任意添加或者删除新的向导页，实现时向导类需要继承 DynamicPageWizard 类，并重写动态添加或者删除向导页方法；而树状拓扑结构使得向导根据用户不同选择，其流程可以实现分支，树状向导需要继承 TreePageWizard 类，向导页需要继承 TreeWizardPage 类，并分别重写父类中的相应方法。基于这两种扩展，用户可以快速编写复杂的 Eclipse 向导实现，满足实际需要。

声明：本文仅代表作者个人观点，不代表 IBM 公司之观点。