netbeans.apache.org/src/old_content/content/tutorials/70/nbm-maven-quickstart_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.
//

= 在 NetBeans 平台中使用 Maven 的快速入门
:jbake-type: platform_tutorial
:jbake-tags: tutorials 
:jbake-status: published
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:icons: font
:experimental:
:description: 在 NetBeans 平台中使用 Maven 的快速入门 - Apache NetBeans
:keywords: Apache NetBeans Platform, Platform Tutorials, 在 NetBeans 平台中使用 Maven 的快速入门

欢迎使用  link:https://netbeans.apache.org/platform/[*NetBeans 平台*]！

本文档快速演示了如何创建一个简单的 NetBeans 平台应用程序和模块，并在生成框架中使用 Maven。在本文档中，您将使用 Maven 原型来创建 NetBeans 平台应用程序和模块。您将使用 Swing UI 工具包和 "Matisse" GUI 生成器来在模块中创建一个窗口组件。利用 NetBeans 平台的模块化特性，您可以简单地通过添加新模块来开发和扩展应用程序的功能。

本文档根据基于 Ant 的 link:nbm-quick-start_zh_CN.html[针对 NetBeans 平台的 NetBeans 平台快速入门]而编写，阐述了使用 Ant 和 Maven 开发 NetBeans 平台应用程序的一些不同之处。在了解 Maven 与 Ant 之间的不同之处后，您便可以轻松地继续学习  link:https://netbeans.apache.org/kb/docs/platform_zh_CN.html[NetBeans 平台学习资源]上的其他教程。

如果您使用的是 NetBeans IDE 6.8，请参见 link:68/nbm-maven-quickstart.html[在 NetBeans 平台 6.8 中使用 Maven 的快速入门]。

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







*注意：*为开发适用于 NetBeans 平台的应用程序，您无需下载该平台的独立版本。通常，您是在 NetBeans IDE 中开发应用程序和模块，并且只包含运行 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 应用程序简介]


== 配置 Maven

如果这是您首次创建 Maven 项目，则需要在“选项”窗口中检查 Maven 配置设置。要学完本教程，您的本地系统中必须安装有 Maven。可以从  link:http://maven.apache.org/[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 已被激活。

IDE 使用 Maven SCM 签出 Maven 工件。您可能希望检查本地计算机上是否安装了签出源文件所需的任何客户端，并对它们进行了正确配置。

有关 Maven SCM 的详细信息，请参见  link:http://maven.apache.org/scm/index.html[Maven SCM 页]。


=== 查看 Maven 资源库

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

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

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

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

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

当将光标置于某个工件上时，IDE 将显示包含其坐标的工具提示。在浏览器中双击工件的 JAR 文件，可以查看有关该工件的其他详细信息。

单击“Maven 资源库”浏览器工具栏上的“查找”按钮，或使用主工具栏中的“快速搜索”文本字段，可以搜索工件。

有关管理 Maven 类路径依赖关系和在 IDE 中使用 Maven 资源库的详细信息，请参见  link:http://wiki.netbeans.org/MavenBestPractices[Best Practices for Apache Maven in NetBeans 6.x]（NetBeans 6.x 中 Apache Maven 的最佳做法）的 link:http://wiki.netbeans.org/MavenBestPractices#Dependency_management[Dependency Management]（依赖关系管理）部分。

要观看使用工件查看器的演示，请参见 link:https://netbeans.apache.org/kb/docs/java/maven-dependencies-screencast.html[处理 Maven 依赖关系]截屏视频。


== 创建 NetBeans 平台应用程序项目

在此部分，您将使用“新建项目”向导来通过 Maven 原型创建 NetBeans 应用程序。该向导会创建您在 NetBeans 平台上开发应用程序所需的 Maven 模块项目。该向导还提供了在应用程序项目中创建 NetBeans 模块的选项，但在本教程中，您将单独创建每个模块。


=== 创建项目

请执行下列步骤，以使用“新建项目”向导创建 NetBeans 平台应用程序。


[start=1]
1. 选择“文件”>“新建项目”(Ctrl-Shift-N) 以打开“新建项目”向导。

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

[start=3]
1. 在“项目名称”中键入 *MavenPlatformWordApp* 并设置“项目位置”。单击“完成”。 
image::images/maven-quickstart_maven-newproject.png[title="“新建项目”向导的屏幕快照"]

*注意：*如果这是您第一次使用 Maven 创建 NetBeans 平台应用程序，则创建项目可能会耗费一些时间，因为 IDE 需要从 NetBeans 资源库中下载所有必需的工件。

单击“完成”后，缺省情况下 IDE 会创建以下 Maven 项目类型。

* *NetBeans 平台应用程序。*此项目是平台应用程序的容器项目，它列出了要包含的模块和项目资源库的位置。此项目不包含任何源文件。IDE 在此项目的子目录中生成包含源文件和资源的模块。
* *基于 NetBeans 平台的应用程序。*此项目指定编译应用程序所需的工件（源文件）。在此项目的  ``pom.xml``  文件中，指定了必需的依赖关系（IDE 工件和模块工件）。如果展开“库”节点，可以看到 NetBeans 平台应用程序所需的库。
* *平台应用程序标记资源。*此项目包含用于标记应用程序的资源。

对于所有 Maven 项目， ``pom.xml``  文件 (POM) 都位于“项目”窗口中的“项目文件”节点下。如果查看 NetBeans 平台应用程序项目的 POM，可以看到由向导创建的其他两个模块已被列为该应用程序的模块。


[source,xml]
----

<modules>
   <module>branding</module>
   <module>application</module>
</modules>

----


=== 修改标记元素

标记模块用于指定在生成平台应用程序时所使用的标记资源。使用标记对话框，您可以方便地修改应用程序的标记属性，以更改其名称、闪屏和文本元素的值。

当通过原型创建 NetBeans 平台应用程序时，该应用程序的缺省名称便是应用程序的工件 Id。在本练习中，您将使用标记向导来修改应用程序的名称，并替换闪屏的缺省图像。

*注意：*IDE 需要首先生成标记模块，然后您才能修改标记资源。


[start=1]
1. 右键单击*平台应用程序标记资源*模块，然后选择“标记”。

[start=2]
1. 在“基本”标签中，将“应用程序标题”修改为 *My Maven Platform Word App*。
image::images/maven-quickstart_maven-branding1.png[title="“新建项目”向导的屏幕快照"]

[start=3]
1. 单击“闪屏”标签，然后单击缺省闪屏图像旁边的“浏览”按钮以查找其他图像。单击“确定”。

您可以将下面的图像复制到本地系统，然后在标记对话框中将该图像指定为闪屏。


image::images/maven-quickstart68_splash.gif[title="缺省闪屏图像的示例"]


== 创建 MavenWordEngine 模块

在此部分，您将创建一个名为 MavenWordEngine 的新模块。然后，您将修改该模块以添加一个窗口组件，并在该窗口组件中添加一个按钮和一个文本区域。


=== 创建模块

在本练习中，您将在包含标记模块和应用程序模块的同一个目录中创建一个新模块项目。


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

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

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

[start=4]
1. 单击“浏览”，然后找到 MavenPlatformWordApp 目录作为“项目位置”。单击“完成”。

image::images/maven-quickstart_maven-wizard-project-location.png[title="“新建项目”向导的屏幕快照"]

如果查看 MavenWordEngine 模块的 POM，则会看到该项目的  ``artifactId``  为 *MavenWordEngine*。


[source,xml]
----

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

----

要生成 NetBeans 模块，您需要使用  ``nbm-maven-plugin`` 。如果查看该模块的 POM，可以看到 IDE 自动为  ``packaging``  指定了  ``nbm`` ，并将 *nbm-maven-plugin* 指定为生成插件。


[source,xml]
----

<plugin>
   <groupId>org.codehaus.mojo</groupId>
   <artifactId>*nbm-maven-plugin*</artifactId>
   <version>3.2-SNAPSHOT</version>
   <extensions>true</extensions>
</plugin>

----

如果查看 NetBeans 平台应用程序的 POM，可以看到 *MavenWordEngine* 已被添加到应用程序的模块列表中。


[source,xml]
----

<modules>
   <module>branding</module>
   <module>application</module>
   <module>*MavenWordEngine*</module>
</modules>

----


=== 使模块成为 MavenPlatformWordApp 的依赖关系

在本练习中，您将通过在 POM 中添加依赖关系，将 MavenWordEngine 模块声明为基于 NetBeans 平台的应用程序的依赖关系。此应用程序的 POM 声明了以下依赖关系。


[source,xml]
----

<dependencies>
    <dependency>
        <groupId>org.netbeans.cluster</groupId>
        <artifactId>platform</artifactId>
        <version>${netbeans.version}</version>
        <type>pom</type>
    </dependency>
    <dependency>
        <groupId>com.mycompany</groupId>
        <artifactId>branding</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>
----

如果展开基于 NetBeans 平台的应用程序的“库”节点，可以看到其中包含对标记模块和其他一些库的依赖关系，这些库是生成应用程序所需的群集依赖关系。


image::images/maven-quickstart_maven-projects-libraries.png[title="“添加依赖关系”对话框的屏幕快照"]

您可以展开非类路径依赖关系列表以查看依赖关系的完整列表。

要在 POM 中添加依赖关系，您可以直接在编辑器中编辑 POM，也可以通过从“项目”窗口中打开“添加依赖关系”对话框进行添加。


[start=1]
1. 在“项目”窗口中展开 "MavenPlatformWordApp - NetBeans Platform based application"。

[start=2]
1. 右键单击“库”节点，然后选择“添加依赖关系”。

[start=3]
1. 单击“打开的项目”标签，然后选择 *MavenWordEngine*。单击“确定”。

image::images/maven-quickstart_maven-add-dependency1.png[title="“添加依赖关系”对话框的屏幕快照"]

*注意：*在 IDE 完成扫描和更新索引之后，新项目将出现在对话框中。

如果在“项目”窗口中展开 MavenPlatformWordApp 的“库”节点，可以看到 MavenWordEngine 现在已被列为依赖关系。


=== 在模块中添加窗口组件

在本练习中，您将使用向导来将窗口组件添加到 MavenWordEngine 模块中。


[start=1]
1. 在“项目”窗口中右键单击 "MavenWordEngine NetBeans Module"，然后选择“新建”>“其他”以打开“新建文件”向导。

[start=2]
1. 在“模块开发”类别中选择“窗口”。单击“下一步”。

[start=3]
1. 在“窗口位置”下拉列表中，选择 "output"。单击“下一步”。
image::images/maven-quickstart_maven-new-window.png[title="“新建文件”向导中窗口组件页的屏幕快照"]

[start=4]
1. 在“类名前缀”字段中键入 *Text*。单击“完成”。

向导会显示将创建和修改的文件列表。

单击“完成”后，可以在“项目”窗口中看到 IDE 在“源包”下面的  ``com.mycompany.mavenwordengine``  中生成了  ``TextTopComponent.java``  类。IDE 还在“其他源”下面的  ``com.mycompany.mavenwordengine``  中生成了其他资源文件。在本练习中，您将仅编辑  ``TextTopComponent.java`` 。

可以在“文件”窗口中查看项目的结构。要编译 Maven 项目，“源包”（“文件”窗口中的  ``src/main/java``  目录）下只能放置源文件。其他资源（例如，XML 文件）需要置于“其他源”（“文件”窗口中的  ``src/main/resources``  目录）下面。


=== 修改窗口组件

在本练习中，您将在窗口组件中添加一个文本区域和一个按钮。然后，您将修改由按钮调用的方法，以将文本区域中的字母更改为大写字母。


[start=1]
1. 在编辑器中单击  ``TextTopComponent.java``  的“设计”标签。

[start=2]
1. 将一个按钮和一个文本区域从“组件面板”拖放到窗口中。

[start=3]
1. 右键单击文本区域并选择“更改变量名称”，然后键入 *text* 作为名称。当通过代码访问该组件时，将使用此名称。

[start=4]
1. 将按钮的文本设置为 "*Filter!*"。
image::images/maven-quickstart68_maven-nbm-textopcomponent.png[title="“新建文件”向导中窗口组件页的屏幕快照"]

[start=5]
1. 在“设计”视图中双击 "Filter!" 按钮元素，以在源代码编辑器中打开该按钮的事件处理程序方法。当双击该按钮元素时，将会自动为其创建方法。

[start=6]
1. 修改方法的主体以添加下列代码。保存所做的更改。

[source,java]
----

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
   *String s = text.getText();
   s = s.toUpperCase();
   text.setText(s);*
}
----

可以在编辑器中使用代码完成功能来帮助键入代码。

如果您希望测试应用程序是否可以正常运行，可以右键单击 "MavenPlatformWordApp - NetBeans Platform based application" 项目节点，然后选择“使用依赖关系生成”。

映射到“使用依赖关系生成”的缺省操作为使用 Reactor 插件生成项目。在使用 Reactor 插件生成项目时，首先将生成子项目的依赖关系，然后再生成包含项目。“输出”窗口将显示生成顺序。


image::images/maven-quickstart_maven-buildwithdependencies1.png[title="“输出”窗口中 Reactor 生成顺序的屏幕快照"]

还会在“输出”窗口中显示生成结果。


image::images/maven-quickstart_maven-buildwithdependencies2.png[title="“输出”窗口中 Reactor 生成成功的屏幕快照"]

如果查看“项目”窗口，则会看到这些项目不再带有标记，因为所需依赖关系的工件此时在“本地资源库”的 "com.mycompany" 节点下可用。


image::images/maven-quickstart_maven-localrepo.png[title="“本地资源库”的屏幕快照"]

要运行项目，请右键单击 "MavenPlatformWordApp - NetBeans Platform based application" 项目节点，然后选择“运行”。在应用程序启动后，您可以通过执行下列步骤来测试该应用程序。


[start=1]
1. 从平台应用程序的主菜单中选择 "Window" > "Text" 以打开 Text 窗口。

[start=2]
1. 在文本区域中键入一些小写字母，然后单击 "Filter!"。

[start=3]
1. 退出 Maven Platform Word App。

当单击 "Filter!" 时，您所键入的字母会被更改为大写并显示在文本区域中。


== 创建 TextFilter 模块

在本练习中，您将创建一个名为 *TextFilter* 的模块，并将该模块作为依赖关系添加到应用程序中。TextFilter 模块将提供一个服务，且仅包含一个接口。然后，可以通过使用 lookup 来访问其他模块中的服务。


=== 创建模块

在本练习中，您将执行下列步骤来创建 TextFilter 模块。


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

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

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

[start=4]
1. 单击“浏览”以设置“项目位置”并找到 MavenPlatformWordApp 目录。单击“完成”。

单击“完成”后，IDE 会创建模块，并在“项目”窗口中打开 "TextFilter NetBeans Module" 模块项目。

IDE 会修改 POM 项目 "MavenPlatformWordApp - NetBeans Platform Application" 的  ``pom.xml`` ，以将新模块添加到要在项目中包含的模块列表中。


[source,xml]
----

<modules>
    <module>branding</module>
    <module>application</module>
    <module>MavenWordEngine</module>
    <module>TextFilter</module>
</modules>
----

创建模块后，您需要将该模块添加为应用程序的依赖关系。


=== 将 TextFilter 模块添加为 MavenPlatformWordApp 的依赖关系

在本练习中，您要将 TextFilter 模块添加为 "MavenPlatformWordApp - NetBeans Platform based application" 的依赖关系。


[start=1]
1. 右键单击 "MavenPlatformWordApp - NetBeans Platform based application" 项目的“库”节点，然后选择“添加依赖关系”。

[start=2]
1. 在“添加依赖关系”对话框中，单击“打开的项目”标签。

[start=3]
1. 选择 "TextFilter NetBeans Module" 模块。单击“确定”。

单击“确定”后，IDE 会将该模块添加为项目的依赖关系。如果展开“库”节点，可以看到该模块已被添加到依赖关系列表中。在 "MavenPlatformWordApp - NetBeans Platform based application" 的 POM 中，可以看到 IDE 在  ``dependencies``  元素中添加了以下代码行。


[source,xml]
----

<dependency>
   <groupId>${project.groupId}</groupId>
   <artifactId>TextFilter</artifactId>
   <version>${project.version}</version>
</dependency>
----


=== 在 TextFilter 模块中添加接口

在本练习中，您将在 TextFilter 模块中添加一个简单的接口。


[start=1]
1. 右键单击 "TextFilter NetBeans Module"，然后选择“新建”>“Java 接口”。

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

[start=3]
1. 在“包”下拉列表中选择 "com.mycompany.textfilter"。单击“完成”。

[start=4]
1. 修改该类以添加下列代码。保存所做的更改。

[source,java]
----

package com.mycompany.textfilter;

public interface TextFilter {
    *public String process(String s);*
}
----


=== 公开 TextFilter 模块

在本练习中，您将公开  ``com.mycompany.textfilter``  包的内容，以便其他模块可以访问其方法。要将包声明为公共包，您需要在 POM 中修改  ``nbm-maven-plugin``  的  ``configuration``  元素，以指定将由插件作为公共包导出的包。您可以在编辑器中更改 POM，也可以通过在“项目属性”对话框中选择要公开的包来进行更改。


[start=1]
1. 右键单击 "TextFilter NetBeans Module"，然后选择“属性”。

[start=2]
1. 在“项目属性”对话框中选择“公共包”类别。

[start=3]
1. 选择 "com.mycompany.textfilter" 包。单击“确定”。

image::images/maven-quickstart_maven-public-packages.png[title="属性对话框的屏幕快照"]

单击“确定”后，IDE 会修改项目 POM，从而修改  ``nbm-maven-plugin``  工件的  ``configuration``  元素以添加下列条目。


[source,xml]
----

<publicPackages>
   <publicPackage>com.mycompany.textfilter</publicPackage>
</publicPackages>
----

现在，POM 包含以下条目。


[source,xml]
----

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

    </configuration>
</plugin>
----

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


== 创建 MyFilter 模块

在本练习中，您将创建 *MyFilter* 模块，然后将该模块添加为 TextFilter 的依赖关系。然后，可以通过查找 TextFilter 服务来调用 MyFilter 中的方法。


=== 创建模块

在本练习中，您将创建一个名为 *MyFilter* 的模块。要创建此模块，您需要执行与创建 TextFilter 模块相同的步骤。


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

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

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

[start=4]
1. 单击“浏览”以设置“项目位置”并找到 *MavenPlatformWordApp* 目录。单击“完成”。

[start=5]
1. 将 MyFilter 模块添加为 "MavenPlatformWordApp - NetBeans Platform based application" 项目的依赖关系。


=== 将 TextFilter 模块添加为依赖关系

在本练习中，您会将 TextFilter 模块添加为 MyFilter 模块的依赖关系。


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

[start=2]
1. 在“添加依赖关系”对话框中，单击“打开的项目”标签。

[start=3]
1. 选择 *TextFilter* 模块。单击“确定”。


=== 修改 MyFilter 模块

在本练习中，您将添加一个 Java 类，该类仅包含一个名为  ``process``  的方法，用于将字符串转换为大写字母。您还将指定该类实现 TextFilter 接口。您将使用  ``@ServiceProvider``  标注来将 TextFilter 指定为将在编译时注册的服务。


[start=1]
1. 右键单击 *MyFilter* 模块，然后选择“新建”>“Java 类”。

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

[start=3]
1. 在“包”下拉列表中选择 "com.mycompany.myfilter"。单击“完成”。

[start=4]
1. 修改该类以添加下列代码。保存所做的更改。

[source,java]
----

package com.mycompany.myfilter;

import com.mycompany.textfilter.TextFilter;
import org.openide.util.lookup.ServiceProvider;

*@ServiceProvider(service=TextFilter.class)*
public class UpperCaseFilter *implements TextFilter {

    public String process(String s) {
        return s.toUpperCase();
    }*
}
----

请注意是如何使用标注来指定服务提供器的。有关  ``@ServiceProvider``  标注以及 ServiceLoader 机制在 JDK 6 中的行为的详细信息，请参见《实用程序 API》文档。


=== 修改 MavenWordEngine 模块

在本练习中，您将修改 Text 窗口组件中的事件处理程序，以使用 lookup 来调用 TextFilter 接口并访问 MyFilter 中的方法。在事件处理程序中添加代码之前，您需要声明对 TextFilter 模块的依赖关系。


[start=1]
1. 右键单击 *MavenWordEngine* 模块的“库”节点，然后添加对 TextFilter 模块的依赖关系。

[start=2]
1. 展开 *MavenWordEngine* 模块的“源包”，然后在源代码编辑器中打开  ``TextTopComponent`` 。

[start=3]
1. 修改  ``jButton1ActionPerformed``  按钮处理程序方法以添加下列代码。保存所做的更改。

[source,java]
----

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
    String s = text.getText();
    *TextFilter filter = Lookup.getDefault().lookup(TextFilter.class);
    if (filter != null) {
        s = filter.process(s);
    }*
    text.setText(s);
}
----

可以使用代码完成功能来帮助您完成代码。

此时，可以检查您的应用程序是否可以正常运行。接下来，您将添加一个新的窗口组件，该组件会显示您使用过滤器处理过的文本的历史记录。


== 在 Text 窗口组件中添加 LookupListener 和 InstanceContent

在本练习中，您将添加一个侦听程序和一个字段，以便在单击 "Filter!" 按钮时存储文本区域的内容。


[start=1]
1. 在 *MavenWordEngine* 模块中，通过添加以下代码来添加  ``InstanceContent``  对象并修改  ``TextTopComponent``  的构造函数。

[source,java]
----

public final class TextTopComponent extends TopComponent {
    *private InstanceContent content;*

    public TextTopComponent() {
        initComponents();
        setName(NbBundle.getMessage(TextTopComponent.class, "CTL_TextTopComponent"));
        setToolTipText(NbBundle.getMessage(TextTopComponent.class, "HINT_TextTopComponent"));
        //        setIcon(Utilities.loadImage(ICON_PATH, true));

        *content = new InstanceContent();
        associateLookup(new AbstractLookup(content));*
    }
----


[start=2]
1. 修改  ``jButton1ActionPerformed``  方法，以便在单击按钮时将旧的文本值添加到  ``InstanceContent``  对象中。

[source,java]
----

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
     String s = text.getText();
     TextFilter filter = Lookup.getDefault().lookup(TextFilter.class);
     if (filter != null) {
         *content.add(s);*
         s = filter.process(s);
     }
     text.setText(s);
 }
----


== 创建 History 模块

在此部分，您将创建一个名为 *History* 的模块，用于显示  ``InstanceContent``  的值。要创建此模块，您需要执行与创建 TextFilter 和 MyFilter 模块相同的步骤。


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

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

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

[start=4]
1. 单击“浏览”以设置“项目位置”并找到 MavenPlatformWordApp 目录。单击“完成”。

[start=5]
1. 将 History 模块添加为 "MavenPlatformWordApp - NetBeans Platform based application" 项目的依赖关系。


=== 在 History 模块中创建窗口组件

在本练习中，您将使用向导在模块中添加窗口组件。


[start=1]
1. 在“项目”窗口中右键单击 "History NetBeans Module"，然后选择“新建”>“其他”以打开“新建文件”对话框。

[start=2]
1. 在“模块开发”类别中选择“窗口”。单击“下一步”。

[start=3]
1. 在“窗口位置”下拉列表中选择 "editor"。单击“下一步”。

[start=4]
1. 在“类名前缀”字段中键入 *History*。单击“完成”。向导会显示将创建和修改的文件列表。


=== 修改 History 窗口组件

现在，您将在窗口组件中添加一个文本区域元素，用于显示已过滤的字符串。


[start=1]
1. 在编辑器中单击  ``HistoryTopComponent.java``  的“设计”标签。

[start=2]
1. 将一个文本区域从“组件面板”拖放到窗口中。

[start=3]
1. 右键单击文本区域并选择“更改变量名称”，然后键入 *historyText* 作为名称。

[start=4]
1. 在  ``HistoryTopComponent``  的构造函数中添加  ``private``  字段  ``result``  和以下代码，以使其侦听当前活动窗口 String 类的 lookup 事件，并在文本区域中显示所有检索到的 String 对象。

[source,java]
----

      *private Lookup.Result result;*

      public HistoryTopComponent() {
          initComponents();
          ...

          *result = org.openide.util.Utilities.actionsGlobalContext().lookupResult(String.class);
          result.addLookupListener(new LookupListener() {
              public void resultChanged(LookupEvent e) {
                  historyText.setText(result.allInstances().toString());
              }
          });*
      }
----


== 生成和运行应用程序

现在，可以测试此应用程序。


[start=1]
1. 右键单击 "MavenPlatformWordApp - NetBeans Platform based application" 项目节点，然后选择“清理”。

[start=2]
1. 右键单击 "MavenPlatformWordApp - NetBeans Platform based application" 项目节点，然后选择“使用依赖关系生成”。

[start=3]
1. 右键单击 "MavenPlatformWordApp - NetBeans Platform based application" 项目节点，然后选择“运行”。

单击“运行”后，IDE 会启动 NetBeans 平台应用程序。您可以从 "Window" 菜单中打开 History 和 Text 窗口。

image::images/maven-quickstart_maven-final-app.png[title="最终 NetBeans 平台应用程序的屏幕快照"]

当在 Text 窗口中键入文本并单击 "Filter!" 按钮时，该文本会被转换为大写字母并添加到 History 窗口的内容中。

本快速入门教程说明了使用 Maven 创建 NetBeans 平台应用程序与使用 Ant 创建应用程序并无太大差异。主要的不同之处在于 Maven POM 控制应用程序组装的方式。有关如何生成 NetBeans 平台应用程序和模块的更多示例，请参见  link:https://netbeans.apache.org/kb/docs/platform_zh_CN.html[NetBeans 平台学习资源]中所列的教程。


== 另请参见

有关创建和开发应用程序的更多信息，请参见以下资源。

*  link:https://netbeans.apache.org/kb/docs/platform_zh_CN.html[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 平台邮件列表归档]。