使用 Maven 创建 NetBeans 模块套件

配置 Maven 选项

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

1. 在“选项”窗口中选择“其他”类别，然后单击 "Maven" 标签。
2. 指定 Maven 在本地的安装位置（要求为 2.0.9 或更高版本）。
3. 确认本地 Maven 资源库的位置正确无误。
4. 单击“确定”。

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

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

查看 Maven 资源库

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

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

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

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

在 MyAPI 模块中创建类

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

1. 在“项目”窗口中展开 MyAPI 项目。
2. 右键单击“源包”节点，然后选择“新建”>“Java 类”。
3. 在“类名”中键入 APIObject，然后从“包”下拉列表中选择 com.mycompany.mavenselectionsuite。单击“完成”。
4. 修改该类以声明一些字段，并添加以下简单方法。

   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;
      }
   
   }

5. 修复导入并保存更改。

指定公共包

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

1. 右键单击项目节点，然后选择“属性”以打开属性窗口。
2. 在“公共包”类别中选择 "com.mycompany.mavenselectionsuite" 包。单击“确定”。

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

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

3. 右键单击项目，然后选择“生成”。

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

有关详细信息，请参见 nbm-maven-plugin 清单文档。

创建模块

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

1. 从主菜单中选择“文件”>“新建项目”(Ctrl-Shift-N)。
2. 从 "Maven" 类别中选择“Maven NetBeans 模块”。单击“下一步”。
3. 在“项目名称”中键入 MyViewer。
4. 确认“项目位置”为 MavenSelectionSuite 目录。单击“完成”。
5. 右键单击“项目”窗口中的“库”节点，然后选择“添加依赖关系”。
6. 在“打开的项目”标签中选择 "MyAPI NetBeans Module"。单击“确定”。
   

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

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

<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>

创建窗口组件

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

1. 右键单击 MyViewer 项目，然后选择“新建”>“窗口”。
2. 从下拉列表中选择 "navigator"，然后选择“在应用程序启动时打开”。单击“下一步”。
3. 在“类名前缀”中键入 MyViewer。单击“完成”。
4. 将两个标签从“组件面板”拖至该组件中，然后将顶部标签的文本更改为 "[nothing selected]"。
   
5. 单击“源”标签，然后修改类签名以实现 LookupListener。

   public class MyViewerTopComponent extends TopComponent implements LookupListener {

6. 通过将插入光标置于代码行中并按 Alt-Enter 组合键来实现抽象方法。
7. 添加以下 private 字段 result 并将初始值设置为 null。

   private Lookup.Result result = null;

8. 对 componentOpened()、componentClosed() 和 resultChanged() 方法进行以下更改。

   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 ("");
       }
   }

   通过使用 Utilities.actionsGlobalContext()，每当打开一个组件时，该类都可以全局侦听具有焦点的组件的 Lookup 对象。当关闭组件时，Lookup 即会被删除。resultChanged() 方法实现了 LookupListener，以便根据具有焦点的 APIObject 来更新窗体中的 JLabel。

9. 修复导入，并确保添加了 org.openide.util.Utilities。保存所做的更改。

创建模块

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

1. 从主菜单选择“文件”>“新建项目”。
2. 从 "Maven" 类别中选择“Maven NetBeans 模块”。单击“下一步”。
3. 在“项目名称”中键入 MyEditor。
4. 确认“项目位置”为 MavenSelectionSuite 目录。单击“完成”。
5. 在“项目”窗口中右键单击该项目的“库”节点，然后选择“添加依赖关系”。
6. 在“打开的项目”标签中选择 "MyAPI NetBeans Module"。单击“确定”。

添加操作

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

1. 右键单击 MyEditor 项目，然后选择“新建”>“操作”以打开“新建操作”对话框。
2. 选择“始终启用”。单击“下一步”。
3. 保留“GUI 注册”页中的缺省设置。单击“下一步”。
4. 在“类名”中键入 OpenEditorAction。
5. 在“显示名称”中键入 Open Editor。单击“完成”。

   IDE 在编辑器中打开 OpenEditorAction 类，并在 layer.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>

6. 修改 OpenEditorAction 类中的 actionPerformed 方法。

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

添加编辑器组件

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

1. 右键单击“源包”，然后选择“新建”>“其他”，并从“Swing GUI 窗体”类别中选择“JPanel 窗体”。单击“下一步”。
2. 在“类名”中键入 MyEditor，然后选择 "com.mycompany.myeditor" 包。单击“完成”。
3. 将两个文本字段拖至该组件中。
4. 通过取消选择每个文本字段的 editable 属性来使这些文本字段成为只读字段。
   
5. 单击“源”标签，然后修改类签名以扩展 TopComponent 而不是 javax.swing.JPanel。

   public class MyEditor extends TopComponent

6. 将插入光标置于签名中，然后按 Alt-Enter 组合键以修复代码中的错误，方法是搜索 Maven 资源库，然后添加对 org.openide.windows 工件的依赖关系。修复导入。
   
7. 修改构造函数，以便每次调用 APIObject 类时都会创建该类的新实例。

   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 的新实例。

8. 修复导入并保存更改。

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

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

声明直接依赖关系

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

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

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

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

1. 展开 MyEditor 模块的“库”节点。
2. 右键单击 org.openide.util-lookup 工件，然后选择“声明为直接依赖关系”。

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

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

指定 NetBeans 安装的位置

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

1. 展开 MavenSelectionSuite 应用程序下的“项目文件”节点，然后双击 profiles.xml 以在编辑器中打开该文件。
2. 修改 <netbeans.installation> 元素以指定目标 NetBeans 平台的路径，然后保存更改。

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

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

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

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

运行应用程序

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

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

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

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

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

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