netbeans.apache.org/src/old_content/content/tutorials/691/nbm-maven-modulesuite_zh_CN.adoc

// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= 使用 Maven 创建 NetBeans 模块套件
:jbake-type: platform_tutorial
:jbake-tags: tutorials 
:jbake-status: published
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:icons: font
:experimental:
:description: 使用 Maven 创建 NetBeans 模块套件 - Apache NetBeans
:keywords: Apache NetBeans Platform, Platform Tutorials, 使用 Maven 创建 NetBeans 模块套件

本文档演示了如何通过 Maven 原型创建 NetBeans 平台模块套件，并在 IDE 安装中生成和安装此套件。在本教程中，您将创建一个 Maven 模块套件项目，其中包含三个 NetBeans 模块作为子项目。包含子项目的 Maven 项目是一个简单的 POM 项目，该项目声明了套件的编译方式和安装目标。

本文档根据基于 Ant 的  link:https://netbeans.apache.org/tutorials/nbm-selection-1.html[NetBeans 选择管理教程]而编写，阐述了使用 Ant 和 Maven 开发 NetBeans 平台模块套件的一些不同之处。在了解其中的一些不同之处后，您便可以轻松地继续学习  link:https://netbeans.apache.org/kb/docs/platform_zh_CN.html[NetBeans 平台学习资源]上的其他教程。

如果您不熟悉 NetBeans 平台，则可能需要观看截屏视频系列 link:https://netbeans.apache.org/tutorials/nbm-10-top-apis.html[最主要的 10 个 NetBeans API]。







*注意：*为开发适用于 NetBeans 平台的应用程序，您无需下载该平台的独立版本。通常，您是在 NetBeans IDE 中开发应用程序和模块，并且只包含运行 NetBeans 平台和您的应用程序所需的模块。

在开始本教程之前，您可以先阅读下面这些文档。

*  link:https://netbeans.apache.org/wiki/[NetBeans 开发者常见问题解答]
*  link:http://wiki.netbeans.org/MavenBestPractices[Best Practices for Apache Maven in NetBeans 6.x]（NetBeans 6.x 中 Apache Maven 的最佳做法）
*  link:http://www.sonatype.com/books/maven-book/reference/introduction.html[Chapter 1. Introducing Apache Maven]（第 1 章. Apache Maven 简介，来自  link:http://www.sonatype.com/books/maven-book/reference/public-book.html[Maven: The Definitive Guide]（Maven：权威指南））
*  link:https://netbeans.apache.org/kb/docs/java/gui-functionality_zh_CN.html[生成 GUI 应用程序简介]


== 在 IDE 中使用 Maven

如果这是您第一次创建 Maven 项目，则您会希望了解 Maven 配置设置和 Maven 资源库浏览器。


=== 配置 Maven 选项

您可以使用“选项”窗口中的 "Maven" 标签来在 IDE 中配置 Maven 的行为，并检查您的配置是否正确。


[start=1]
1. 在“选项”窗口中选择“其他”类别，然后单击 "Maven" 标签。

[start=2]
1. 指定 Maven 在本地的安装位置（要求为 2.0.9 或更高版本）。

[start=3]
1. 确认本地 Maven 资源库的位置正确无误。

[start=4]
1. 单击“确定”。

在大多数情况下，如果您执行了典型的 Maven 配置，则“选项”窗口中的信息应该已经是正确的。

*注意：*Maven 支持是作为 Java SE 功能集的一部分被激活的。如果“选项”窗口中的 "Maven" 标签不可用，请通过创建一个 Java 应用程序来确认 Java SE 已被激活。


=== 查看 Maven 资源库

Maven 用于生成所有项目的工件均存储在本地 Maven 资源库中。如果某一工件被声明为项目依赖关系且尚未安装，则会将其从已注册的某个远程资源库下载到您的本地资源库中。

缺省情况下，已注册 NetBeans 资源库和一些常见的索引 Maven 资源库，并将它们列在资源库浏览器窗口中。NetBeans 资源库包含生成项目所需的大多数公共工件。您可以使用“Maven 资源库”浏览器查看本地和远程资源库的内容。您可以展开“本地库”节点以查看本地存在的工件。NetBeans 资源库节点下列出的工件可以添加为项目依赖关系，但并非所有这些工件都在本地存在。仅当这些工件被声明为项目依赖关系时，才会将其添加到“本地库”。

打开“Maven 资源库”浏览器：

* 从主菜单中选择“窗口”>“其他”>“Maven 资源库浏览器”。

image::images/maven-quickstart68_maven-nbm-netbeans-repo.png[title="“Maven 资源库”浏览器的屏幕快照"]


== 创建 NetBeans 平台模块套件

在此部分，您将使用“新建项目”向导来通过 Maven 原型创建 NetBeans 平台模块套件。此向导将创建一个包含模块项目的 POM 项目。在此向导中，您还将创建一个模块作为套件的子项目。


[start=1]
1. 打开“新建项目”向导，然后在 "Maven" 类别中选择“Maven NetBeans 模块套件”。单击“下一步”。

[start=2]
1. 在“项目名称”中键入 *MavenSelectionSuite*。单击“下一步”。

[start=3]
1. 选择“创建模块项目”，然后键入 *MyAPI* 作为模块名称。单击“完成”。

单击“完成”后，IDE 会创建 MavenSelectionSuite 项目以及子项目 "MyAPI NetBeans Module"。

image::images/maven-suite_maven-suite-projectswindow.png[title="“项目”窗口的屏幕快照"]

MavenSelectionSuite 是一个 POM 项目，它是一个用来包含子项目（在本例中为 NetBeans 模块项目）的容器。POM 项目不包含任何源文件。此项目的 POM 包含用于编译套件的说明；如果您查看此项目的 POM，则可以看到对于 packaging 指定了  ``pom`` 。


[source,xml]
----

     <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>MavenSelectionSuite</artifactId>
    *<packaging>pom</packaging>*
    <version>1.0-SNAPSHOT</version>
    <name>MavenSelectionSuite Netbeans Module Suite</name>
    ...
        <properties>
            <netbeans.version>RELEASE69</netbeans.version>
        </properties>
    *<modules>
        <module>MyAPI</module>
    </modules>*
</project>
----

POM 还包含一个模块列表，当生成 POM 项目时，将包含这些模块。您可以看到 MyAPI 项目已被列为一个模块。

如果在“项目”窗口中展开“模块”节点，则会看到 MyAPI 项目已被列为一个模块。在“文件”窗口中，可以看到 MyAPI 项目目录位于  ``MavenSelectionSuite``  目录中。当在 POM 项目的目录中创建新项目时，IDE 会自动将该项目添加到 POM 的模块列表中，在生成和运行 POM 项目时将包含这些模块。

当通过 Maven 原型创建 NetBeans 平台模块套件时，您不需要像使用 Ant 时那样在“新建项目”向导中指定目标 NetBeans 平台安装。要设置 NetBeans 平台安装，则需要修改 POM 项目的  ``profiles.xml``  文件中的  ``<netbeans.installation>``  元素，并明确指定 NetBeans 平台安装的路径。有关详细信息，请参见本教程中的<<05b,指定 NetBeans 安装的位置>>部分。


== 修改 MyAPI 模块

在创建模块套件时，您创建了 MyAPI 模块，但现在，您需要在该模块中创建一个类，并向其他模块公开该类。


=== 在 MyAPI 模块中创建类

在本练习中，您将创建一个名为  ``APIObject``  的简单类。 ``APIObject``  的每个实例都将是唯一的，因为每创建一个  ``APIObject``  的新实例，字段  ``index``  都会递增 1。


[start=1]
1. 在“项目”窗口中展开 MyAPI 项目。

[start=2]
1. 右键单击“源包”节点，然后选择“新建”>“Java 类”。

[start=3]
1. 在“类名”中键入 *APIObject*，然后从“包”下拉列表中选择  ``com.mycompany.mavenselectionsuite`` 。单击“完成”。

[start=4]
1. 修改该类以声明一些字段，并添加以下简单方法。

[source,java]
----

public final class APIObject {

   private final Date date = new Date();
   private static int count = 0;
   private final int index;

   public APIObject() {
      index = count++;
   }

   public Date getDate() {
      return date;
   }

   public int getIndex() {
      return index;
   }

   public String toString() {
       return index + " - " + date;
   }

}
----


[start=5]
1. 修复导入并保存更改。


=== 指定公共包

在本教程中，您将创建其他模块，这些模块需要访问  ``APIObject``  中的方法。在本练习中，您将公开 MyAPI 模块的内容，以便其他模块可以访问其中的方法。要将  ``com.mycompany.mavenselectionsuite``  包声明为公共包，则需要在 POM 中修改  ``nbm-maven-plugin``  的  ``configuration``  元素，以指定将作为公共包导出的包。您可以在编辑器中更改 POM，也可以通过在项目的属性窗口中选择要公开的包进行更改。


[start=1]
1. 右键单击项目节点，然后选择“属性”以打开属性窗口。

[start=2]
1. 在“公共包”类别中选择 "com.mycompany.mavenselectionsuite" 包。单击“确定”。
image::images/maven-suite_maven-suite-publicpackages.png[title="属性窗口中的“公共包”"]

在选择要导出的包之后，IDE 会修改 POM 中的  ``nbm-maven-plugin``  元素以指定该包。


[source,xml]
----

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>nbm-maven-plugin</artifactId>
    <extensions>true</extensions>
    <configuration>
        <publicPackages>
            *<publicPackage>com.mycompany.mavenselectionsuite</publicPackage>*
        </publicPackages>
    </configuration>
</plugin>
----


[start=3]
1. 右键单击项目，然后选择“生成”。

在生成项目时， ``nbm-maven-plugin``  将在 JAR 的  ``MANIFEST.MF``  中生成一个清单头，用于指定公共包。

有关详细信息，请参见  link:http://bits.netbeans.org/mavenutilities/nbm-maven-plugin/manifest-mojo.html#publicPackages[nbm-maven-plugin 清单文档]。


== 创建 MyViewer 模块

在此部分，您将创建一个名为 MyViewer 的新模块，然后添加一个窗口组件和两个文本字段。该组件将实现  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util-lookup/org/openide/util/LookupListener.html[LookupListener]``  以侦听对  link:https://netbeans.apache.org/wiki/devfaqlookup[Lookup] 的更改。


=== 创建模块

在本练习中，您将在  ``MavenSelectionSuite``  目录中创建 MyViewer NetBeans 模块。


[start=1]
1. 从主菜单中选择“文件”>“新建项目”(Ctrl-Shift-N)。

[start=2]
1. 从 "Maven" 类别中选择“Maven NetBeans 模块”。单击“下一步”。

[start=3]
1. 在“项目名称”中键入 *MyViewer*。

[start=4]
1. 确认“项目位置”为  ``MavenSelectionSuite``  目录。单击“完成”。

[start=5]
1. 右键单击“项目”窗口中的“库”节点，然后选择“添加依赖关系”。

[start=6]
1. 在“打开的项目”标签中选择 "MyAPI NetBeans Module"。单击“确定”。
image::images/maven-suite_maven-suite-addapi.png[title="属性窗口中的“公共包”"]

单击“确定”后，IDE 会将工件添加到 POM 的依赖关系列表中，并在“库”节点下显示该工件。

如果查看 MyViewer 模块的 POM，则会看到该模块的父项目是 MavenSelectionSuite，对于  ``packaging``  指定了  ``nbm`` ，并且将使用 *nbm-maven-plugin* 将该项目生成为 NetBeans 模块。


[source,xml]
----

<modelVersion>4.0.0</modelVersion>
*<parent>
    <groupId>com.mycompany</groupId>
    <artifactId>MavenSelectionSuite</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>*
<groupId>com.mycompany</groupId>
<artifactId>MyViewer</artifactId>
*<packaging>nbm</packaging>*
<version>1.0-SNAPSHOT</version>
<name>MyViewer NetBeans Module</name>

----


=== 创建窗口组件

在本练习中，您将创建一个窗口组件，并添加两个文本字段。


[start=1]
1. 右键单击 MyViewer 项目，然后选择“新建”>“窗口”。

[start=2]
1. 从下拉列表中选择 "navigator"，然后选择“在应用程序启动时打开”。单击“下一步”。

[start=3]
1. 在“类名前缀”中键入 *MyViewer*。单击“完成”。

[start=4]
1. 将两个标签从“组件面板”拖至该组件中，然后将顶部标签的文本更改为  ``"[nothing selected]"`` 。
image::images/maven-suite_maven-suite-myviewertopcomponent.png[title="窗口组件中的文本字段"]

[start=5]
1. 单击“源”标签，然后修改类签名以实现  ``LookupListener`` 。

[source,java]
----

public class MyViewerTopComponent extends TopComponent *implements LookupListener* {
----


[start=6]
1. 通过将插入光标置于代码行中并按 Alt-Enter 组合键来实现抽象方法。

[start=7]
1. 添加以下  ``private``  字段  ``result``  并将初始值设置为 null。

[source,java]
----

private Lookup.Result result = null;
----


[start=8]
1. 对  ``componentOpened()`` 、 ``componentClosed()``  和  ``resultChanged()``  方法进行以下更改。

[source,java]
----

public void componentOpened() {
    *result = Utilities.actionsGlobalContext().lookupResult(APIObject.class);
    result.addLookupListener(this);*
}

public void componentClosed() {
    *result.removeLookupListener (this);
    result = null;*
}

public void resultChanged(LookupEvent le) {
    *Lookup.Result r = (Lookup.Result) le.getSource();
    Collection c = r.allInstances();
    if (!c.isEmpty()) {
        APIObject o = (APIObject) c.iterator().next();
        jLabel1.setText (Integer.toString(o.getIndex()));
        jLabel2.setText (o.getDate().toString());
    } else {
        jLabel1.setText("[no selection]");
        jLabel2.setText ("");
    }*
}
----

通过使用  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util/org/openide/util/Utilities.html#actionsGlobalContext%28%29[Utilities.actionsGlobalContext()]`` ，每当打开一个组件时，该类都可以全局侦听具有焦点的组件的 Lookup 对象。当关闭组件时，Lookup 即会被删除。 ``resultChanged()``  方法实现了  ``LookupListener`` ，以便根据具有焦点的  ``APIObject``  来更新窗体中的 JLabel。


[start=9]
1. 修复导入，并确保添加了 * ``org.openide.util.Utilities`` *。保存所做的更改。


== 创建 MyEditor 模块

在此部分，您将创建一个名为 MyEditor 的新模块。该模块将包含一个  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-windows/org/openide/windows/TopComponent.html[TopComponent]`` ，该组件将通过 Lookup 提供  ``APIObject``  的实例。您还将创建一个操作，用于打开 MyEditor 组件的新实例。


=== 创建模块

在本练习中，您将在  ``MavenSelectionSuite``  目录中创建一个 NetBeans 模块，并添加对 MyAPI 模块的依赖关系。


[start=1]
1. 从主菜单选择“文件”>“新建项目”。

[start=2]
1. 从 "Maven" 类别中选择“Maven NetBeans 模块”。单击“下一步”。

[start=3]
1. 在“项目名称”中键入 *MyEditor*。

[start=4]
1. 确认“项目位置”为  ``MavenSelectionSuite``  目录。单击“完成”。

[start=5]
1. 在“项目”窗口中右键单击该项目的“库”节点，然后选择“添加依赖关系”。

[start=6]
1. 在“打开的项目”标签中选择 "MyAPI NetBeans Module"。单击“确定”。


=== 添加操作

在本练习中，您将创建一个类，该类用于在“文件”菜单中添加一个菜单项，以便打开名为 "MyEditor" 的组件。在下一个练习中，您将创建该组件。


[start=1]
1. 右键单击 MyEditor 项目，然后选择“新建”>“操作”以打开“新建操作”对话框。

[start=2]
1. 选择“始终启用”。单击“下一步”。

[start=3]
1. 保留“GUI 注册”页中的缺省设置。单击“下一步”。

[start=4]
1. 在“类名”中键入 *OpenEditorAction*。

[start=5]
1. 在“显示名称”中键入 *Open Editor*。单击“完成”。

IDE 在编辑器中打开  ``OpenEditorAction``  类，并在  ``layer.xml``  文件中添加以下内容。


[source,xml]
----

<filesystem>
    <folder name="Actions">
        <folder name="Build">
            <file name="com-mycompany-myeditor-OpenEditorAction.instance">
                <attr name="delegate" newvalue="com.mycompany.myeditor.OpenEditorAction"/>
                <attr name="displayName" bundlevalue="com.mycompany.myeditor.Bundle#CTL_OpenEditorAction"/>
                <attr name="instanceCreate" methodvalue="org.openide.awt.Actions.alwaysEnabled"/>
                <attr name="noIconInMenu" boolvalue="false"/>
            </file>
        </folder>
    </folder>
    <folder name="Menu">
        <folder name="File">
            <file name="com-mycompany-myeditor-OpenEditorAction.shadow">
                <attr name="originalFile" stringvalue="Actions/Build/com-mycompany-myeditor-OpenEditorAction.instance"/>
                <attr name="position" intvalue="0"/>
            </file>
        </folder>
    </folder>
</filesystem>
----


[start=6]
1. 修改  ``OpenEditorAction``  类中的  ``actionPerformed``  方法。

[source,java]
----

public void actionPerformed(ActionEvent e) {
    MyEditor editor = new MyEditor();
    editor.open();
    editor.requestActive();
}
----


=== 添加编辑器组件

在本练习中，您将创建 MyEditor 组件，当  ``OpenEditorAction``  调用该组件时，会在编辑器区域中将其打开。不能使用“窗口”组件模板，因为您需要的是组件的多个实例，而“窗口”组件用于创建单个组件。但是，您可以使用“JPanel 窗体”模板，然后对类进行修改以扩展  ``TopComponent`` 。


[start=1]
1. 右键单击“源包”，然后选择“新建”>“其他”，并从“Swing GUI 窗体”类别中选择“JPanel 窗体”。单击“下一步”。

[start=2]
1. 在“类名”中键入 *MyEditor*，然后选择 "com.mycompany.myeditor" 包。单击“完成”。

[start=3]
1. 将两个文本字段拖至该组件中。

[start=4]
1. 通过取消选择每个文本字段的  ``editable``  属性来使这些文本字段成为只读字段。
image::images/maven-suite_maven-suite-editableprop.png[title="标签的 editable 属性"]

[start=5]
1. 单击“源”标签，然后修改类签名以扩展  ``TopComponent``  而不是  ``javax.swing.JPanel`` 。

[source,java]
----

public class MyEditor extends *TopComponent*
----


[start=6]
1. 将插入光标置于签名中，然后按 Alt-Enter 组合键以修复代码中的错误，方法是搜索 Maven 资源库，然后添加对  ``org.openide.windows``  工件的依赖关系。修复导入。
image::images/maven-suite_maven-suite-add-topcomponent.png[title="标签的 editable 属性"]

[start=7]
1. 修改构造函数，以便每次调用  ``APIObject``  类时都会创建该类的新实例。

[source,java]
----

public MyEditor() {
    initComponents();
    *APIObject obj = new APIObject();
    associateLookup(Lookups.singleton(obj));
    jTextField1.setText("APIObject #" + obj.getIndex());
    jTextField2.setText("Created: " + obj.getDate());
    setDisplayName("MyEditor " + obj.getIndex());*

}
----

构造函数中的  ``associateLookup(Lookups.singleton(obj));``  一行将创建一个 Lookup，其中包含  ``APIObject``  的新实例。


[start=8]
1. 修复导入并保存更改。

组件中的文本字段仅显示  ``APIObject``  中的索引值和日期。这样，您便可以看到每个 MyEditor 组件都是唯一的，并且 MyViewer 显示了具有焦点的 MyEditor 组件的详细信息。

*注意：* ``OpenEditorAction``  中的错误会在您保存对  ``MyEditor``  所做的更改之后得以解决。


== 生成和运行模块套件

此时，您几乎已经做好运行此套件的一切准备，以查看它是否可以正确生成、安装和运行。


=== 声明直接依赖关系

在生成和运行此套件之前，您需要首先修改 MyEditor 项目的一个依赖关系。如果您现在尝试生成模块套件，则“输出”窗口中的生成输出会通知您无法编译套件，因为 MyEditor 模块要求  ``org.openide.util-lookup``  工件在运行时可用。

如果右键单击项目节点，然后选择“显示依赖关系图形”，则可以借助依赖关系图形查看器以可视方式查看模块依赖关系。


image::images/maven-suite_maven-suite-dependency-graph.png[title="工件依赖关系图形"]

您可以看到 MyEditor 对  ``org.openide.util-lookup``  不具有直接依赖关系。依赖关系是传递的，并且该工件在编译时对于项目可用，但如果要使该工件在运行时可用，则依赖关系必须是直接的。您需要修改 POM 以将该工件声明为直接依赖关系。

通过手动编辑 POM，或者使用“项目”窗口中的弹出式菜单项，可以使该工件成为直接依赖关系。


[start=1]
1. 展开 MyEditor 模块的“库”节点。

[start=2]
1. 右键单击  ``org.openide.util-lookup``  工件，然后选择“声明为直接依赖关系”。

选择“声明为直接依赖关系”后，IDE 便会修改 POM 以将该工件添加为依赖关系。

*注意：* ``org.openide.util-lookup``  工件已经是 MyViewer 模块的直接依赖关系。


=== 指定 NetBeans 安装的位置

缺省情况下，当使用 Maven 原型创建 NetBeans 平台模块套件时，不会指定任何目标 NetBeans 安装。要在 IDE 安装中安装并运行模块套件，您需要指定安装目录的路径，方法是编辑 POM 项目中的  ``profiles.xml``  文件。


[start=1]
1. 展开 MavenSelectionSuite 应用程序下的“项目文件”节点，然后双击  ``profiles.xml``  以在编辑器中打开该文件。

[start=2]
1. 修改  ``<netbeans.installation>``  元素以指定目标 NetBeans 平台的路径，然后保存更改。

[source,xml]
----

<profile>
   <id>netbeans-ide</id>
   <properties>
       <netbeans.installation>/home/me/netbeans-6.9</netbeans.installation>
   </properties>
</profile>
----

*注意：*此路径需要指定包含可运行文件的  ``bin``  目录所在的目录。

例如，在 OS X 上，您的路径可能与下面的内容类似。


[source,xml]
----

<netbeans.installation>/Applications/NetBeans/NetBeans6.9.app/Contents/Resources/NetBeans</netbeans.installation>
----


=== 运行应用程序

现在，您已经指定了 IDE 的目标安装，接下来便可以对套件项目使用“运行”命令。


[start=1]
1. 右键单击 MavenSelectionSuite，然后选择“运行”。

选择“运行”后，将会启动安装了模块套件的 IDE 实例。


image::images/maven-suite_maven-suite-run1.png[title="My Viewer 和 MyEditor 窗口"]

MyViewer 窗口会在应用程序启动时打开，并将显示两个文本标签。现在，您可以从“文件”菜单中选择 "Open Editor"，以在编辑器区域中打开一个 MyEditor 组件。MyViewer 窗口将显示具有焦点的 MyEditor 组件的详细信息。

缺省情况下，模块套件项目的“运行”操作会被配置为使用 Reactor 插件以递归方式对指定为套件组成部分的模块执行生成和打包操作。您可以打开项目的属性窗口以查看被映射到 IDE 中的操作的 Maven 目标。


image::images/maven-suite_maven-suite-run-action.png[title="My Viewer 和 MyEditor 窗口"]

在属性窗口的“操作”类别中，可以看到被映射到“运行”操作的目标。


== 动态修改 Lookup

目前，每当您打开一个新的 MyEditor 组件时，都会创建一个新的  ``APIObject`` 。在此部分，您将在 MyEditor 组件中添加一个按钮，以便将组件当前的  ``APIObject``  替换为一个新对象。您将修改代码以使用  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util-lookup/org/openide/util/lookup/InstanceContent.html[InstanceContent]``  动态处理对 Lookup 内容所做的更改。


[start=1]
1. 展开 MyEditor 项目，然后在编辑器的“设计”视图中打开  ``MyEditor``  窗体。

[start=2]
1. 将一个按钮拖至该窗体上，然后将该按钮的文本设置为 "Replace"。

[start=3]
1. 右键单击该按钮，然后选择“事件”> "Action" > "actionPerformed" 来为该按钮创建事件处理程序方法，接着在源代码编辑器中打开该窗体。

[start=4]
1. 将下面的  ``final``  字段添加到类中。

[source,java]
----

public class MyEditor extends TopComponent {
    *private final InstanceContent content = new InstanceContent();*
----

要利用  ``InstanceContent`` ，您需要在构造函数中使用  `` link:http://bits.netbeans.org/dev/javadoc/org-openide-util-lookup/org/openide/util/lookup/AbstractLookup.html#AbstractLookup%28org.openide.util.lookup.AbstractLookup.Content%29[AbstractLookup]``  而不是  ``Lookup`` 。


[start=5]
1. 通过复制类构造函数中的代码行并添加对  ``content.set``  的调用，修改  ``jButton1ActionPerformed``  事件处理程序方法的主体，使其与以下内容类似。

[source,java]
----

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
    *APIObject obj = new APIObject();
    jTextField1.setText ("APIObject #" + obj.getIndex());
    jTextField2.setText ("Created: " + obj.getDate());
    setDisplayName ("MyEditor " + obj.getIndex());
    content.set(Collections.singleton (obj), null);*
}
----


[start=6]
1. 修改构造函数以删除您复制到事件处理程序中的代码行，然后将  ``associateLookup``  更改为使用  ``AbstractLookup``  并添加  ``jButton1ActionPerformed(null);`` 。现在，该构造函数应如下所示。

[source,java]
----

public MyEditor() {
    initComponents();
    *associateLookup(new AbstractLookup(content));
    jButton1ActionPerformed(null);*
}
----

您已将  ``jButton1ActionPerformed(null);``  添加到构造函数中，以确保组件在创建时被初始化。


[start=7]
1. 修复导入并保存更改。

当再次运行模块套件项目时，便会在每个 MyEditor 组件中看到新按钮。单击该按钮时，文本字段中的索引编号将会增加。MyViewer 窗口中的标签也将更新以与新值相对应。

本教程演示了如何创建和运行您通过 Maven 原型创建的 NetBeans 平台模块套件。您看到了如何构建模块套件以及如何配置模块 POM 以指定公共包。还学习了如何修改父 POM 项目以指定目标 NetBeans 安装，这样 IDE 中的“运行”命令就可以安装该套件并启动平台的新实例。有关如何生成 NetBeans 平台应用程序和模块的更多示例，请参见  link:https://netbeans.apache.org/kb/docs/platform_zh_CN.html[NetBeans 平台学习资源]中所列的教程。


== 另请参见

有关在 NetBeans 平台上进行创建和开发的更多信息，请参见以下资源。

*  link:https://netbeans.apache.org/kb/docs/platform_zh_CN.html[NetBeans 平台学习资源]
*  link:https://netbeans.apache.org/wiki/[NetBeans 开发者常见问题解答]
*  link:http://bits.netbeans.org/dev/javadoc/[NetBeans API Javadoc]

如果您有任何有关 NetBeans 平台的问题，可随时写信至邮件列表 dev@platform.netbeans.org，或查看  link:https://mail-archives.apache.org/mod_mbox/netbeans-dev/[NetBeans 平台邮件列表归档]。