🎶 Sym - 一款用 Java 实现的现代化社区(论坛/BBS/社交网络/博客)平台

📕 思源笔记 - 一款桌面端笔记应用,支持 Windows、Mac 和 Linux

🎸 Solo - B3log 分布式社区的博客端节点,欢迎加入下一代社区网络

♏ Vditor - 一款浏览器端的 Markdown 编辑器

Netbeans 插件模块(Plugin Module)的开发

 By [email protected],
3/6/07

Netbeans在近年的发展,可说是长足的进步。它不仅是功能强大的集成开发环境,更可以看作是一个开发框架和平台,基于这个平台,通过模块开发,扩展这个平台的功能,或者根据自己的需求,定
制个性化的IDE环境。


概述

Netbeans IDE由一个核心运行时环境(core runtime)和一组模块组成。这个core runtime为大多数桌面应用提供公共组件和服务,而“模块”,则是运行在这个core runtime之上的java class,譬如,对于Java语言的支持,就是一个"plugin module",所有Netbeans IDE的跟开发相关的功能都是以“模块”的方式提供的。

开发者可以根据Netbeans平台所开放的编程接口,开发自己的"plugin module"来实现特定的功能。一般来说,有这么两个目的:

  • 扩展Netbeans IDE。我们可以轻松的加入需要的特性,扩展IDE的功能。譬如,在工具栏上加入Google的搜索框;支持新的文件类型;在Netbeans IDE上支持新的web应用框架的开发;或者实现web 程序在特殊的应用服务器上的部署或调试,等等。
  • 在Netbeans核心平台之上,构造自己的rich client应用。譬如,构造一个有丰富的GUI界面的报表生成器。

从程序的角度看,一个module就是一个java的archive(.jar)文件,它包含多个java类,以及一个manifest文件,用来标志该jar文件是一个Plugin Module。当 平台的main class运行时,找到所有可用的module,建立一个内存登记表,并且运行这些module指定的在平台启动时的代码,module的其它代码则根据需要装载。

从发布的角度看,一个module是一个.nbm文件,使用者可以从利用Netbeans IDE中的“update center”功能,从网站下载.nbm文件并安装,或 者选择本地的.nbm文件进行安装。
 

创建Plugin Module的一般步骤

Netbeans从5.0版本开始,提供了向导(Wizard)和模板template,来帮助Netbeans module的开发。一般的开发过程是在基于Wizard生成的Template之上,添 加功能。下面以一个简单的Plugin Module开发过程(参考:http://platform.netbeans.org/tutorials/nbm-google.html)为例,来 介绍这个过程:

1. 创建Plugin Module Project

Step1

在创建project的界面上,如图所示,有三类:

  • Module Project:为一个standalone plugin module创建模板
  • Module Suite Project:为一组互相关联的plugin module和library wrapper module创建模板。它们将一起部署。
  • Library Wrapper Module Project:为一个外部的jar文件创建一个plugin module,可以包含在module suite project中。

这里选择Module Project就可。

Library Wrapper Module有什么用途?它帮助我们在Netbeans Plugin开发中和第三方jar文件建立依赖关系。举例:如果要申明本模块依赖test.jar,

  • 将test.jar包装成Library Wrapper Module,命名为TestModule
  • 在Project property的API versioning页中,设置这个module的版本号,以及public package(public package是指对于module之外的其它类可见的package)
  • 将这两个模块放到同一个Module Suite Project中
  • 在原module中的“add dependency”的界面中,加入它和TestModule的public package的依赖关系。

当然,如果模块依赖Netbeans本身提供的module,比如Data System API,只需最后一步即可,不用Library Wrapper Module。

这和我们在普通的java程序开发过程中,申明和.jar之间的依赖关系的方法有所不同,平时,我们只需将.jar文件放到classpath上即可。Netbeans Module申明依赖关系的方式的好处在于保持很好的模块化,将模块之间的依赖关系最小化,清晰化,并且利用netbeans中的public package的功能,隐藏API的实现细节,利 于模块将来的升级和维护。

在接下来的界面中,给模块命名(MyFirstModule),选择模块所在的目录(d:\test\nbmodule),生成的java的包名(org.myorg.myfirstmodule)。点击“ finish”就完成了模板的建立。

2. 让我们看看模板中都包含些什么:

 

  • 源文件和单元测试的包。除了包含和大多数其它普通项目一样的源文件,它还包含一个重要文件:

    • 缺省在org.myorg.myfirstmodule的源文件包下,有一个“layer.xml”文件。它以xml的格式定义了系统的可扩展点,如新增加的 Menu,T oolbars,action属性等以及用户自定义的配置信息,这些信息将合并到整个netbeans系统的配置注册表中(以后会谈到,这个系统的配置注册表称为System FileSystem)。浏 览layer.xml文件的内容,会发现它包含了“FileSystem”这样的tag。

     

  • Important Files:这个目录下包含了Plugin Module项目中重要的配置文件,其中比较重要的有:

  • XML Layer:它是上述的layer.xml文件的图形表达方式,可以通过图形界面对layer.xml进行浏览和修改

  • Module Manifest:位于项目根目录下的manifest.mf 文件指明该项目是一个plugin module,并 包含layer.xml和bundle文件的位置

  • Project Metadata:包含项目的元数据,如项目类型,该模块和别的模块依赖关系等等。在Library Wrapper Module Project介绍中 提到的依赖关系即在这里申明。

3. 在生成的项目上,就可以利用IDE提供的wizard来创建各种文件模板:

filetemplate

如图所示,Netbeans为plugin的开发提供了多种模板以供选择。除了常见的Java Package,Java Class和File/Folder等,有些模板是Plugin Module开发专用的,它们提供了扩展系统的一些方式,运用模板能够迅速的搭起框架,或者获得示例的代码:如,Project Template可以以提供的项目结构和源码为基准,建立新的模板,加 入到主菜单的“File”-> “New Project”的可选项目模板中;Wizard可以帮助你建立一系列向导窗口;Window Component可以用来创建以 TopComponent为子类的窗口类,并且可将对应的窗口对象嵌入到IDE的指定位置;等等。值得注意的是,并不是所有的系统扩展和新功能的添加都能够,或者必须通过模板的方式来实现,如,希 望在Editor中添加代码自动完成的功能,则没有可用的模板,开发者应熟悉在layer.xml中可以添加的系统的扩展点,以及对应的code completion API。

这里,我们以生成一个新的Action为例。目的是要在系统的工具条上加上一个google搜索栏。当在搜索栏中输入文字,回车后,将调用GoogleAction。因此,在模板列表中选择“ Action...”,出现

NewAction

我们知道,凡菜单项或者工具条选项,都有两个状态,激活或者禁止。这里界面上有两个选项正是为这两种状态设置。“Always Enabled”,如名称所示,这个Action总是处于可调用的状态,因 而界面上的选项将总是处于激活的状态。而“Conditionally Enabled (use CookieAction)”则是根据当前所选择的界面对象的状态和条件,来决定是否激活Action。关 于界面上看到的DataObject,Node和Cookie等,我们将在后续的内容中介绍。这里简单起见,选择“Always Enabled”,下一步的界面“GUI Registration”:

GuiReg

容易推测出,这一步为Action在界面上注册一个调用入口,并且指定它的位置。它可以是一个菜单项,也可以工具条上的按钮,或者对应某个快捷键等。指定Toolbar和Position之后,在 接下来的步骤中指定类名GoogleAction等信息后,就完成了Action模板的建立。

让我们看看Netbeans自动为我们做了什么:

  • GoogleAction.java:新生成的CallableSystemAction的子类。注意,在代码中,i mport了org.openide.util等package。这意味着本 module依赖了其它的module。
  • Layer.xml:被修改。因为增加了新的action以及工具条选项。在之前提到的“FileSystem”下,新增加了一些“folder”和“file”。 这些“ folder”和“file”正描述了这个action以及界面注册的情况等等。
  • Project metadata:被修改。因为增加了新的module dependency。

4. 基于自动生成的模板,运用Netbeans API编写代码,实现所需功能。

本例将创建JPanel 表单,并和GoogleAction关联。在项目名字上右键弹出的菜单中,选择“new”-> “JPanel Form”,在生成的Panel界面上,建立表单,编 写代码实现Google Search。最后重载GoogleAction类的getToolbarPresenter()方法,将JPanel实例作为返回值,即可。具体的步骤请参见 http://platform.netbeans.org/tutorials/nbm-google.html

5. 测试和安装

这两步也非常简单。选择右键菜单中的“Install/Reload in Target Platform”,即可以测试。选择“Create NBM”,可以创建可发布的nbm文件, 用户则可以用菜单中的“Tools”->“Update Center”来安装。如果想卸载,则可用“Tools”-> “Module Manager”功能。

这是非常简单的例子,但是在这个例中,我们介绍了plugin module的几种类型,创建和发布plugin module的一般步骤,module的基本组成,如何解决 netbeans module dependency,怎么扩展系统的菜单,以及action API的基本用法。但是,在这个示例的介绍中,也留下了很多疑问,比如什么是 System FileSystem,D ataObject,Node等等。在下文中,将比较深入的介绍基于netbeans平台,进行Plugin Module开发所涉及到的基本概念,以及其中API的使用。

 

基本概念 & API

我们知道,构建一个框架或者平台软件,必须考虑平台的通用性以及模块和平台之间的接口。当我们学习怎么基于netbeans的平台,做模块开发的时候,不仅 是单纯的开发过程,也 是一个了解netbeans的设计思想的过程。

文件系统 (FileSystem)

在netbeans 3.x的版本的IDE中,开发者经常要mount“filesystem”到一个虚拟的名字空间中,每个文件系统都有一个根(“root”),所 有在这个根下的文件都存于这个名字空间中。在netbeans 4.0以后,对于普通IDE使用者而言,在界面上,文件系统的概念已经不存在了,但是类似的概念仍然存在于IDE的基础架构中,开发plugin module仍需涉及。

Netbeans中,文件系统(FileSystem)扮演着双重角色:它既可以代表磁盘上的物理文件系统,也可以代表IDE和module的配置数据构成的虚拟的文件系统。基于IDE 的配置数据的文件系统称为“System FileSystem”。在当前的FileSystem API中,可以从一个称为Repository的singleton对象里,用 Repository.getDefault().getDefaultFileSystem()方法获得“System FileSystem”,开发者利用System FileSystem,存 取系统的配置数据,以及特定配置目录下的磁盘文件。其它常见的文件系统有JarFileSystem和LocalFileSystem等。LocalFileSystem代表本地磁盘的文件系统。无论是物理的,还 是虚拟的文件系统,它们都共享FileSystem的抽象特性,以及基于其上的FileObject,DataObject,Node等概念。

从文件系统中,获得的是FileObject对象,它提供关于文件对象的基础信息(名字,父对象,是否存在等),和在对象上的操作(移动,删除等)。FileObject和 java.io.File的主要不同之一在于FileObject提供了change listener的机制。另外,FileObject并不一定是代表磁盘上的物理文件,这种情况在接下来介绍中,可 以看到实例。

物理的文件系统(如LocalFileSystem)是比较好理解的,可以参考相关API。这里,我们更需要关注关于System FileSystem的几个基本问题:
1. Netbeans plugin的配置数据是如何表示的?
2. 配置数据与System FileSystem的关系?
3. System FileSystem的根(“root”)在哪里?
4. System FileSystem的扩展点
5. 如何取得System FileSystem根下的物理文件?
6. 如何取得System FileSystem里的虚拟文件对象?

上文提到,每个module都是通过一个“layer.xml”文件来保存配置数据,文件中包含一些虚拟的“文件”和“目录”。这些layer.xml合并在一起就构成了System FileSystem。module就是通过这种方式把配置数据加载到系统中。在module的jar文件中的manifest中,指明了这个layer.xml所处的位置,例如:

OpenIDE-Module-Layer: org/myorg/myfirstmodule/layer.xml

根据这个信息,可以在classes目录中找到这个文件。

一个简单的layer.xml文件就像:
<folder name="Actions">   
  <folder name="Edit">       
    <file name="org-myorg-myfirstmodule-GoogleAction.instance"/>   
  </folder>
</folder>

<folder name="Toolbars">
  <folder name="Edit">
    <attr name="org-openide-actions-FindAction.instance/org-myorg-myfirstmodule-GoogleAction.shadow" boolvalue="true"/>
    <file name="org-myorg-myfirstmodule-GoogleAction.shadow">
      <attr name="originalFile" stringvalue="Actions/Build/org-myorg-myfirstmodule-GoogleAction.instance"/>
    </file>
  </folder>
</folder>

<folder name="myFolder"> 
  <file name="vFile">
     <attr name="attr1" stringvalue="attrValue"/>   
  </file>   
  <file name="myFile.txt" url="resource/realfile"/>
</folder>

其中有一些“folder”是系统预先定义好的,比如,例中的“Actions”和“Toolbars”,当module往IDE的toolbar上添加新的选项的时候,在 “Toolbars”以 及它的子目录下,必然出现对应与这个新选项的“file”条目和相关的属性。可以看到,这些预定义的folder正是这个系统的扩展点。

还有一些folder是用户自定义的,比如例中的“myFolder”,注册于System FileSystem中,可以动态保存用户自己的配置或者资源信息。这些信息可以以虚拟文件的形式,存 于layer.xml中:

FileObject vFile = Repository.getDefault().getDefaultFileSystem().findResource("myFolder/vFile");
System.out.println("the attr is:" + vFile.getAttribute("attr1"));

程序将打印出"the attr is attrValue"。这是一个在System FileSystem中代表虚拟文件的FileObject的例子。当然,如果需要一个物理文件作为实体,也可以用“ url”属性建立虚拟文件和物理文件之间的映射。如例中的 <file name="myFile.txt" url="resource/realfile"/>。 用下面的代码,程 序将获得相对于layer.xml路径的"resource/realfile"物理文件,并且构造出File Object:

FileObject res = Repository.getDefault().getDefaultFileSystem().findResource("myFolder/myFile.txt");

另外,在运行过程中,还可以在System FileSystem的根下,往myFolder目录下添加新的物理目录和文件:

FileObject myFolder = Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("myFolder"); myFolder.createData("newFile");

程序将获得System FileSystem根下myFolder目录对应的FileObject,并调用createData方法,在这个目录下创建一个“newFile"文件。在 module的开发调试环境中这个“根“位于<myModulePath>\build\testuserdir\config,在以nbm的格式安装下,位 于<userdir>\.netbeans\5.5\config目录下(在windows环境中,<userdir>常见于“C:\Documents and Settings\<useraccount>”)。

更cool的是,在System FileSystem中,可以使FileObject成为java对象的工厂。在上例中以.instance为后缀的文件,就是这样的例子。我们在介绍Data System API的时候会详细介绍。

可见,在netbeans中,文件系统以及文件对象扮演了多种角色,但是它们基于同一抽象的特性,使下面介绍的DataObject,Node等能广泛适用。

数据系统 (Data System)

DataObject是FileObject的wrapper。FileObject代表的是一个类似于文件的实体,而DataObject代表的则是文件内容的模型。文件类型是通过后缀名来标志的,一 般来说不同的文件类型对应于不同的DataObject的实现。DataLoader是创建DataObject的工厂类,如果程序需要支持新的文件类型,则应实现相应的DataLoader 和DataObject,并在module的manifest中注册,如:

Name: org/netbeans/modules/povray/PovDataLoader.class
OpenIDE-Module-Class: Loader

如果不需要支持新的文件类型,则不用和DataLoader打交道。只须用下面的方法获得某个fileobject的DataObject:

DataObject.find(someFileObject);

和DataObject交互的方式是通过getCookie()和getLookup()方法。这两个方法应该是可以互换的。getCookie()在将来的netbeans版本中,将 被getLookup所替代。注意,这里的Cookie和http协议中的Cookie没有关系。它代表的是这个DataObject能够提供的操作或者服务。用法如下:

OpenCookie open = someDataObject.getCookie (OpenCookie.class);



if (open != null) {

open.open();

}

如果在someDataObject上如果支持open操作,则从这个DataObject中获得实现了OpenCookie接口的对象,然后调用这个对象上的open操作。这样,DataObject 中并不实现具体的操作,接口实现代码封装在cookie中,通过getCookie和getLookup(关于Lookup,在后面介绍)的编程接口,提供给调用者。

前面提到,System FileSystem中,以.instance为后缀的文件构造的FileObject,能成为java对象的工厂。让我们看看是怎么实现的:在例中的lay.xml中,

//fo中包含了要构造的对象的类名。
FileObject fo = Repository.getDefault().getDefaultFileSystem().findResource("Actions/Edit/org-myorg-myfirstmodule-GoogleAction.instance")

DataObject dobject = DataObject.find(fo); //根据后缀名,获得DataObject对象。
InstanceCookie ic = dobject.getCookie(InstanceCookie.class) //从DataObject中,获 得InstanceCookie的实现
if (ic != null) { //如果该DataObject支持创建新的实例的操作
  GoogleAction myAction = (GoogleAction)ic.createInstance(); //利用Cookie接口,创建Java对象
}

和以.instance为后缀名的情况类似,如果文件对象的后缀名是.ser,即对象的串行化的结果文件,也可以通过获得InstanceCookie的方法来创建被串行化的对象。

节点(Nodes)

前面提到,FileObject是文件的抽象,DataObject是文件内容的模型,而Node是表现层的对象。它们有actions(操作),properties(属性),本 地化的显示名称以及图标等等,封装了对象在人机接口方面的特性。需要注意的是,Netbeans 的Node不是GUI对象,和JDK中的TreeNode没有继承关系。但类似的是,它一般来说,也 是一个树型结构,每一个Node有Children对象,提供子节点的列表。

  • Node和Lookup
    和DataObject类似,每个Node对象都有一个Lookup对象,来存储上下文相关的信息。对于两者而言,调用者都可以通过getLookup方法获得 其上下文以及支持的操作。同 样Node也有getCookie方法,但是它的典型实现是,代理给了DataObject的getCookie()方法。

    Node实例中的Lookup对象是如何设置的呢?这里列举几种方法:
    - 在API中,有可能用到Node的基本实现类AbstractNode(注意,它其实并不是一个抽象类), 在AbstractNode的构造方法中,可以以Lookup为参数。
    - 从DataObject中调用用getNodeDelegate()方法获得的Node对象,可能已经包含了Lookup。
    - 子类如从FilterNode继承,则子类的Lookup可以从代理Node对象中获得。
    - 子类中重载Node的getLookup方法,返回所需的Lookup对象

    至于Lookup的详细说明,以及怎么创建一个Lookup对象,见下章节。
  • Node和Explorer Views
    Explorer Views是界面对象,Node可以用不同的View展现出来。这些View对象包含在Explorer & Property Sheet API中,比 如BeanTreeView用来显示Node 的树型结构,ListView用来显示Node的列表等。至于怎样用View去展现Node,会在Explorer API中介绍。
  • Node和DataObject
    DataObject可以用Node,也可以不用Node来表现。同样,Node后面的数据,可以是DataObject,也可以不是DataObject。但是,在某些场景下是互相关联的,它们 之间也有API可以方便的互相转换。比如,希望用界面树型组件来显示磁盘上的某个目录结构,或者System FileSystem中的虚拟目录。很自然,从FileSystem,到 FileObject,D ataObject,Node,最后用Explorer View显示出来。

    现在我们从编程的角度,看看FileSystem,FileObject, DataObject, Node之间调用和转换关系:

    //Find a file on disk
    FileObject f = Repository.getDefault().getDefaultFilesystem().getRoot().getFileObject("lsome/folder/someFile.txt");

    //or if something passes you a File...
    FileObject f = FileUtil.toFileObject (new File("some/folder/someFile.txt"));


    //Turn a FileObject into a File (may fail for virtual filesystems)
    File f = FileUtil.toFile (someFileObject)

    //Get the DataObject for a FileObject
    DataObject obj = DataObject.find (someFileObject)

    //Get the FileObject a DataObject represents
    FileObject file = someDataObject.getPrimaryFile();

    //Get the Node that represents a FileObject
    Node n = someDataObject.getNodeDelegate();

    //Get the DataObject a Node represents (if any)
    DataObject obj = (DataObject) someNode.getLookup().lookup(DataObject.class);
  • Node和Action
    Node可以提供一组Actions,这些Actions表示在该node被选中的时候,右键弹出菜单中将显示的项目。在这组Actions中,开 发者可以加入一个AbstractAction的子类, 也可以从SystemAction中获得系统菜单中支持的如“delete”,“copy”,“save”等Action。如下例所示:

    public Action[] getActions(boolean popup) {
        DataFolder df = (DataFolder)getLookup().lookup(DataFolder.class);
        return new Action[] {
            new AddRssAction(df),
            SystemAction.get(DeleteAction.class),
            SystemAction.get(SaveAction.class)
        };

    当该Node被选中,在点击右键弹出的菜单中,会有三个选项,一个是“add”操作,操作的实现在AddRssAction中,该操作是在激活状态,因为AddRssAction就是这 个action的实现;第二个是系统Action中的“delete”操作。操作如“delete”,“copy”,“paste”,“cut”,它们的实现可以由ExploreUtil的工厂方法来 提供,它 们的激活与否是由ExploreManager以及当前的剪贴板等状态来控制的。第三个选项是系统Action中的“save”操作,它的激活与否在于该Node的Lookup或者 cookie中有没有SaveCookie的实现。简而言之,getActions()返回了右键菜单中的选项,但是这些选项是否激活,取决于运行系统是否能以各种方式获得对应action的 实现。< /p>

Lookup

在DataObject和Node的介绍中,多次提到Lookup。Lookup( http://www.netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/Lookup.html)类,是 被广泛应用于netbeans API中一个很重要的概念,我们也可以把它看成是Netbeans版本的IoC的实现,它也是各个模块之间实现decouple的关键所在。可以先简单的把它理解为,它 是一个Map,其中keys是class对象,对应每个key的value,是这个class的实例。一般来说,这个class对象是一个interface,定义了某服务的接口,而class实例,是 这个服务的实现。

在Netbeans中,有两种Lookup的用法。一种是用于从全局的服务登记表中获得某个服务的实现,Lookup.getDefault()调用返回的Lookup对象,即这个全局的服务登记表;另 一种,局部的用法,用来查询某个对象是否支持某个服务,并且获得它所支持的服务的实现。很多类型的对象都有自己的Lookup,比如TopComponent,DataObject,Node等等,可 以用类似于obj.getLookup()调用来获得obj的Lookup,这个Lookup对象里存的是当前上下文信息。对于调用者来说,只需获得它所关心的对象的Lookup,从中检索并调用相应的服务。& amp; amp; amp; lt; /p>

这里我们主要探讨一下Lookup的局部用法。用户在IDE环境中的常用操作之一是,移动焦点,并且“选择”某个对象,在这个对象上执行相应操作。当前焦点所在的对象,也称当前选中的对象,活动的对象,或 者处于激活状态的对象。Netbeans IDE菜单中的常见功能,比如“打开”,是在当前所选中的对象上执行“打开”操作。显然对于不同的对象,“打开”操作的实现是不一样的。当选择不同的对象的时候,也 可见属性窗口中的属性值随着对象的不同而变化。那么在同样一个框架下,如何判断某个特定对象是否支持“打开”这样的公用操作,并且执行操作?当焦点对象变化的时候,框架如何得到通知,从而作相应的变化?在 Netbeans中,Lookup就是解决类似问题的答案。

例如下面这个例子就是从Node对象中获得它的Lookup:

Node[] n = TopComponent.getRegistry().getActivatedNodes();



if (n.length == 1) {

OpenCookie oc = (OpenCookie) n[0].getLookup().lookup(OpenCookie.class);

if (oc != null) {

oc.open();

}

}

这段代码,就可以用于实现上文描述的关于“打开”操作的场景,Lookup的应用,使得“打开”这个操作不需关心当前活动的节点的内容,也不用关心该节点将怎么执行 “打开”操作,只 要这个节点的Lookup中能够检索到OpenCookie接口的实现,调用其open函数即可。这样就实现了模块之间的解耦。关于Lookup的更细节的用法说明,请参见:

Lookup的基本概念:
http://openide.netbeans.org/lookup/

用Lookup SPI构造自己的Lookup:
http://www.netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/lookup/doc-files/lookup-spi.html

Lookup API的使用:
http://www.netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/lookup/doc-files/lookup-api.html
 

Window System

在Window System API中,最常用到的是TopComponent类,它是可嵌入式的窗口组件的父类,负责跟Netbeans的窗口系统交互。在 前面介绍Netbeans提供的代码模板类型中,就提到TopComponent。选择“Window Component”模板自动生成的java类,就是TopComponent的子类。Top component可以是一个单独的窗口,也可以嵌入在tab页中。Netbeans的整个界面环境被划分为不同的部分,每个部分都有名称。比如:“explorer”,一般指位于界面左上角位置的窗口部分,“ Project”,“Files”,“Runtime”这些都是位于“explorer”位置的窗口组件。"Editor",指的是位于界面中间的部分,比如各种编辑器都是位于这个部分。生成新的窗口组件时,会 要求指定窗口所处的位置。

每一个TopComponent实例都有一个Lookup的对象来标志其上下文,有一组Explorer view对象作为其界面元素,和一个或者多个激活的节点(Nodes)。程序中,一 般用associateLookup方法来设置TopComponent的Lookup对象,而当前激活的nodes则一般从下文将要介绍的ExplorerManager中得到。

Explorer & Explorer Views

Nodes提供了一组层次化的对象,而Explorer API则提供了界面对象(Explorer View)来显示这些Nodes。但是Nodes和界面对象view之间,并没有直接的调用关系,它 们之间的交互是通过ExplorerManager来实现的。用MVC的观点看,ExplorerManager就是Controller,它提供一个或者多个view要显示的node内容,管 理了views之间的共享的状态,如当前选中的节点和它的Lookup。当用户在某个view上的操作导致共享状态的改变时,该view对象会调用ExplorerManager的方法更新共享状态,E xplorerManager再将共享状态的改变通知到其它的view。结合这些概念,来看一段代码:

class FeedTopComponent extends TopComponent implements ExplorerManager.Provider {

private final ExplorerManager manager = new ExplorerManager();

private final BeanTreeView view = new BeanTreeView();

private FeedTopComponent() {

add(view, BorderLayout.CENTER);

view.setRootVisible(true);

try {

manager.setRootContext(new RssNode.RootRssNode());

} catch (DataObjectNotFoundException ex) {

ErrorManager.getDefault().notify(ex);

}

ActionMap map = getActionMap();

map.put("delete", ExplorerUtils.actionDelete(manager, true));

associateLookup(ExplorerUtils.createLookup(manager, map));

}



public ExplorerManager getExplorerManager() {

return manager;

}

...........

}



示例中,FeedTopComponent即上文提到的TopComponent的子类,BeanTreeView作为一个Explorer View对象加入到了窗口对象中。B eanTreeView需要显示的节点,以及共享状态是由ExplorerManager来控制的。通过调用ExploreManager的setRootContext方法,设置了这组节点的根。

因为ExplorerManager管理了nodes的状态,所以前面提到能从TopComponent窗口实例中获得一组当前激活的节点,实际上,是从其内置的ExplorerManager 中获得。T opComponent的Lookup对象用ExplorerUtils.createLookup(ExplorerManager,ActionMap)方法创建,使 得TopComponent的Lookup实际上,代理给了由ExplorerManager管理下的当前活动节点的Lookup和ActionMap中支持的action操作。

ActionMap对象维护了action的名字和对应的action实现的映射。示例中,ActionMap添加了“delete”操作,通 过把ActionMap和ExplorerManager一起加入到TopComponent的lookup中,使“delete”操作能够在ExplorerManager管理下的nodes上执行。也 就是说当某个node选中的时候,系统的“delete”菜单会被激活。

其它的API

Netbeans中还有很多别的API,可以参见Netbeans的网站上javadoc和相关资料。当然关于API的了解,往往也是在实际运用中得到增强的。

总结

本文首先介绍了创建Netbeans Plugin Module的一般步骤,然后就开发过程中要涉及到的基本概念做了探讨,目的在于了解Netbeans Plugin Module开发中的基本思想和要素,为更深入的学习和理解打下一定的基础。

参考文档

http://platform.netbeans.org/tutorials/index.html

http://www.netbeans.org/download/dev/javadoc/


欢迎注册黑客派社区,开启你的博客之旅。让学习和分享成为一种习惯!

留下你的脚步