Java 开发者的 NetBeans IDE 入门手册（一）
一、安装和设置
由于其开箱即用的体验，NetBeans 是学习 Java 的最佳入门 IDE。一个简单的点击式安装过程提供了您需要的所有工具，以及一个友好而直观的用户界面来开发各种 Java 应用。—Zoran Sevarac，塞尔维亚贝尔格莱德大学助理教授，欧米诺创始人
在本章中，我将向您介绍 NetBeans IDE，之后我将为您提供启动和运行 IDE 所需的信息。你会发现这个过程很简单，很快你就能完成一个基本的场景，如第二章中所描述的，它将引导你完成用 IDE 用 Java 编程的工作流程。
什么是 NetBeans IDE？
IDE 是一个 100%免费的开源开发环境，可以帮助您创建不同种类的软件应用。在本书的上下文中，我们将特别关注 IDE 作为开发 Java 应用的环境。IDE 支持所有类型的 Java 应用，帮助您开发使用所有 Java 技术的项目—Java SE、Java EE、嵌入式和云。
IDE 是模块化的，可以通过插件进行扩展。本章将向您介绍的下载包中包含的特性非常广泛，您不需要使用任何插件，至少最初不需要。
Java 是用来编写 IDE 的语言。它可以在安装了 Java 开发工具包(JDK)的操作系统上运行。指导您完成 ide 安装和设置过程的安装程序适用于 Windows、Linux 和 Mac OSX。IDE 也可以作为 ZIP 或 TAR 文件下载，如果您想在没有提供安装程序的操作系统上使用 IDE，这可能会很有用。
出于本书的目的，IDE 的存在是为了简化 Java 应用的开发过程。如果没有 IDE，Java 开发中固有的编辑-编译-调试循环会很麻烦，而且容易出错。为了克服和帮助开发过程，IDE 集成了用于这些活动的工具。具体来说，IDE 会执行以下操作:
- 通知您代码中的问题，并在 Java 编辑器中突出显示它们。
- 使用 Java 编辑器中的代码模板、代码完成和提示等编辑器功能，帮助您快速高效地进行编码。
- 在 Java 编辑器中键入时显示类和方法的文档。
- 包括可视化导航帮助，包括导航器和编辑器功能(如代码折叠),以及许多加速编码的键盘快捷键。
- 在“输出”窗口中提供超链接，使您可以从编译错误跳转到 Java 编辑器中找到相关有问题代码的行。
- 通过在整个代码中管理对包、类和方法名称的引用，帮助管理应用代码中的更改。当您移动或重命名代码时，IDE 会找到受您的更改影响的相关代码，并让您控制是否应该自动更改相关代码。
- 附带一个调试器和分析器，它们协同工作，帮助您快速轻松地识别代码中的问题。当代码运行时，您可以逐句通过它并设置断点，而不需要添加打印语句。分析器允许您识别代码中的瓶颈，例如导致性能问题和死锁的区域。
- 允许您将开发工作流集成到一个单一的环境中，包括将代码签入和签出版本控制系统，如 Git、Mercurial 和 Subversion。
IDE 的优势
就像其他开发环境一样，IDE 由一组编辑器和图形工具组成，用于高效编码和快速检测问题。IDE 从创建项目开始，通过编辑过程，指导您编译、调试和打包应用。
在使用 IDE 时，您可以使用它的免费和先进的工具和功能，而不会有将代码移动到单一集成开发环境中的缺点。例如，IDE 的独特之处在于它支持的基于 Maven、Gradle 或 Ant 的项目架构和构建结构也是基于开放标准的。其他 ide 使用专有的元数据和其他文件对您强制执行特定于 IDE 的结构和过程，因此当您想要在其他 IDE 之外运行应用时，您需要更改应用架构。使用 NetBeans ide，您可以确保您所做的工作在 IDE 外部编译和运行，就像在 IDE 内部一样。当您使用 Hudson 或 Jenkins 等连续构建服务器时，以及当您使用 Maven 作为构建工具时，这尤其方便。
在为新的和不断发展的软件标准提供支持方面，IDE 始终与潮流保持一致，甚至走在潮流的前面。当您使用 Java 时，您可以确保 IDE 支持最新的规范和技术，并且您从它那里获得的所有帮助都基于最新的标准。例如，通过重构工具、批处理分析器、Java 提示和语法着色，IDE 的 Java 编辑器支持最新的语言功能，尤其是那些与 Java SE 8 中引入的 lambdas 和函数操作相关的功能。
IDE 的新用户往往会对“开箱即用”的特性感到惊讶，也就是说，不需要安装任何额外的插件。IDE 内置了一个全功能的 Java EE 平台开发环境，同样是开箱即用的。Java SE 应用可用的编辑器、调试器、分析器和项目支持也可用于 Java EE 开发，无需任何设置或配置。
下载 IDE
您可以从 NetBeans.org 网站下载 IDE:
http://www.netbeans.org/downloads/index.html
您也可以从 Oracle.com 网站下载它和 JDK:
http://www.oracle.com/technetwork/java/javase/downloads
最好使用最新版本的 JDK 和 IDE。在撰写本文时，IDE 的最新版本是 NetBeans IDE 8.1。本书通篇使用 NetBeans IDE 8.1，并且假设您在阅读本书时使用的是 NetBeans IDE 8.1。
图 1-1 显示了 NetBeans.org 上可用的下载包。
图 1-1。
NetBeans IDE download bundles
NetBeans IDE 下载包包含表 1-1 中描述的功能。对于本书中的说明，您需要 Java EE 下载包。一般来说，当您学习 Java 语言时，Java SE 下载包是您所需要的，因为它包括 Java 编辑器、调试器和分析器。然而，当您作为 Java 开发人员受雇于一个组织时，您通常会创建使用 Java EE 平台的应用，因为 Java EE 是一个用于创建复杂的企业 Java web 应用的集成解决方案。Java EE 下载包提供了在使用 Java EE 平台时很有用的工具。简而言之，Java EE 下载包包含了 IDE 提供的全套 Java 特性，是您在阅读本书时应该下载并安装的下载包。
表 1-1。
NetBeans IDE Download Bundles
| 下载捆绑包 | 特征 | | --- | --- | | Java SE | 提供创建 Java 桌面应用的功能，包括 JavaFX 和 Swing 用户界面工具，包括 Java 编辑器、Java 调试器和 Java profiler。 | | 容器 | 提供与 Java SE 发行版相同的功能，以及用于 Java EE 平台的工具，如 Java servlets、Java Server Faces、Java Persistence API、Enterprise Java Beans、Java RESTful Web 服务，以及用于框架(如 PrimeFaces)的代码生成器。包括用于注册和部署到 GlassFish 和 Tomcat 的工具，以及管理部署到这些服务器的应用的工具。 | | C/C++ | 提供开发 C 和 C++应用的功能，包括项目模板、编辑器、代码生成器、调试器和用于配置管理的生成文件向导。 | | HTML5/JavaScript 和 PHP | 为 HTML5 web 应用提供特性，包括 HTML5、JavaScript 和 CSS3 的编辑器、模板和代码生成器，以及使用 Cordova 创建部署到 iOS 和 Android 的混合移动应用。包括一个 JavaScript 调试器、SASS 和更少工具以及 JavaScript 框架支持，例如 Knockout.js 和 AngularJS。PHP 的特性包括编辑器、代码模板、代码生成器和调试器，以及与 MYSQL 和其他数据库服务器的集成。 | | 全部 | 在一个下载包中提供上述所有工具。您不太可能需要“All”发行版，建议您使用其他下载包之一，特别是最符合您实际需求的下载包。 |Note
对于 Java 开发，也就是说，如果您希望使用 Java SE、Java EE 或所有发行版，那么在系统上安装 IDE 和 Java 运行时环境(JRE)对于运行 IDE 是不够的。你需要有 JDK，也就是 Java 开发工具包，里面包括 JRE。IDE 依赖于 JDK 提供的开发工具，如javac编译器，并利用该下载的其他部分，如它包含的 JDK 源代码。去这里下载 JDK 的最新版本: http://www.oracle.com/technetwork/java/javase/downloads
安装 IDE
一旦下载了 IDE，安装就很简单了。首先确保您的系统上安装了合适版本的 JDK，必须是 JDK 7 或更高版本。打开命令提示符并运行以下命令:
java -version
您应该会看到类似于以下内容的输出:
java version "1.8.0_40-ea"
Java(TM) SE Runtime Environment (build 1.8.0_40-ea-b23)
Java HotSpot(TM) 64-Bit Server VM (build 25.40-b25, mixed mode)
您可以看到 JDK 8 更新 40 已安装。如果命令不被识别，进入 http://www.oracle.com/technetwork/java/javase/downloads ，下载最新版本的 JDK 并安装。
一旦安装了 JDK，就可以开始安装 IDE 了。在 Windows 上，双击在上一节中下载的 IDE 安装程序。在 Mac OSX 或 Linux 上，从命令提示符启动安装程序。如下所述，逐步完成安装向导。
Figure 1-2 shows the first screen in the wizard that you use to install the IDE. As you can see, together with the IDE, you can install the GlassFish server and the Apache Tomcat server. GlassFish is useful if you want to work with Java EE, while Apache Tomcat is focused on Java web applications, which do not make full use of the Java EE platform. For the purposes of this book, you should install the GlassFish server so that you can use the IDE tools that relate to the Java EE platform.
图 1-2。
Welcome to the NetBeans IDE installer
图 1-3 显示了使用 IDE 时需要同意的许可条款。
图 1-3。
License agreement
图 1-5。
Summary Once you have gone through Steps 1-3, the installer shows where the IDE will be installed. If you click the Check for Updates checkbox, the IDE will notify you when new versions of installed features are available and prompt you to let the IDE install them. In Figure 1-4 you can see that you need to specify the location where the IDE will be installed, together with the JDK that will be used to start it. If you need to change the JDK used to start the NetBeans IDE after you have installed it, you can use the netbeans.conf file, which is in the installation directory’s etc folder, to point to a different JDK.
图 1-4。
NetBeans IDE installation folder and JDK location
完成这些步骤后，IDE 将开始安装过程，如图 1-6 所示。
图 1-6。
NetBeans IDE installation
如图 1-7 所示，安装程序会在安装过程完成时通知您。您可以通过让 IDE 定期自动提交您使用 IDE 的匿名数据来帮助 IDE 工程师改进 IDE。
图 1-7。
Setup complete
这就是你所需要做的，NetBeans IDE 现在已经安装好了，如图 1-8 所示。如您所见，安装程序会引导您在系统上选择一个 JDK 来运行 IDE，并且在 Windows 上，可以创建桌面图标和开始菜单项来启动 IDE。
图 1-8。
Figure 1-8.
使用麦克·OSX
尽管 IDE 可以在 Windows、Linux 和 Mac OSX 上运行，但是了解 IDE 使用方式的不同是很重要的。为了保持一致，也为了避免因操作系统的不同而混淆本书，所有图片和描述都假设您使用的是 Windows。在 Linux 发行版上，IDE 的行为与 Windows 相同，当然，IDE 本身看起来很不一样。在 Mac OSX 上，IDE 不仅看起来不同，而且在某些特定方面的行为也不同。不仅在本书中，而且在使用 IDE 本身时，了解这些差异以避免许多挫折是很重要的。
最重要的是，每当这本书告诉你通过在 IDE 的菜单栏中进入工具➤选项来打开选项窗口时，如果你使用的是 Mac OSX，你应该转到 NetBeans ➤首选项，如图 1-9 所示。
图 1-9。
Accessing the Options window on Mac OSX via NetBeans ➤ Preferences
整本书使用的键盘快捷键也需要稍微调整一下，以便与 Mac OSX 配合使用。一般来说，当你看到使用 Ctrl 键的快捷键时，你应该使用 Mac OSX 上的 Cmd 键。例如，在 Windows 和 Linux 上，你使用 Ctrl+C 将字符复制到键盘上，而在 Mac OSX 上，你使用 Cmd+C。欲知详情和更多例子，请访问以下网址: https://netbeans.org/kb/articles/mac.html 。
现在您已经下载并安装了 IDE，并且知道了与 Mac OSX 的区别，您已经准备好创建您的第一个“hello world”应用，这将是下一章的重点。
二、入门指南
NetBeans 只是一个完整且组织有序的工具箱。当你需要时，一切都很容易找到并随手可得。NetBeans 开箱即用，无需进一步组装，使用起来非常直观。新用户从一开始就很有效率。—安东·埃普勒，埃普勒顿 IT 咨询公司的创始人和所有者
在本章中，您将使用 NetBeans IDE 完成一个简单的 Java“Hello World”示例。之后，我将向您展示 IDE 提供的示例项目，以帮助您开始使用各种技术。本章以对 IDE 主窗口的探索结束。花一些时间熟悉 IDE 提供的工作区的关键组件是一个好主意。
你好世界
当您启动 IDE 时，会出现一个欢迎窗口，其中有指向感兴趣内容的链接，如图 2-1 所示。
图 2-1。
Welcome screen
为了帮助您激活 IDE，本节提供了设置、编译和运行“Hello World”项目的快速演练。
To set up the project, start by choosing File ➤ New Project. The New Project window opens, as shown in Figure 2-2.
图 2-2。
The New Project window In the New Project window, expand the Java node, select Java Application, and click Next. The Java Application template sets up a basic project and includes a main class. In the Name and Location page of the window, type "HelloWorld" as the project name, as shown in Figure 2-3.
图 2-3。
Setting the name and location in the New Project window In the Create Main Class field, change helloworld.HelloWorld to com.mydomain.myproject.HelloWorld. When you enter a fully-qualified class name in this field, the IDE will generate directories for each level of the package structure when you complete this process. Click Finish.
IDE 会为您创建一个新的 Java 项目，如图 2-4 所示。
图 2-4。
Newly created Java project
完成该窗口后，IDE 将扫描为项目设置的类路径，以启用代码完成等功能。现在已经填充了几个窗口，如图 2-5 所示。
图 2-5。
Windows populated when Java project is created
您在图 2-5 中看到的窗口如下所述。
- “项目”窗口位于工作区的左上角。它提供了对您的源代码、您可能有的任何测试以及您的类路径的访问。您可以在“项目”窗口中显示多个项目。
- 导航器位于工作区的左下方。它为您查看和访问当前选定类的成员提供了一种简单的方法。
- 源代码编辑器覆盖了工作区的主要区域。它提供了多个文档的选项卡，比如 Java 文件。
HellowWorld.java类的标签自动打开。
现在让我们修改、构建并运行项目。
In the Source Editor, click within the main method at the end of the line that reads // TODO code application logic here. Press the Enter key and then type the following statement.
System.out.println("Hello World!");
另一种更快且利用代码模板的方法是键入字符sout，然后按 Tab 键。此外，代替sout，您可以键入soutv并按 Tab 键，您将看到在System.out.println语句中引用的最近的变量。
Press Ctrl+S to save the file. Press F11 (or choose Build ➤ Build Main Project) to compile and package the application. This command triggers a script that the IDE has generated and maintains for the project. The Output window opens and displays the output from the script as it runs through its targets, as shown in Figure 2-6.
图 2-6。
Output window Press F6 (or choose Run ➤ Run Main Project) to run the project. The Output window should display the "Hello World!" message from your application, as shown in Figure 2-7.
图 2-7。
“Hello World!” message in Output window
请注意，您不需要单独构建和运行应用。当您运行项目时，任何没有构建到 Java 类中的文件都会自动为您构建。至此，您已经在 IDE 中创建和运行了您的第一个应用！
用示例代码尝试 IDE
如果您想在不接触现有文件的情况下检查 IDE 在工作代码上的功能，或者您只想查看 IDE 中工作项目的外观，您可以打开一个或多个 IDE 示例项目。
当您创建一个示例项目时，示例代码被复制到您选择的目录中，并且生成所有必需的项目元数据。
To create a sample project, choose File ➤ New Project. In the New Project window, expand the Samples folder and choose a template from one of the categories, as shown in Figure 2-8. Then click Next.
图 2-8。
Samples in the New Project window Choose a sample and click Next. On the Name and Location page of the window, check the generated values for the name and location of the project and change them, if you wish. Then click Finish.
探索 IDE
现在，您将通过浏览组成 IDE 的所有窗口来了解自己。有如此多的窗口，不可能在一张图像中捕捉到它们。其中很多如图 2-9 所示。在随后的部分中，我将依次浏览每个窗口。
图 2-9。
Most windows open in the IDE
IDE 中的窗口可以分为五类，具体取决于它们提供的视图。
- 项目视图
- 文件视图
- 层次视图
- 服务视图
- 支持观点
项目视图
“项目”窗口(Ctrl+1)是项目源的主要入口点。它显示了重要项目内容的逻辑视图；也就是说，它向您显示了您最有可能想要处理的文件，这些文件被组织在您可能容易理解的文件夹中。
除了“项目”窗口，IDE 还提供了“文件”窗口(Ctrl+2)，如图 2-10 所示，这样您就可以看到属于一个项目的所有文件。例如，每当构建一个项目时，即编译其文件时，都会创建一个新的“build”文件夹(对于基于 Ant 的项目)或一个新的“target”文件夹(对于基于 Maven 的项目)，尽管它只显示在文件窗口中，因为您不太可能想要处理将要重新生成的文件。通常,“项目”窗口仅显示那些不会被对项目或其文件执行的操作覆盖的文件。
图 2-10。
Projects Window and Files Window
收藏夹窗口(Ctrl+3)提供了第三个项目视图。“收藏夹”窗口允许您访问磁盘上的所有文件夹和文件。它相当于一个文件浏览器，内置于 IDE 中。在“收藏夹”窗口中，您可以添加在磁盘上找到的任意文件夹和文件，这样您就可以轻松地访问和浏览 IDE 中您特别感兴趣的文件夹和文件。默认情况下，用户目录被添加到此窗口，尽管您可以删除它，添加其他文件夹和文件，或者执行这些操作的组合。
文件视图
导航窗口(Ctrl+7)如图 2-11 所示，提供了当前所选文件的紧凑视图，并简化了文件不同部分之间的导航。
图 2-11。
Navigator window
例如，对于 Java 文件，导航窗口显示构造函数、方法和字段的列表，而对于 HTML 和 CSS 文件，它显示所选文档的逻辑结构。
层次视图
如图 2-12 所示的层次窗口(Alt+F12)显示了当前选中的 Java 文件的超类型和子类型，或者当前选中的 Java 类型在编辑器中的光标下。
图 2-12。
Hierarchy window
“层次结构”窗口与“导航”窗口和 Javadoc 窗口集成在一起，因此您可以很容易地看到所选项目的元素及其 Javadoc。
服务视图
如图 2-13 所示，服务窗口(Ctrl+5)可让您访问许多辅助资源，如数据库、服务器、web 服务和问题跟踪器。
图 2-13。
Services window
您可以直接在 IDE 中启动和停止数据库和服务器。使用数据库时，可以在 IDE 中添加、删除和修改数据。将应用部署到服务器时，您可以管理已部署的资源，因为它们显示在“服务器”节点中。您可以连接到 bug 数据库，如 Issuezilla 或 Bugzilla，并在 IDE 中列出项目的问题报告。
支持观点
可用于支持项目视图、文件视图和服务视图的窗口是输出窗口、属性窗口、操作项窗口、任务窗口和通知窗口。
输出窗
输出窗口(Ctrl+4)如图 2-6 和 2-7 所示，是一个多选项卡窗口，显示来自 IDE 的处理消息。当遇到编译错误、调试程序和生成 Javadoc 文档时，它会自动显示。您可以在选项窗口中配置输出窗口的显示选项。
如果包含错误的文件是打开的，当您在源代码编辑器中将插入点移到错误中时，源代码编辑器将跳转到包含每个错误的行。您也可以使用 F12 和 Shift+F12 键盘快捷键移动到文件中的下一个和上一个错误。
当运行需要用户输入的程序时,“输出”窗口中会出现一个新的选项卡。该选项卡包含一个光标。您可以像在命令行上一样在输出窗口中输入信息。
属性窗口
属性窗口(Ctrl+Shift+7)如图 2-14 所示，显示当前选中项目的属性。例如，可以在“项目”、“文件”或“导航”窗口中表示的大多数项都具有可以在“属性”窗口中查看的属性。
图 2-14。
Properties window
根据当前选定的项，可以在“属性”窗口中编辑某些属性的值。要更改属性值，请单击属性值字段。字段的外观根据所需值的类型而变化。
行动项目窗口
如图 2-15 所示，行动项窗口(Ctrl+6)显示了一个统一的问题列表，您需要在您的各种文件和项目中解决这些问题。
图 2-15。
Action Items window
您可以使用过滤器来确定列表中显示的条目，并且可以通过单击列标题来对列表进行排序。
任务窗口
任务窗口(Ctrl+Shift+6)，如图 2-16 所示，提供了任务库中记录的任务的有组织的概述，例如 Bugzilla 和 JIRA。
图 2-16。
Tasks window
通知窗口
如图 2-17 所示，通知窗口显示了当前 IDE 会话中出现的 IDE 消息、错误和警告的列表。您可以在列表中选择一个通知，以便在窗口的右窗格中查看有关该通知的详细信息。
图 2-17。
Notifications window
三、Java 编辑器
我没有时间去学习每一个小事件、动作或可用的处理程序类型，NetBeans 会提供建议和语法自动完成功能，只需自动按键。这个功能非常流畅，已经取代了我的网络搜索。—肖恩·菲利普斯，地面系统工程师，美国宇航局 MMS 和 JWST 任务
NetBeans IDE 提供了一组相互关联的工具来支持 Java 应用开发。然而，尤其是源代码编辑器，您将在那里花费大部分时间。鉴于这一事实，很多注意力都集中在提供源代码编辑器中及其周围的特性和微妙之处，以帮助开发人员更快、更有效地编码。本章详细研究了使用源代码编辑器简化和加速常见编码任务的方法，特别是针对 Java 文件。
概观
当您编写、编辑和重构 Java 代码时，许多编辑器特性都是可用的。例如，其中之一是代码完成，有时也被称为“智能感知”，如图 3-1 所示。使用它来了解光标所在的上下文，并生成代码或提供适用于该上下文的信息。
图 3-1。
Code completion
代码生成功能和应用中文件导航的键盘快捷键确保您的手很少需要离开键盘。
请注意，源代码编辑器是不同类型编辑器的集合，每种编辑器都包含特定于某些文件的功能。例如，当您打开一个 Java 文件(这是本章的重点)时，有一个专门针对 Java 文件的语法突出显示方案，以及代码完成、重构和其他与 Java 文件相关的特性。同样，当您打开 JSP、HTML、XML 和其他类型的文件时，您会看到一组适用于这些文件类型的特性。
也许最重要的是，源代码编辑器与 IDE 的其他部分紧密集成，这极大地简化了您的工作流程。例如，您可以直接在源代码编辑器中定义断点，并在 Java 代码执行时跟踪它。同样，当“输出”窗口中报告编译错误时，可以通过单击错误或按 F12 键跳转到这些错误的来源。
入门指南
本节帮助您熟悉源代码编辑器的布局和结构。这里描述了与开始使用源代码编辑器相关的最直接的任务。后续章节将详细介绍具体的功能。在这里，您可以根据邮件列表和其他地方的用户问题，了解到用户对于源代码编辑器的最基本的初始关注。
打开文件
在开始使用源代码编辑器之前，通常需要设置一个 NetBeans 项目。然后，您可以在项目中打开一个现有的 Java 文件，或者从模板创建一个新的 Java 文件。下一章将详细介绍这些任务，所以这里不再详细讨论。相反，您将快速浏览基本过程，让您在源代码编辑器中有一个 Java 文件，为本章的其他部分做准备。
选择文件➤新建项目，单击文件工具栏中的新建项目按钮，或者按 Ctrl+Shift+N。此时会出现新建项目窗口，如图 3-2 所示，您可以创建一个新的 Java 项目，这将在下一章中讨论。
图 3-2。
New Project window
一旦你有了一个项目，你会想要在其中创建新的文件。要在项目中创建新的 Java 文件，选择文件➤新建文件，单击文件工具栏中的新建文件按钮，或按 Ctrl+N。此时会出现新建文件窗口，如图 3-3 所示，您可以在其中创建新的 Java 文件。
图 3-3。
New File window
打开没有项目的文件
如果您想在不设置项目的情况下用 Java 编写代码，可以使用文件➤打开文件打开磁盘上的特定 Java 文件。使用文件➤打开最近使用的文件(Ctrl+Shift+T)打开自 IDE 打开以来最近关闭的文件。
或者，你可以使用收藏夹窗口(Ctrl+3)，如图 3-4 所示。“收藏夹”窗口允许 IDE 访问系统中的任意文件夹和文件。
图 3-4。
The Favorites window
但是，请注意，虽然收藏夹窗口在您只想快速打开和编辑几个文件时会很有用，但它并不是为全面的 Java 应用开发而设计的，比如使用重构工具。
要使用“收藏夹”窗口访问源代码编辑器而无需创建项目，请从“窗口”菜单中选择“收藏夹”,或按 Ctrl+3。这将打开收藏夹窗口。通过在“收藏夹”窗口中右键单击，选择“添加到收藏夹”，然后从文件选择器中选择文件夹，来添加您希望文件存放的文件夹(或它已经存放的文件夹)。在“收藏夹”窗口中，导航到要编辑的文件，双击它以在源代码编辑器中打开它。如果要创建新文件，请右键单击文件夹节点，选择“新建”，然后在文件夹中创建新文件夹或文件。
重新配置源代码编辑器
现在您已经打开了一个或多个 Java 文件，是时候放松一下了！第一步是按照您希望的方式设置源代码编辑器。
首先，您会很高兴知道您可以拆分源代码编辑器来同时查看多个文件或查看同一文件的不同部分，如图 3-5 所示。若要拆分源代码编辑器窗口以查看多个文件，请确保至少有两个文件已经打开。单击一个文件上的选项卡，按住鼠标按钮，然后将该选项卡拖到源代码编辑器的最左侧、最右侧或底部。当开始拖动时选项卡周围出现的红色轮廓变为矩形时，释放鼠标按钮。这表示拆分窗口的位置。
图 3-5。
Viewing multiple files simultaneously
您可以在 IDE 中使用各种不同的工具同时查看同一文件的不同部分，如图 3-6 所示。
图 3-6。
Splitting a single file
- 克隆文档。在源代码编辑器中右键单击文件的选项卡，然后选择“克隆文档”为同一文档创建第二个选项卡。如果需要，拖放其中一个选项卡来创建一个分割源代码编辑器区域。请参见前面关于拖放源代码编辑器选项卡的过程。
- 拆分文档。在源代码编辑器中右键单击文件的选项卡，然后选择“拆分文档”。然后选择垂直或水平，这取决于您想要如何拆分文档。
- 拆分文档按钮。从每个编辑器文档的右上角垂直或水平拖动“拆分文档”按钮，根据需要拆分编辑器。
接下来，让我们探索一下为代码腾出更多空间可以采取的措施。
- 双击文件的标签。当您这样做时，除了主菜单和工具栏行之外，该文件将占用 IDE 的整个空间。您可以通过再次连按标签来使其他窗口重新出现。
- 使其他窗口成为“滑动”窗口。右键单击其他窗口的标签并选择“最小化”,使它们成为滑动窗口。只有当您在 IDE 的一个边缘上单击或鼠标悬停在代表该窗口的按钮上时，它们才会出现。您可以通过单击滑动窗口中的按钮将窗口恢复到正常显示。
- 隐藏 ide 的工具栏。您可以在视图菜单中切换主工具栏的显示，在视图菜单中您可以选择工具栏。然后，您可以单独选择要隐藏或显示的工具栏。通过选择“显示编辑器工具栏”,可以在“视图”菜单中切换源代码编辑器工具栏的显示。
更改键盘快捷键、字体和颜色
您可以更改默认键盘快捷键或将其他可用命令映射到快捷键。如果您熟悉其他 IDE 中定义的键盘快捷键，您可以选择使用这些快捷键，而不是 NetBeans IDE 提供的默认快捷键。
此外，如果您熟悉其他 IDE 或编辑器中的字体和颜色，或者出于某种原因，您不喜欢编辑器或整个 IDE 中使用的默认颜色，您可以相对容易地切换到您喜欢的字体和颜色组合。
要修改键盘快捷键，请从“工具”菜单中选择“选项”。当“选项”窗口打开时，单击“键盘映射”面板。在“操作”列表中，导航到要更改的操作，单击省略号按钮，然后单击“编辑”。键入要使用的键盘快捷键，然后按 Enter 键。
如图 3-7 所示，IDE 附带了 Eclipse、IntelliJ IDEA 和 Emacs 的键盘快捷键配置文件，您可以从 Keymap 面板的配置文件下拉框中选择其中的任何一个。您也可以创建自己的个人资料。
图 3-7。
Switching Keymap profiles in the Options window
要修改源代码编辑器的字体和颜色，请从“工具”菜单中选择“选项”。当选项窗口打开时，点击字体和颜色面板，如图 3-8 所示。从配置文件下拉框中选择一个配置文件。如果要微调配置文件，请使用类别列表导航到要修改的类成员，然后根据需要使用字体、前景、背景、效果和效果颜色组件。使用预览区域来确保您已经根据自己的要求进行了定制。然后按回车。
图 3-8。
Switching Fonts & Colors profiles in the Options window
例如，如果您从 Profile 下拉列表中选择 Norway Today，而不做任何进一步的更改，编辑器将如图 3-9 所示。
图 3-9。
“Norway Today” Font and Color profile
去下面的网址设计并下载你自己的主题: netbeansthemes。com 。
如今，深色背景在开发工具中越来越受欢迎。通过安装深色外观和感觉主题插件，你可以在整个 IDE 中切换到深色背景。
为此，请从“工具”菜单中选择“插件”。当插件管理器打开时，单击可用插件面板。选择并安装深色观感主题插件，如图 3-10 所示。
图 3-10。
Dark Look and Feel Themes plugin
安装插件并重启 IDE 后，IDE 看起来如图 3-11 所示。
图 3-11。
Dark Metal look and feel
然而，插件提供了两种不同的黑暗主题。此外，默认情况下还提供了各种其他主题，这些主题是由 Swing 的“外观和感觉”实现定义的。
要在主题之间切换，请从“工具”菜单中选择“选项”。当选项窗口打开时，点击外观面板，如图 3-12 所示。使用首选外观下拉菜单来切换主题。
图 3-12。
Switching between look and feels in the Options window
将主题切换到黑暗光轮并重启 IDE 后，看起来如图 3-13 所示。
图 3-13。
The Dark Nimbus look and feel
比较两个文件之间的差异
您可以生成两个文件的并排比较，突出显示不同的行。
要比较两个文件，右键单击要比较的两个文件。选择工具，然后选择差异，如图 3-14 所示。
图 3-14。
Diff menu item in the Tools menu
源代码编辑器中出现 Diff 窗口，如图 3-15 所示。
图 3-15。
Diff window
在比较文档时，比较窗口中的颜色显示删除的行(红色)、更改的行(蓝色)和添加的行(绿色)。
请注意，只有在“项目”、“文件”或“收藏夹”窗口中选择了两个(且不超过两个)文件时,“比较”项才会出现在“工具”菜单中。
打字
当您在源代码编辑器中键入时，您首先会注意到的一件事是，当您键入开始字符时，会自动插入结束字符。例如，如果键入引号，右引号将插入行尾。同样，圆括号(())、方括号([])和花括号({})也为您完成了。
虽然这乍一看似乎令人惊讶，但该功能的设计不会妨碍您。如果您自己键入结束字符，自动插入的字符将被覆盖。此外，您可以通过键入分号(；)来完成一个语句。分号插入在自动生成的一个或多个字符之后的行尾。
有关如何使用匹配结束字符插入的信息，请参见以下副标题。
整理和连接
当源代码编辑器在行尾插入匹配字符时，这似乎会迫使您在键入分号之前手动将插入点移过结束字符。
事实上，您可以按住 Ctrl 键，在不移动插入点的情况下键入分号，它将自动放置在行尾。当您按住 Shift 键和 Ctrl 键，然后在不移动插入点的情况下键入分号时，会在分号后添加一个新行。
例如，要获得该行
ArrayList ls = new ArrayList();
你只需要打字
ArrayList ls = new ArrayList(;
如果有一个很长的字符串，您想将它分成两行，那么当您按 Enter 键时，源代码编辑器会添加连接字符串的语法。例如，要得到这些线
String s = "Though typing can seem tedious, reading long" +
"and convoluted sentences can be even worse."
你可以打字
String s = "Though typing can seem tedious, reading long
and convoluted sentences can be even worse.
最后三个引号和加号(+)是为您添加的。
如果您想在不创建连接的情况下换行，请按 Shift+Enter。
匹配文件中的其他单词
如果您键入的单词出现在文件中的其他位置，您可以使用键盘快捷键，根据源代码编辑器中找到的与您键入的字符匹配的第一个单词来完成该单词。这个单词匹配功能适用于文件中的任何文本。它还会搜索您最近处理过的文件(按照您上次访问文件的顺序)。按 Ctrl+K 从光标处向后搜索匹配项。按 Ctrl+L 从光标处向前搜索匹配项。
例如，如果您已经在第 100 行定义了方法refreshCustomerInfo,现在想从第 50 行调用该方法，您可以键入ref,然后按 Ctrl+L。如果在第 50 行和第 100 行之间没有其他以ref开头的单词，那么剩余的单词refreshCustomerInfo将被填充。如果找到不同的匹配项，请一直按 Ctrl+L，直到填入所需的匹配项。
对于键入变量名，您可能会发现单词匹配功能比代码完成功能更好，因为与代码完成功能相比，IDE 只需在几个文件中搜索文本字符串，而在代码完成功能中，IDE 会搜索整个类路径。
文本选择快捷键
为了让您的双手都放在键盘上，许多快捷键允许您选择文本、取消选择文本以及更改所选文本。参见表 3-1 了解这些快捷键的选择。
表 3-1。
Text Selection Shortcuts
| 捷径 | 描述 | | --- | --- | | Alt+Shift+J | 选择插入点所在的当前标识符或其他单词。 | | Ctrl+Shift+ | 选择一组圆括号、方括号或花括号之间的所有文本。插入点必须紧接在左括号/右括号/大括号之后。 | | Alt+Shift+句点(Alt+Shift+逗号) | 选择当前代码元素。在后续按下时，递增(Alt+Shift+句点)或递减(Alt+Shift+逗号)选择的大小，以包括周围的代码元素。例如，如果您按 Alt+Shift+句点一次，则当前单词被选中。如果再次按下它，表达式的其余部分可能会被选择。第三次按下可能会选择整个语句。第四次按下可能会选择整个方法。 | | Shift+右(Shift+左) | 选择下一个(上一个)字符或将所选内容扩展一个字符。 | | Ctrl+Shift+向右(Ctrl+Shift+向左) | 选择下一个(上一个)单词或将选择范围扩大一个单词。 | | Shift+向下(Shift+向上) | 向下(向上)创建或扩展一行文本选择。 | | Shift+End (Shift+Home) | 创建文本选择或将文本选择扩展到行尾(行首)。 | | Ctrl+Shift+End (Ctrl+Shift+Home) | 创建文本选择或将文本选择扩展到文档的结尾(开头)。 | | Shift+向下翻页(Shift+向上翻页) | 向下(向上)一页创建或扩展文本选择。 |宏指令
您可以在 IDE 中录制宏，以将通常涉及一长串击键的操作减少到一个键盘快捷键。在宏中，您可以将源代码编辑器中的字符键入和其他键盘快捷键的键入结合起来。
要录制宏:
Put the insertion point in the part of a file in the Source Editor where you want to record the macro. Click the Start Macro Recording button in the Source Editor’s toolbar to begin recording. Record the macro using any sequence of keystrokes, whether it is typing characters or using keyboard shortcuts. Mouse movements and clicks (such as menu selections) are not recorded. Click in the Source Editor’s toolbar to finish recording. In the Macro field of the Recorded Macro window that appears, fine-tune the macro, if necessary. Click Add to assign a keyboard shortcut to the macro. In the Add Keybinding window, press the keys that you want to use for the keyboard shortcut. (For example, if you want the shortcut Alt+Shift+Z, press the Alt, Shift, and Z keys.) If you press a wrong key, click the Clear button to start over.
注意不要使用已经分配的快捷方式。如果您输入的快捷方式是编辑器快捷方式，则对话框中会出现警告。但是，如果组合键是应用于源代码编辑器之外的快捷方式，则不会向您发出警告。
您可以在选项窗口中指定新的快捷方式。选择工具➤选项，单击编辑器面板，选择宏选项卡，然后单击设置快捷方式按钮。
代码片段
源代码编辑器有几个特性可以减少键入代码所需的击键次数。你可以使用这些功能，不需要使用鼠标，不需要使用菜单，也不需要记住键盘快捷键。
可以说，最重要的代码生成机制如下:
-
Ctrl+spacebar. This shortcut opens the code completion box, as shown in Figure [3-16. The code completion box contains a context-sensitive list of ways you can complete the statement you are currently typing and of other code snippets you might want to insert in your code.
图 3-16。
Code completion
-
Multi-keystroke. Abbreviations for longer snippets of code called code templates. These abbreviations are expanded into the full code snippet after you press the spacebar, as shown in Figure 3-17.
图 3-17。
Code templates
-
Alt+Insert. This shortcut opens a small popup, shown in Figure 3-18, from which code snippets can quickly be generated.
图 3-18。
Code generators
-
Alt+Enter. You can use this shortcut to display suggestions the IDE has regarding missing code and then have the IDE insert that code. The IDE notifies you that it has a suggestion by displaying a light bulb icon in the left margin of the line you are typing, as shown in Figure 3-19.
图 3-19。
Java hints
除了节省击键和使用鼠标，这些特性还有助于防止输入错误，并帮助您找到正确的类名和方法名。
下面几节说明了在用 Java 编码时如何充分利用这些特性。
代码完成
当您在源代码编辑器中键入 Java 标识符时，可以使用代码完成功能来帮助您完成表达式。此外，还会出现 Javadoc 文档，并显示代码完成中当前选定项的文档。
各种类型的代码生成工具已经被添加到代码完成功能中。使用代码完成，您可以执行下列操作:
-
Fill in names of classes and class members while reading the related Javadoc documentation, as shown in Figure 3-20.
图 3-20。
Code completion
-
Generate whole snippets of code from dynamic code templates, as shown in Figure 3-21.
图 3-21。
Dynamic code templates
-
Generate getter and setter methods, as shown in Figure 3-22.
图 3-22。
Generate getters and setters
-
Generate skeletons for abstract methods of classes extended by and interfaces implemented by the current class and override inherited methods, as shown in Figure 3-23.
图 3-23。
Override inherited methods
-
Generate skeletons of anonymous inner classes, as shown in Figure 3-24.
图 3-24。
Generate anonymous inner classes
提供了多种机制来打开代码完成框:
- ctrl+空格键。键入表达式的前几个字符，然后按 Ctrl+空格键(或 Ctrl+)。
- 暂停一下。键入句号()后暂停。)在一个表达式中。
- 空间。键入一个空格，然后暂停片刻。
“代码完成”框将打开，其中选择了与您到目前为止键入的内容可能匹配的内容。
若要缩小代码完成框中的选择范围，请继续键入表达式。
若要完成表达式并关闭代码完成框，请执行下列操作之一:
- 打字。继续输入，直到只剩下一个选项，然后按 Enter 键。
- 滚动。使用箭头键或鼠标滚动列表以选择一个值，然后按 Enter。
若要关闭代码完成框而不输入任何选择，请按 Esc。
要完成表达式并保持代码完成框打开，请选择一个完成项并按下句点(.)键。如果您正在链接方法，这将非常有用。例如，如果你想输入
getRootPane()。set default button(default button name)
您可以执行以下操作:
- 键入
getRo(这将在代码完成框中只留下getRootPane())并按下句点(.)键。 - 键入
.setDef(这将使setDefaultButton(JButton defaultButton)成为代码完成框中选定的方法)并按 Enter 键。getRootPane().setDefaultButton(defaultButtonName)现在应该插入到代码中，插入点放在最后一对括号之间。将出现一个工具提示，其中包含要输入的参数类型的信息。 - 键入参数的名称。
- 键入分号(
;)以结束语句。分号自动放在最后一个括号后面。
代码完成技巧
当在代码完成框打开的情况下键入时，有一些技巧可以用来更快地缩小选择范围并生成您要查找的代码。例如:
- 骆驼案。如果你想创建一个
HashSet的实例，你可以输入private HS并按 Ctrl+空格键来显示HashSet(以及其他名字中有大写 H 和大写 S 的类)。 - 逗号(
,)和分号(;)键。使用这些将代码完成框中突出显示的项插入到代码中。逗号或分号被插入到代码中从代码完成框中选择的项之后。 - 选项卡。您可以通过按 Tab 键来填写列表中所有剩余选项的通用文本。当代码完成框中的选择范围缩小到具有相同前缀的选项时，这可以为您节省几次击键(或使用箭头键或鼠标)的时间。例如，如果您正在处理一个
Hashtable对象ht，并且您已经键入了ht.n，那么将会有两个以notify开头的方法(notify()和notifyAll())。要更快地将选择缩小到仅notifyAll()，请按 Tab 键将ht.n扩展到ht.notify，然后键入A。然后，您可以按回车键，用notifyAll()完成该语句。
自定义代码完成设置
如果您喜欢使用不同的快捷键来完成代码，可以在 NetBeans IDE 中更改这些快捷键。从选项菜单中选择工具。选项窗口打开。在选项窗口中，点击编辑器，选择键映射，如图 3-25 所示。在搜索过滤器中，键入code completion。将显示相关的快捷方式，以便您可以根据自己的喜好进行微调。
图 3-25。
Customizing code completion actions
要调整通用格式规则，请从“选项”菜单中选择“工具”。选项窗口打开。在选项窗口中，点击编辑器，选择代码完成，如图 3-26 所示。在语言下拉列表中，选择所有语言后，根据您的喜好微调常规设置。
图 3-26。
Code completion settings in the Options window
正如你在图 3-26 中看到的，如果你发现代码完成框麻烦多于帮助，你可以禁用代码完成弹出窗口的自动出现。如果您通过按 Ctrl+空格键或 Ctrl+\，手动激活代码完成，它仍然可以工作。
您可能会发现有用的另一个典型设置是，您可以启用代码完成弹出窗口的自动外观，但禁用 bulkier Javadoc 代码完成对话框。可以使用 Ctrl+Shift+空格键手动调用 Javadoc 弹出窗口。
您可以调整特定于 Java 的格式规则，如图 3-27 所示。
图 3-27。
Java-specific code completion in the Options window
模板
随着您对 IDE 越来越熟悉，您应该尽量利用它提供的许多功能。例如，如果您花一些时间了解 IDE 的许多不同种类的模板，就可以大大减少您需要键入的内容。本节介绍 IDE 的代码模板和文件模板。到这一节结束时，你应该比以前少打很多字了！
代码模板
当您在源代码编辑器中输入时，您可以使用代码模板来加速常用单词序列和常见代码模式的输入，例如for循环和字段声明。源代码编辑器附带了一组代码模板，但是您也可以创建自己的模板。
有些代码模板是由常用代码的片段组成的，比如private static final int。另一些是动态的，生成一个框架，然后让您轻松地通过 tab 键填充可变文本，而不必使用鼠标或箭头键将光标从一个字段移动到另一个字段。在代码段重复一个标识符的地方，比如迭代器对象，您只需要键入一次标识符名称。
这里有几个例子:
newo模板。创建新的对象实例。键入newo并按 Tab 键。IDE 生成Object name = new Object(args);，并突出显示Object的两次出现。然后可以键入类名并按 Tab 键。两次出现的Object都被更改为类名，然后选择args。然后，您可以填写参数并按 Enter 键，将插入点放在插入的代码的末尾。您可以使用 Shift+Tab 在参数间向后移动。您可以随时按 Enter 键跳过任何参数，直接跳到模板的末尾(或者指定填充模板参数后光标应该停留的位置)。fori模板。您可以使用fori模板创建一个循环来操作数组中的所有元素。该索引被自动赋予一个在当前范围内唯一的名称(默认为i)。您可以手动更改该值(使 IDE 在所有三个位置更改该值),或者直接跳至arr键键入数组名称。如果数组在范围内，默认情况下，IDE 将使用其名称。下一次按 Tab 键时，光标停留在下一行，您可以在这里键入数组处理代码。
您可以通过以下任一方式访问代码模板:
- 代码完成框。键入代码的前几个字母，按 Ctrl+空格键，然后从“代码完成”框的列表中选择模板。模板的完整文本显示在 Javadoc 框中。
- 空格键。在源代码编辑器中直接键入代码模板的缩写，然后按空格键。您可以在键盘快捷键卡片中找到内置 Java 代码模板的缩写，该卡片在 IDE 的帮助菜单下以 PDF 文档的形式提供。如果您在代码完成框中发现了一个代码模板，该模板的缩写将出现在缩写列表的右列中。
如果缩写与您要键入的文本相同(例如，您不希望它扩展为其他内容)，请按 Shift+空格键以防止它扩展。
添加、更改和移除代码模板
IDE 附带的代码模板代表了您可以使用代码模板做的事情，但它们只代表了潜在有用模板的一小部分。
您可以修改现有的代码模板并创建全新的模板，以适应您在代码中经常使用的模式。
要创建新的代码模板:
Choose Tools ➤ Options, click Editor in the left panel, and select the Code Templates tab. Click New. In the New Code Template window, type an abbreviation for the template and click OK. In the Expanded Text field, insert the text for the template. See the “Code Template Syntax” section later in this chapter for information on how to customize the behavior of your templates. Click OK to save the template and exit the Options window.
要修改代码模板:
Choose Tools ➤ Options, click Editor in the left panel, and select the Code Templates tab. Select a template from the Templates table and edit its text in the Expanded Text field. Click OK to save the changes and exit the Options window.
您不能直接更改代码模板的缩写。如果要为现有模板分配不同的快捷方式，请选择该快捷方式，复制其扩展文本，用该文本和不同的缩写创建一个新的代码模板，然后删除带有不需要的缩写的模板。
要删除代码模板，请执行以下操作:
Choose Tools ➤ Options, click Editor in the left panel, and select the Code Templates tab. Select a template from the Templates table and click Remove. Click OK to save the changes and exit the Options window.
代码模板语法
在代码模板中，您可以设置变量文本，为模板用户提供以下好处:
- 显示需要键入的剩余文本的描述性提示。
- 允许一次键入一个标识符，并在多个位置生成它。
- 确保为一个类添加了一个
import语句。 - 指定代码模板的参数是其实例的类型。当模板用于插入代码时，IDE 将自动为该参数生成一个适当的值。
- 自动为迭代器设置一个变量名，确保该变量名尚未在当前作用域中使用。
- 设置一个位置，以便在生成静态文本和填充变量文本后，光标出现在生成的代码片段中。
例如，您可能希望为经常实例化的类轻松生成如下代码:
FileWriter filewriter = new FileWriter(outputFile);
在这种代码模板的定义中，您可以使用类似如下的内容:
${fw type = "java.io.FileWriter"
editable="false"} ${filewriter} = new ${fw}(${outputFile});
当模板插入到代码中时，会发生以下情况:
${fw type = "java.io.FileWriter" editable="false"}被转换成插入代码中的FileWriter。${fw}也被转换成Filewriter(因为它本质上是先前定义的${fw type = "java.io.FileWriter" editable="false"}的简写)。${filewriter}和${outputFile}生成文本(分别为filewriter和outputFile)。filewriter被选中。您可以为该字段键入一个新名称，然后按 Tab 键选择outputFile并为该参数键入一个名称。然后，您可以按 Tab 或 Enter 将光标放在整个生成的代码片段之后。
您可以通过为${outputFile}定义一个instanceof属性来进一步细化代码模板(比如OutputFile instanceof = "java.io.File")。这将使 IDE 能够检测该类的实例，并在生成的代码片段中动态插入实例变量的名称，而不仅仅是outputFile。
更改代码模板的扩展器快捷方式
如果您发现代码模板妨碍了您的工作，因为在您键入某些字符串时无意中调用了它们，您可以配置 IDE 使用不同的键或组合键来激活模板。这使您能够继续使用代码模板特性，而不必单独更改任何妨碍您的模板。
要更改代码模板扩展器键，请选择“工具”“➤选项”,单击左侧面板中的“编辑器”,然后选择“代码模板”选项卡。从展开模板下拉列表中选择首选的键或组合键。单击确定保存更改并退出选项窗口。
文件模板
您可以自定义用来创建文件的模板。您也可以创建自己的模板，并在“新建文件向导”中提供这些模板。如果您需要在所有文件中添加标准元素，例如版权声明，或者您想要改变其他元素的生成方式，这可能会很有用，如图 3-28 所示。
图 3-28。
File templates
模板中有几个宏可以用来在创建的文件中动态生成文本。这些宏可以通过名称前后的双下划线来识别。
要编辑模板:
In the Tools menu, choose Templates. The Template Manager opens. Expand the appropriate category node and select the template that you want to edit. Where possible, click Open in Editor, edit the template, and then save it.
并非模板管理器中列出的所有模板都可以在用户级别修改。在某些情况下，模板在“新建文件”向导中可用，但不代表文件结构，例如企业和 Sun 资源类别中的文件结构。
要基于另一个模板创建新的文件模板:
In the Tools menu, choose Templates. The Template Manager opens. Expand the appropriate category node and select the template that you want to use as a starting point. Click Duplicate. A new node appears for the copied template. _1 is appended to the template’s name. Click Open in Editor. Edit the file, incorporating any of the template macros that you want to use, and save it. If the template is for a Java class, you can use the filename for the classname and constructor name. These are automatically adjusted in the files you create from the template.
要导入文件模板:
In the Tools menu, choose Templates. The Template Manager opens. Select the category folder for the template. Click Add to open the Add Template window. Navigate to and select the file that you want to import as a template. Then click Add.
Java 提示
当 IDE 检测到一个它已经确定可能修复的错误，或者一个用不同方式表达代码的建议时，一个灯泡图标出现在该行的左边，如图 3-29 所示。
图 3-29。
Java hints
您可以单击灯泡或按 Alt+Enter 来显示可能的修复列表。如果其中一个修复适合您，您可以选择它并按 Enter 键，在您的代码中生成该修复。
通常，“错误”不是编码错误，而是与您没有填写丢失的代码有关。在这些情况下，编辑器提示只是自动输入某些类型的代码。其他时候，代码不是“错误的”，而是可以用不同的方式表达，因此编辑器提示建议了表达代码的替代方式。
例如，假设您刚刚输入了下面的代码，但是x没有在类中的任何地方定义。
int newIntegerTransformer () {
return x;
}
如果您的光标仍然停留在return语句的行上，图标将会出现。如果您单击图标或按 Alt+Enter，您将获得三种可能的解决方案。您可以选择其中一个提示来生成代码。
例如，IDE 可以为常见的编码错误提供提示并生成以下解决方案。
-
添加缺失的
import语句。 -
插入在类的实现接口和抽象超类中声明的抽象方法。
-
插入一个
method参数。 -
创建缺失的方法。
-
创建一个缺失字段。
-
创建一个丢失的局部变量。
-
初始化变量。
-
插入石膏。
-
添加一个带有适当例外的
throws子句。 -
用包含适当异常的
try-catch块包围代码。 -
To modify Java hints, choose Options from the Tools menu. In the Options window, click Editor and select Hints, as shown in Figure 3-30. In the Hints list, specify the hints you want to enable. In the Show As dropdown, specify the priority of the hint.
图 3-30。
Customizing Java hints
Java 成员
Java 编辑器有专门为特定种类的 Java 成员创建的工具。
实现和覆盖
当您扩展一个类或实现一个接口时，您有需要实现的抽象方法，也可能有可以重写的非抽象方法。IDE 有几个工具可以帮助您在类中生成这些方法:
- 编辑提示。当您添加
implements或extends子句时，左边空白处会出现一个灯泡图标。您可以单击此图标或按 Alt+Enter 查看实现抽象方法的提示。如果选择提示并按 Enter 键，IDE 将为您生成方法。只有当光标位于类声明的行中时，该提示才可用。 - 代码完成。通过按 Ctrl+空格键并从代码完成框中选择方法，可以生成要分别实现和重写的方法。
爪哇咖啡豆
IDE 为创建 JavaBeans 组件提供了一些级别的支持。您可以使用以下功能:
- 代码完成。当您的类中有一个字段没有对应的
get或set方法时，您可以通过按 Ctrl+空格键并从代码完成框中选择方法来生成该方法。 - 重构/封装字段。您可以使用封装字段命令来生成
get和set方法，更改字段的访问修饰符，并更新直接访问字段的代码以使用 getters 和 setters。 - BeanInfo 生成器。在“项目”窗口中，可以右键单击 JavaBeans 组件，然后选择“BeanInfo 编辑器”。如果 BeanInfo 类不存在，将为您生成一个。
进口
当您使用 IDE 的代码完成和编辑器提示功能时，会自动为您生成import语句。
例如，如果打开代码完成框，开始键入简单类名而不是完全限定类名(例如，键入Con，然后从代码完成框中选择ConcurrentHashMap，下面的import语句将被添加到文件的开头:
import java.util.concurrent.ConcurrentHashMap;
如果这些机制不足以管理import语句，您可以使用以下命令:
- 修复导入(Alt+Shift+F)。自动为整个文件插入任何缺失的
import语句。import语句是按类(而不是按包)生成的。要快速管理您的导入，请使用此命令。 - 快速导入(Alt+Shift+I)。使您能够为当前选定的标识符添加一个
import语句或生成完全限定的类名。如果您想为整个包生成一个import语句，或者如果您想使用一个完全限定的内联类名而不是一个import语句，这个命令非常有用。
文档
IDE 为您提供了几种访问 JDK 和库类文档的方法。
- 要浏览源代码编辑器中当前所选类的文档，请按 Ctrl+Shift+空格键。将出现一个弹出窗口，其中包含该类的 Javadoc 文档。当您使用代码完成时，也会出现此弹出窗口。您可以通过在弹出窗口之外单击来关闭弹出窗口。
- 要打开所选类文档的 web 浏览器，请右键单击该类，然后选择“显示 Javadoc”(或按 Alt+F1)。
- 要在 web 浏览器中打开库文档的索引页面，请选择“查看➤文档索引”,然后从子菜单中选择索引。
一些库的文档与 IDE 捆绑在一起。但是，您可能需要在 IDE 中注册其他库的文档，Javadoc 功能才能工作。
矛盾的是，JDK 文档可以通过源代码编辑器中的弹出窗口获得，但默认情况下不能通过浏览器获得。这是因为源代码编辑器中的 Javadoc 弹出窗口从 JDK 附带的源代码中获取文档。但是，文档的浏览器视图需要编译的 Javadoc 文档，您必须从 JDK 单独下载。
格式化
当您在源代码编辑器中键入或生成代码时，默认情况下，Java 代码会以下列方式自动格式化:
- 类成员缩进四个空格。
- 连续语句缩进八个空格。
- 制表符被转换成空格。
- 左花括号与类或方法的声明放在同一行。
- 左括号前面没有空格。
如果您的文件丢失了正确的格式，您可以通过选择源➤格式(Alt+Shift+F)来重新格式化整个文件。如果选择了一行或多行，则重新格式化仅适用于这些行。如果在“项目”窗口中选择了一个节点，例如一个项目或一个包，或者多个项目、包和文件的组合，则重新格式化仅适用于这些节点的内容。
复制代码后，可以通过使用 Ctrl+Shift+V 快捷方式进行粘贴，以正确的格式插入代码。当您想要从剪贴板复制时，按 Ctrl+Shift+D 显示剪贴板内容的弹出窗口(您复制的文本的历史)，并选择您想要粘贴的项目。
如果您想要查看空格和行尾，请选择查看➤显示不可打印的字符。编辑器看起来如图 3-31 所示。
图 3-31。
Show non-printable characters
手动缩进代码块
您可以选择多行代码，然后通过按 Tab 或 Alt+Shift+Right 来缩进所有这些行。
您可以通过选择这些行，然后按 Shift+Tab 或 Alt+Shift+Left 来反转行的缩进。
编辑器工具栏有两个按钮，可以用来缩进和取消缩进选中的代码行，如图 3-32 所示。
图 3-32。
Indenting blocks of code manually
更改格式规则
对于各种文件类型，您可以调整格式设置，例如每个制表符的空格数、花括号的位置等等。
要调整 Java 文件的格式规则，请从“选项”菜单中选择“工具”。选项窗口打开。在选项窗口中，点击编辑器，选择格式，如图 3-33 所示。在“格式”选项卡中，您可以根据自己的喜好微调设置。
图 3-33。
Changing formatting settings
航行
知道你在某个地方有一段代码，但是不知道它具体在哪里，这可能会非常令人沮丧。这一节向您展示了在文件和项目中快速移动的方法，以便快速有效地管理您的 Java 代码。
在当前 Java 文件中导航
- IDE 提供了几个工具来简化查看和导航给定的 Java 文件:Navigator。出现在“项目”窗口下方，提供当前选定 Java 文件中的成员列表(例如，构造函数、字段和方法)。
- 书签窗口。使您能够跳回到文件中的特定位置。
- 跳转列表。使您能够在您一直工作的区域之间跳转。
- 键盘快捷键。使您能够在编辑器中滚动。
- 代码折叠。使您能够折叠代码部分(如方法体、Javadoc 注释和
import语句块)，从而使您的类的更大部分在给定时间在窗口中可见。
查看和导航类的成员
导航器提供了您的类的所有成员(构造函数、方法和字段)的列表，如图 3-34 所示。
图 3-34。
Navigator
双击列表中的成员，跳转到源代码编辑器中的源代码。或者，不使用鼠标，按 Ctrl+7 将焦点放在导航窗口上。然后开始输入标识符，直到导航器找到它，并按 Enter 键在源代码编辑器中选择该标识符。
您可以使用导航器底部的过滤器按钮来隐藏非公共成员、静态成员、字段和/或继承成员。
移动插入点并滚动窗口
有很多种键盘快捷键可以用来在编辑器周围快速移动插入点，即光标，而不是简单地按左右箭头键左右移动一个字符或上下箭头键上下移动一个字符，如表 3-2 所示。
表 3-2。
Cursor Movement Shortcuts
| 捷径 | 描述 | | --- | --- | | Ctrl+右(Ctrl+左) | 将插入点移动到下一个单词(上一个单词)。 | | Ctrl+Home (Ctrl+End) | 将插入点移动到文件的顶部(底部)。 | | 主页(结束) | 将插入点移动到语句的开头(结尾)。 | | Ctrl+向上(Ctrl+向下) | 向上(向下)滚动，不移动插入点。 | | Alt+Shift+Home/End/Insert | 滚动窗口，使当前行移动到窗口的顶部、底部或中部，而不移动插入点。 | | Ctrl+ | 将插入点移动到与插入点前面的括号、中括号或大括号相匹配的位置。 |自定义代码折叠
您可以在文件中设定书签，以便于找到您经常使用的项目区域。然后，您可以通过按 Ctrl+Shift+句点(下一个书签)或 Ctrl+Shift+逗号(上一个书签)来循环浏览所有书签。
若要为文件中的某一行添加书签，请单击该行并按 Ctrl+Shift+M。若要删除书签，也可以使用 Ctrl+Shift+M。
您可以通过选择窗口➤ IDE 工具➤书签来打开书签窗口。或者，通过 Ctrl+Shift+句点和 Ctrl+Shift+逗号在书签中循环时，选择弹出菜单中的最后一项。书签窗口显示所有应用中的所有书签，使您能够创建一个简单的路径来浏览您正在使用的应用的相关部分，如图 [3-35 所示。
图 3-35。
Bookmarks window
隐藏代码段
您可以折叠(或“折叠”)代码底层细节，以便在源代码编辑器中只能看到代码块中的一行，从而留出更多空间来查看其他行。方法、内部类、import块和 Javadoc 注释都是可折叠的。
可折叠的代码块在代码块第一行旁边的左边界标有减号图标。块的其余部分用从图标向下延伸的垂直线标记。折叠的块标有加号图标。您可以点击其中一个图标来折叠或展开它所代表的特定块，如图 3-36 所示。
图 3-36。
Hiding sections of code
还可以使用键盘快捷键和源代码编辑器中的“查看➤代码折叠”菜单和“代码折叠”子菜单中的菜单项折叠和展开单个或多个代码块。表 3-3 列出了相关的命令和快捷键。
表 3-3。
Code Folding Shortcuts
| 捷径 | 描述 | | --- | --- | | ctrl+numpad-减号 | 折叠褶皱 | | ctrl+numpad 组合键 | 展开折叠 | | ctrl+Shift+数字小键盘-减号 | 全部折叠 | | ctrl+shift+numpad 组合键 | 全部展开 |用书签标记代码行
默认情况下，您编写的任何代码都不会被折叠。您可以将源代码编辑器配置为在创建文件或打开以前未打开的文件时默认折叠 Java 代码。
要将 IDE 配置为自动折叠 Java 代码的某些元素，请从“选项”菜单中选择“工具”。选项窗口打开。在选项窗口中，点击编辑器，选择折叠，如图 3-37 所示。在“折叠”选项卡中，选择默认情况下要折叠的元素的复选框。您可以从类成员中进行选择，如方法、内部类、imports、Javadoc 注释和初始注释。
图 3-37。
Changing folding settings
从源代码编辑器导航
IDE 包括在文件、不同代码和不同窗口之间导航的快捷方式。你在工作流程中使用的快捷键越多，你的手指就越少会离开键盘去使用鼠标。
在打开的文件之间切换
除了使用源代码编辑器的选项卡和下拉列表，您还可以使用键盘快捷键在打开的文件之间切换。
-
Ctrl+Tab. Opens a popup showing all open files, as shown in Figure 3-38. Hold down the Ctrl key and press the Tab key multiple times until the file that you want to view is selected. Then release both keys to close the box and display the file.
图 3-38。
Popup switcher
-
Shift+F4. Opens a dialog box that lists all open files, as shown in Figure 3-39. You can use the mouse or the arrow keys to select the file that you want to view and press Enter to close the dialog box and display the file.
图 3-39。
Document switcher
跳转到相关代码和文档
下面列表中的快捷方式使您能够跳转到当前文件的某些部分或与所选标识符相关的其他文件。这些快捷方式中的前六个可以从源代码编辑器的上下文(右键单击)菜单的导航菜单和转到子菜单中找到。Show Javadoc 命令可以直接从源代码编辑器的上下文菜单中获得。
- Alt+O(或 Ctrl 单击)。如果源代码可用，跳转到当前选定的类、方法或字段的源代码。要实现这一点，可以在选定标识符的情况下按 Alt+O，或者按住 Ctrl 键，将鼠标悬停在标识符上，直到它带有蓝色下划线，然后单击它。
- 跳转到当前选定的类、方法或字段的声明。
- Ctrl+B. Go to Super Implementation 跳转到当前所选方法的超级实现(如果所选方法重写了另一个类中的方法或者是接口中定义的方法的实现)。
- 跳转到当前文件中的特定行号。
- “转到类”使您能够键入类名，然后跳转到该类的源代码(如果 IDE 有该源代码)。
- 跳转到所选类的单元测试。
- Alt+F1。Show Javadoc 在 web 浏览器中显示选定类的文档。要使此命令生效，必须通过 Java 平台管理器(对于 JDK 文档)或库管理器(对于其他库的文档)使类的 Javadoc 对 IDE 可用。
在你工作的区域之间跳跃
当您一次处理多个文件或在同一个文件的不同区域工作时，您可以使用编辑器工具栏中的跳转列表按钮，如图 3-40 所示，直接导航到您一直工作的区域，而不是滚动和/或切换窗口。
图 3-40。
Jump List buttons
跳转列表本质上是你在源代码编辑器中完成的代码行的历史，如图 3-41 所示。
图 3-41。
Expanded Jump List
从源代码编辑器跳转到文件的节点
当您在源代码编辑器中键入时，可以跳转到其他窗口中表示当前文件的节点。例如，如果您想要快速导航到同一包中的另一个文件，或者想要浏览当前文件的版本信息，这可能会很有用。
- Ctrl+Shift+1。在“项目”窗口中选择当前文件的节点。
- Ctrl+Shift+2。在“文件”窗口中选择当前文件的节点。
- Ctrl+Shift+3。在“收藏夹”窗口中选择当前文件的节点。
搜索和替换
有不同类型的搜索可用于不同类型的需求。根据您要执行的活动类型，您可以使用搜索/替换工具的不同方面，这里将对每个方面进行描述。
- 查找用法命令。在项目中查找类、方法或字段的标识符的匹配项。
- 重命名命令。在整个项目中重命名类、方法或字段。
- 文件中的 Ctrl+F。在打开的文件中查找并替换特定的字符组合。
- 在项目上按 Ctrl+F。根据文件中的字符、文件名中的字符、文件类型和/或日期查找符合搜索条件的文件。
寻找用法
当您在源代码编辑器中工作时，您可以通过使用 Find Usages 命令快速找到当前所选类、方法或字段名的给定 Java 标识符在项目中的使用位置，该命令会显示 Find Usages 窗口，如图 3-42 所示。
图 3-42。
Find Usages window
要显示“查找使用实例”窗口以查找代码中出现的特定标识符，请在源代码编辑器中启动。然后将插入点/光标移动到要查找其出现的类、方法或字段名。然后按 Alt+F7。或者，您可以在编辑器中单击鼠标右键，然后选择“查找用法”。另一种开始查找使用实例的方法是，在“编辑”菜单中，选择“查找使用实例”。在“查找使用实例”窗口中，指定诸如是否应在注释中执行搜索之类的设置，然后单击“查找”。
Find Usages 对文本编辑器中的 Find 命令进行了改进，它对 Java 语言上下文中文本的相关性很敏感。
根据您选择的标识符种类以及您在“查找使用实例”窗口中选择的选项，“使用实例”窗口会出现在 IDE 的底部并显示您的结果，如图 3-43 所示。
图 3-43。
Usages results
“使用实例”窗口显示包含以下项目组合的语句，具体取决于标识符:
- 类和接口。类或接口的方法或变量的声明，类型的用法，例如在创建新实例、导入类、扩展类、实现接口、转换类型或引发异常时，类型的方法或字段的用法，以及子类型。
- 方法。方法和任何重写方法的调用。
- 字段。获取或设置字段的值。
- 评论。引用标识符的任何注释。
通过双击“使用实例”窗口中的“出现次数”行，可以导航到类、方法或字段名称的给定出现次数。
重新命名
如果你想重命名一个类、方法或字段，你可以使用重构➤重命名命令，将项目中所有出现的标识符更新为新名称，如图 3-44 所示。
图 3-44。
Rename window
与标准的搜索和替换操作不同，Rename 命令对代码的 Java 上下文敏感，这使得它更容易使用，也更可靠。此外，使用 Rename 命令，您可以预览将要进行的更改，使您能够取消选择项目以防止特定事件的重命名，如图 3-45 所示。
图 3-45。
Refactoring preview
要重命名类、方法或字段名称，请在源代码编辑器中启动。将插入点移动到代码中要重命名的类、方法或字段名处。按 Ctrl+R 或右键单击，然后在“重构”菜单中选择“重命名”。在“重命名”对话框中，键入元素的新名称。如果您想更改注释中出现的名称，请选中“在注释中应用名称”复选框。在重命名窗口中，单击下一步。如果您取消选择了“预览所有更改”复选框，更改会立即应用。如果保持选中“预览所有更改”复选框，将出现“重构”窗口，并预览更改。
在出现在 IDE 底部的“重构”窗口中，验证设置为要更改的事件。如果您不想更改某个事件，请取消选择该行的复选框。单击执行重构以应用更改。如果您后来发现重构产生了一些您想要逆转的后果，您可以按 Ctrl+Z 或从“编辑”菜单中选择“撤消”。
通过在“项目”窗口中内联重命名，可以启动重命名类或接口的过程。通过在要重命名的节点上键入 Ctrl+R，可以做到这一点。
发现
如果您想快速找到文件中的字符组合，请在您想要搜索的文件中单击，选择编辑➤查找(Ctrl+F)，并在查找窗口中键入您想要查找的文本，该窗口集成在编辑器的底部，如图 3-46 所示。
图 3-46。
Integrated Find window
使用“查找”对话框的一些提示:
- 在“查找”对话框中，通过按 Alt+G 或单击“正则表达式”按钮，可以使用正则表达式作为搜索条件。
- 与“查找用法”命令不同，“查找”命令允许您搜索部分单词，进行区分大小写的搜索(按 Alt+C 或单击“区分大小写”按钮)，并突出显示当前文件中的匹配项(按 Alt+H 或单击“突出显示匹配项”按钮)。
- 您可以通过按 F3(下一个匹配项)和 Shift+F3(上一个匹配项)在搜索字符串的匹配项之间跳转。
- 若要选择光标所在的单词并开始搜索该单词的其他匹配项，请按 Ctrl+F3。
取代
找到你要找的东西通常只是一项任务的开始。通常情况下，您需要替换已经找到的代码。本节将帮助您完成这项任务。
要搜索和替换文本，单击适当的文件，按 Ctrl+H，并填写查找内容和替换为字段，如图 3-47 所示。
图 3-47。
Integrated Replace window
其他文件搜索
如果您想在多个文件中搜索某个特定 Java 标识符以外的内容，您可以使用查找和在项目中查找命令，如图 3-48 所示。
图 3-48。
Find in Projects window
这些命令使您能够在文件夹、项目或所有项目中搜索文件。
这些命令可以基于以下标准类型的任意组合:
- 匹配文件中文本的子字符串或正则表达式
- 匹配文件名上的子字符串或正则表达式
- 文件的修改日期
- 文件类型
要启动这样的文件搜索，请在“编辑”菜单中选择“在项目中查找”,以搜索所有打开的项目中的所有文件。或者，在“项目”窗口中，右键单击要搜索的文件夹或项目的节点，然后选择“查找”(或按 Ctrl+F)。还有一种方法是在“文件”窗口中右键单击文件夹，然后选择“查找”(或按 Ctrl+F)。
启动搜索后，根据需要填写任意数量的搜索标准。在“查找”或“在项目中查找”窗口中输入条件并单击“搜索”后，搜索结果将显示在“搜索结果”窗口中，并显示每个匹配文件的节点。对于全文搜索，可以展开这些节点以显示匹配文本出现的单独行。您可以双击匹配项，在源代码编辑器中打开该文件(如果是全文匹配项，则跳转到匹配项所在的行)。
按 Ctrl+F 或选择“编辑➤查找”(或“在项目中编辑➤查找”)时出现的对话框取决于哪个 IDE 窗口具有焦点。如果选择了源代码编辑器，则会出现集成在单个文件底部的“查找”对话框。如果在“项目”窗口(或其他树视图窗口之一)中选择了一个节点，则会打开用于在多个文件中搜索的对话框。
跟踪笔记
IDE 有一个“操作项”窗口，为您提供了一种在代码中编写注释，然后在一个集中的位置查看所有这些注释的方法。为了给自己写一个笔记，也称为“行动项目”，你可以在代码的任何地方使用像XXX或TODO这样的模式。
当清理代码中的松散部分时，你可以使用 action items 窗口作为操作的中心，如图 3-49 所示，它为你列出了所有的 Action Items。
图 3-49。
Action Items window
如果某行“标记有”(包含)以下任何文本，则该行将显示在任务列表中。
当您在代码中键入这些标记之一时，它必须作为一个完整的单词键入，以便 IDE 能够识别它。例如，如果您没有在标签和注释之间添加空格，注释将不会出现在“操作项”窗口中。
要查看“操作项”窗口，请选择“窗口”“➤操作项”(或按 Ctrl+6)。
显示“操作项”窗口后，您可以通过单击“操作项”窗口左侧的相应按钮来查看当前文件、所有打开的文件或特定文件夹的任务。
通过单击相应的列标题，可以按任务、位置或优先级对任务列表项进行排序。有关显示“优先级”列的信息，请参阅本章后面的“按优先级显示任务”。
双击任务列表中的条目，可以直接跳到代码中编写注释的那一行。
添加、删除和更改行动项目标签
要更改用于“操作项”窗口的标签，请从“选项”菜单中选择“工具”。选项窗口打开。点击团队，选择行动项目，如图 3-50 所示。在“措施项”标签中，使用“添加”、“编辑”和“删除”按钮来修改措施项列表的内容。
图 3-50。
Customizing action items
过滤行动项目
您可以通过创建和使用过滤器来进一步限制“措施项”窗口中显示的条目。使用过滤器时，只显示符合过滤器指定条件的条目。标准包括需要出现在注释中的文本、任务的优先级和/或文件名。
要创建过滤器，在行动项窗口左侧的过滤器下拉菜单中点击编辑，如图 3-51 所示。在“编辑过滤器”对话框中，单击“新建”按钮，然后在“名称”字段中键入过滤器的名称。详细填写。或者，在“关键字”选项卡中添加附加条件，然后填写过滤器的详细信息。您可以使用对话框顶部的单选按钮选择让过滤器匹配所有或任何标准。
图 3-51。
Action Items Filter window
新定义的过滤器条目会出现在待办事项窗口工具栏中“操作项”窗口左侧的过滤器下拉列表中。
四、使用向导和插件
Download, double-click and start encoding. I use NetBeans to encode, debug and analyze Java EE, Java SE, JavaFX, HTML5 and JavaScript ... out of the box. NetBeans saved me and my airhacks.com students a lot of time. Adam Bean, an independent developer and pilot in airhacks.com
在这一章中，我将对 ide 中的工作流以及它为您提供的关键 Java 技术提供的工具进行概述。IDE 中包含许多向导，帮助您为每种 Java 技术——Java SE、Java EE、Embedded 和 Cloud——设置项目。本章的结构基于 Oracle.com 上的 Java 技术大纲，如以下 URL 所述:
https://www.oracle.com/java/technologies/index.html
当与 NetBeans 社区提供的许多插件结合使用时，本章中描述的向导将为您提供创建任何类型的 Java 应用所需的一切。由于这个原因，你将被介绍到插件管理器中最有用的插件，以及最有用的向导。
完成本章后，您应该对 IDE 的应用结构原理有了深入的了解，并且能够通过使用 IDE 的向导及其相关插件，在 IDE 中快速有效地设置您的开发工作。
概观
您可能会对如何开始开发您感兴趣的 Java 应用的快速概述感兴趣，而不是费力地阅读本章的其余部分。表 4-1 概述了每种 Java 技术在 NetBeans 中的入口点。
表 4-1。
Getting Started with Java Technologies in the IDE
| 技术 | 描述 | 入门指南 | | --- | --- | --- | | Java SE | Java platform，Standard Edition (Java SE)使您能够为尽可能多的计算平台开发安全、可移植、高性能的应用。Java SE 应用运行在计算机桌面上，而不是浏览器或移动设备上。如今，这些应用有时被称为“内部”应用。 | 在 IDE 中，打开“新建项目”向导(Ctrl+Shift+N)。当您开始学习 Java 时，您可能希望使用简单的基于 ant 的 Java SE 项目模板，该模板可以在 Java ➤ Java 应用的新建项目向导中找到。当您更加熟悉 Java 并且对使用广泛使用的 Maven 构建系统感兴趣时，请在新建项目向导中转到 Maven ➤ Java 应用，开始创建您的 Java SE 应用。 | | 容器 | Java 平台企业版(Java EE)是企业 Java 计算的行业标准。Java EE 使开发人员能够编写更少的样板代码，更好地支持最新的 web 应用和框架，并获得增强的可伸缩性和更丰富的功能。 | 在 IDE 中，打开“新建项目”向导(Ctrl+Shift+N)。当您开始学习 Java 时，您可能希望使用简单的基于 ant 的 Java EE 项目模板，该模板可以在 Java Web ➤ Web 应用的新建项目向导中找到。当您更加熟悉 Java EE 并且对使用广泛使用的 Maven 构建系统感兴趣时，请在新建项目向导中转到 Maven ➤ Web 应用，开始创建您的 Java EE 应用。 | | 植入的 | Java 嵌入式产品的设计和优化旨在满足嵌入式设备的独特要求，如微控制器、传感器(如 Raspberry Pi)和网关。它们支持 M2M 通信和“物联网”的智能系统，因此您可以使用您的设备做更多事情。 | 在 IDE 中，转到工具➤ Java 平台。单击添加平台并选择远程 Java 标准版。单击“下一步”,您将能够连接到嵌入式设备上安装的 JDK。一旦注册了嵌入式 JDK，您就可以将您的 Java 应用部署到其中，方法是在您想要部署到嵌入式设备的项目的“项目属性”窗口中设置嵌入式 JDK。 | | 云 | Java 云服务提供了在云中开发和部署业务应用的企业级平台。它们使您能够通过即时访问支持任何标准 Java EE 应用的云环境，以及集成的安全性和数据库访问，最大限度地提高工作效率。 | 在 IDE 中，转到服务窗口(Ctrl+5)并查看云节点，在这里可以管理部署到 Java 云服务的应用。Amazon Beanstalk 支持开箱即用。插件可用于 Oracle Cloud、Oracle Developer Cloud Service、Red Hat OpenShift 和 Jelastic。 |对于喜欢冒险的读者来说，表 4-1 应该足以让你开始使用这些技术。对于那些想了解更多细节的读者，以及那些遇到问题的爱冒险的读者，本章的剩余部分将详细探讨每一种 Java 技术以及 IDE 为支持它们而提供的工具。
一般
在本节中，将向您介绍 IDE 工具结构和 IDE 中各种 Java 项目的应用结构的一般原理。IDE 坚持认为应用结构应该如何在 IDE 中可视化。通常，一旦您理解了 IDE 处理应用的角度，您就会对 IDE 采用的方法非常满意。
例如，您将了解到 IDE 只在“项目”窗口中显示您最可能使用的工件，而“文件”窗口也包含生成的代码。如果不了解这些考虑因素，您会经常问自己这样的问题，“我的构建文件夹在哪里？”以及“我刚刚构建的应用的 JAR 在哪里？”
一旦您研究了 IDE 遵循的一般应用结构原则，您将更详细地了解每种 Java 技术以及 IDE 为它们提供的工具。
应用结构
当您在 IDE 中创建新项目时，它将在“项目”窗口中打开(Ctrl+1)。“项目”窗口显示了应用的逻辑结构。逻辑结构由您可能想要直接使用的文件夹和文件组成，并且不会因自动化过程(如构建过程)而改变。
当您在一个项目上执行一个自动化过程时，可能会创建各种各样的工件，比如构建过程或者 JUnit 测试过程。这些工件不会显示在“项目”窗口中。如果您正在寻找以某种方式生成或自动创建的工件，请打开文件窗口(Ctrl+2)。文件窗口有一个 dist 文件夹，其中包含以某种方式为您创建的归档文件，如 JAR、WAR 和 EAR。在基于 Ant 的项目中,“文件”窗口在构建过程完成后显示一个构建文件夹，而基于 Maven 的项目在构建过程完成后在“文件”窗口中显示一个目标文件夹。
图 4-1 展示了基于 Ant 的项目 AsyncRequest 和基于 Maven 的项目 CDI Sample Application for Bean Validation 的要点。这两个项目都可以在 New Project 向导的 Samples 类别中找到。
图 4-1。
Projects and Files windows
项目组
NetBeans 项目是一组源文件以及用于构建、运行和调试这些源文件的设置。在 IDE 中，所有开发都必须在一个项目中进行。对于涉及大型代码库的应用，将应用源代码分成几个项目通常是有利的。
您可以创建项目分组，以便一次打开和关闭几个项目。此外，每个组可以有不同的主项目。创建项目组后，该项目组在“项目组”菜单中可用。当您从该菜单中选择一个项目组时，该项目组之外所有打开的项目都将关闭。如果要关闭所有打开的项目，请选择文件➤项目组➤(无)。
查看 Java 包
默认情况下，如图 4-2 中最左边的图像所示，每个包在应用结构中显示为一个单独的节点。
图 4-2。
Java packages as list, tree, and reduced tree
但是，IDE 中有一个隐藏的功能，使您能够更改包的显示方式。包可以显示为列表(左图)、树(中图)或简化的树(右图)。通过右键单击“项目”窗口中的空白区域，并选择“查看 Java 包为”子菜单，为包选择不同的视图布局，可以在包布局之间切换。你不用再做什么了；封装布局会立即自我更新。
全面的服务集成
每当你想知道用于连接数据库、服务器或云服务的工具在哪里时，你应该首先查看服务窗口(Ctrl+5)，如图 4-3 所示。
图 4-3。
Services window
“服务”窗口很有用，因为它为您提供了访问任何可以想象的外部资源的单一访问点。“服务”窗口中包括数据库、web 服务、服务器、Maven 存储库、Hudson 连续构建服务器和问题跟踪器的访问点。
这些服务提供了一个统一的、标准化的机制来使用它们。在每种情况下，右键单击服务来初始化、注册或启动服务的实例。例如，右键单击 Servers 节点以注册本地安装的 GlassFish 服务器，这样您就可以从服务窗口管理它，而不是从命令提示符或管理控制台(通常在浏览器外部运行)管理它。
插件管理器
IDE 的独特之处在于，原则上，基本的 Java 开发不需要任何额外的插件。然而，由于 IDE 相对容易扩展，并且已经存在了十多年，世界上许多人已经为它创建了插件。
使用插件管理器(如图 4-4 所示，可在工具菜单下访问)从注册的更新中心动态更新 IDE，并管理 IDE 插件。使用插件管理器的“可用插件”选项卡查看和安装可从已注册的更新中心获得的新插件。
图 4-4。
Plugin Manager
在学习本章的过程中，有时会建议您使用插件管理器将附加功能安装到 IDE 中。
虽然插件管理器中有许多插件，但是那些列在表 4-2 中的插件是你可能想要考虑马上安装的。这些插件在它们的功能集方面是雄心勃勃的，它们与流行的或“酷”的外部技术相集成，并且它们与插件当前可用的功能子集相关联。
表 4-2。
Plugins to Consider Installing Right Away
| 种类 | 描述 | | --- | --- | | DukeScript 项目向导 | 使用此向导可以通过 NetBeans 创建新的 DukeScript 项目。该向导基于 Maven，负责项目的正确而简单的配置。使用 DukeScript 和这个向导来开发运行在 iOS、Android、桌面、浏览器甚至 NetBeans 插件上的应用。 | | 轻松文本 | 使用 PMD 执行代码分析，并在编辑器和“操作项”窗口中显示结果。 | | easyurl | 提供 UML 绘图功能、代码生成和从 Java 代码创建 UML 类图。它是由贝尔格莱德大学组织科学学院开源软件开发中心开发的。 | | Eclipse Java 代码格式化程序 | 帮助您在 Eclipse JDT 和 NetBeans IDE 用户团队中遵循通用的代码风格。Eclipse 的原始格式化引擎是嵌入式的，它允许您像 Eclipse 同事一样格式化源代码。您只需要提供一个 Eclipse 格式化程序配置文件。 | | gluon 外挂程式 | 允许开发人员使用相同的代码库创建面向 Android 和 iOS 移动平台以及桌面平台的 JavaFX 应用。 | | 梯度支持 | 允许在 NetBeans 中将包含 build.gradle 文件的目录作为项目打开。然后，打开的项目可以作为普通的 Java 项目使用。 | | jBatch 套件 | 允许开发人员使用 Java Batch 1.0 规范设计 Java 批处理应用模型并自动生成 Java 代码。批处理的典型特征是面向批量、非交互、后台执行。它经常长时间运行，可能是数据密集型或计算密集型的，按顺序或并行执行，并且可能通过各种调用模型启动，包括临时的、预定的和按需的。 | | JBoss 锻造厂 | 允许开发人员快速开始使用各种基于 Maven 的 Java EE 应用。 | | 缩进 | 一个强大的 Java 和 C/C++源代码格式化程序。Jindent 使您能够转换任何外来的 Java/C/C++源代码，以满足您偏好的编码风格或任何常见的 Java 代码约定。 | | 测试工具 | 提供 Apache JMeter (2.4)到 NB 基础设施的紧密集成。此插件将安装其他插件，包括负载生成器和分析器/负载生成器桥。 | | JPA 建模器 | 帮助软件开发人员以图形化图表的形式创建、设计和编辑 Java 持久性应用业务模型。它使用 JPA 类图中的 JPA 2.0 自动生成 Java 代码。 | | 杰贝尔 | 一个生产力工具，允许您查看对代码所做的更改，而无需重新部署。它将您的项目工作区直接映射到一个正在运行的应用，这样对类和资源的更改就会立即反映在应用中。它跳过了构建和重新部署阶段。IDE 插件捆绑了 JRebel 代理，自动化服务器和项目配置，并提供调试器支持。 | | 莫奈 | 这使得 JavaFX 快速 GUI 设计的工作流程与目前通过 Matisse GUI 生成器为 Swing 提供的工作流程相同。提供 FXML 文件的设计视图。这个插件使用 JavaFX 场景生成器提供了一个新的多视图。 | | 我坚持 | 提供开发 Vaadin 项目的帮助，包括项目生成向导、用于更新 Vaadin 版本的首选项页面、设置小部件集编译参数，以及为常用命令提供帮助方法。 |除了插件管理器中提供的插件之外，在 NetBeans 插件门户网站上还有更多插件( http://plugins.netbeans.org )。插件管理器中的插件是由 NetBeans 团队提供的，以及由 NetBeans 社区创建和验证的。插件门户中的插件是由 NetBeans 社区提供的。如果它们没有经过验证，也就是说，没有经过 NetBeans 社区的试用和批准，它们将不会出现在插件管理器中。在假设 IDE 不支持某项技术之前，请确保检查插件管理器和插件门户。通常，NetBeans 社区中的某些人会创建一个 NetBeans 插件来支持您最喜欢的技术。
Java SE
Java platform，Standard Edition (Java SE)使您能够为尽可能多的计算平台开发安全、可移植、高性能的应用。通过使应用在异构环境中可用，企业可以提高最终用户的工作效率、加强沟通和协作，并大幅降低企业和消费者应用的拥有成本。
Java SE 应用运行在计算机桌面上，而不是浏览器或移动设备上。这些应用有时被称为“内部”应用。本书第二章提供了创建 Java SE 应用的完整的端到端描述。所有这些类型的应用的起点是去文件➤新项目(Ctrl+Shift+N)，这将打开新项目向导。选择 Java 类别，如图 4-5 所示。
图 4-5。
Getting started with Java SE projects
正如您在图 4-4 中看到的，在 IDE 中为开始创建和使用 Java SE 应用提供了不同的入口点。通常，您将使用 Java 应用项目模板在 IDE 中开始工作。尤其是当您第一次学习 Java 语言时，这是您可能从事的工作的理想切入点。
还提供了三个更专业的项目模板。Java 类库项目模板将创建一个没有主类的新 Java 应用。这个想法是，您将使用这个模板提供的项目结构来创建 Java 库，也就是说，为 Java 应用提供一部分通用功能的 Java 代码包。如果要从磁盘上包含 Java 源文件的一组文件夹中创建 NetBeans 项目，而没有 build.xml 文件，请使用 Java 项目和现有源代码项目模板。Ant 驱动这些应用，IDE 将为您设置 Ant 构建脚本。通常，这样的 Ant 构建脚本已经存在，在这种情况下，您将使用 Java 自由格式项目模板，该模板允许您将 Ant build.xml 文件与 Java 源代码一起导入。如果您使用 Maven 而不是 Ant 作为您的构建系统，请在 New Project 向导中使用 Maven 类别而不是 Java 类别。如果您的 Maven 项目已经存在于磁盘上，只需通过文件➤打开项目打开它，因为 IDE 会自动知道如何解释您的 POM 文件。要为 Java SE 应用创建新的 Maven 项目，请在新建项目向导中选择 Maven ➤ Java 应用或 Maven ➤ JavaFX 应用。
一旦应用被设置好，您将希望在其中创建新文件，通常是新的 Java 源文件。为此，转到文件➤新建文件(Ctrl+N)，如图 4-6 所示。特别是，Java、JavaFX、Swing GUI 表单、JavaBeans 对象和 AWT GUI 表单类别与 Java SE 开发直接相关。
图 4-6。
Getting started with files in Java projects
根据您创建的文件类型，IDE 提供了各种支持功能。在本书的第三章中，详细描述了 Java 编辑器。此外，IDE 还为 Java Swing 组件的布局和设计提供了 Matisse GUI 构建器，并与 JavaFX 场景构建器集成，用于 JavaFX 组件的布局和设计。关于这些 GUI 设计者的详细信息可以在 NetBeans.org 的 Java GUI 应用学习资源中找到，网址如下: https://netbeans.org/kb/trails/matisse.html .
请注意，您可以在“项目属性”窗口中配置您使用的每个项目。右键单击一个项目，然后选择“属性”。项目属性窗口打开，如图 4-7 所示。可以为您处理的每个项目定义一系列配置，从类路径上的 JAR 文件到编译设置和运行时命令。例如，当您使用基于 Maven 的应用时，您可以将 POM 文件中的命令映射到项目命令，以便当您按下运行项目的 F6 时，您可以执行您在 POM 中定义的目标。IDE 中相当多的功能都可以配置，所有这些功能都位于 IDE 在“项目属性”窗口中提供的统一位置。
图 4-7。
Properties of Maven-based Java EE projects
随着您对 IDE 越来越熟悉，您可能会越来越希望使用键盘快捷键，而不是菜单项和工具栏按钮。将鼠标悬停在工具栏按钮上可以查看它们相关的键盘快捷键，例如 F6 表示运行，F11 表示构建。在“选项”窗口的“键盘映射”部分，您可以调整和微调所有与处理项目相关的键盘快捷键。有关键盘快捷键的列表，请转到“帮助”|“键盘快捷键卡片”。
容器
Java 平台企业版(Java EE)是企业 Java 计算的行业标准。Java EE 平台提供了增强 HTML5 支持、提高开发人员工作效率和进一步改善企业需求满足方式的新特性，使开发人员能够编写更少的样板代码，更好地支持最新的 web 应用和框架，并获得增强的可伸缩性和更丰富的功能。
Java EE 平台包含一系列规范，涉及从数据库访问、业务逻辑封装、安全性到前端开发的方方面面。请访问以下网址了解全部详情和完整的端到端教程: http://docs.oracle.com/javaee/7/tutorial 。下一章将提供一个简单的端到端场景，使用 Maven 和 Java Server Faces (JSF ),以及 RESTful Web 服务和 JavaScript。
要开始创建 Java EE 应用，请转到文件➤新项目(Ctrl+Shift+N)。新建项目向导打开，如图 4-8 所示。如果您不熟悉 Maven，并且主要关注于学习 Java EE 平台，那么您的切入点可能是新建项目向导中的 Java Web ➤ Web 应用。然而，如果你想使用 Maven，并且你还没有一个基于 Maven 的项目，从 Maven ➤ Web 应用开始，如图 4-8 所示。
图 4-8。
Getting started with Java EE projects
如果您已经在磁盘上有一个基于 Maven 的应用，即一个包含 POM 文件的应用，只需转到文件➤打开项目。IDE 自动理解 POM 文件，并以逻辑方式在 IDE 中布局应用。POM 还以多种方式得到支持。双击打开 POM，注意 IDE 显示了有效的 POM、POM 的源，以及显示 POM 中注册的 jar 之间的依赖关系的图形视图。
接下来，您可能希望在设置完项目后立即创建新文件。为此，在 IDE 中转至文件➤新文件，特别是浏览持久性和 Web 服务类别，如图 4-9 所示。
图 4-9。
Getting started with files in Java EE projects
您将很快发现，除了帮助您创建简单的 Java 源文件之外，IDE 还提供了高级代码生成器。从一个数据库或一个或多个符合 JPA 规范的实体类开始，IDE 可以为您生成许多工件。代码生成器，如图 4-9 所示，之所以成为可能，是因为工件基于 Java EE 平台的规范。规范使工具提供者，比如 IDE，能够提前知道文件的结构和内容以及其他需要创建的工件。例如，如果你想通过基于 JAX-RS 规范的 RESTful Web 服务来公开数据库中的数据，你只需要通过 RESTful Web 服务从数据库向导，如图 4-9 所示。探索其他代码生成器，阅读描述，并注意它们如何与 Java EE 平台提供的规范直接相关。
植入的
当您想要更多——更多选择、更多保护和更多嵌入式应用功能时，Java 是最佳选择。Oracle Java 嵌入式产品经过专门设计和优化，能够满足微控制器、传感器和网关等嵌入式设备的独特要求。它们支持智能系统用于 M2M 通信和“物联网”，因此您可以利用您的设备做更多事情。
当使用 Java 嵌入式产品时，您通常会希望在嵌入式设备上安装 JDK 8 for ARM，比如在 Raspberry Pi 上。面向 ARM 的 JDK 8 包括面向 ARM 平台的 Java 运行时环境(JRE)和工具，如开发应用所需的编译器和调试器。
一旦你设置和配置了你的嵌入式设备，比如 Raspberry Pi，这就是你在上面安装 JDK 8 for ARM 的方法:
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install oracle-java8-jdk
在设备上安装了 JDK 8 for ARM 之后，您通常需要 Putty、WinSCP、SSH 等命令行工具来从命令行连接您的开发环境，以便在设备上运行应用。然而，除了所有这些工具，您只需要 IDE。
在 IDE 中，转到主菜单中的工具➤ Java 平台。单击添加平台。选择远程 Java 标准版。单击下一步。出现 Add Java Platform 窗口，在这里您可以使用主机、端口和其他连接详细信息连接到您的设备，如图 4-10 所示。
图 4-10。
Registering a remote Java SE platform
现在，您已经在 IDE 中设置了一个远程 Java SE 平台，您可以创建一个标准的 Java SE 项目。在项目的“项目属性”窗口的“运行”选项卡中，指定项目使用远程 Java SE 平台。您将能够在设备上创建、编译、运行、调试和分析应用，就像它是一个本地应用一样。
云
Java 云服务提供了在云中开发和部署业务应用的企业级平台。它们使您能够通过即时访问支持任何标准 Java EE 应用的云环境，以及集成的安全性和数据库访问，最大限度地提高工作效率。
表 4-3 提供了 IDE 中可用的云服务提供商列表。
表 4-3。
Java Cloud Service Providers
| 公司 | 技术 | 入门指南 | | --- | --- | --- | | 神谕 | 甲骨文云和甲骨文开发者云服务 | 在 IDE 中，转到工具➤插件并搜索 Oracle 云。安装插件并在服务窗口中查看云节点以开始。 | | 红帽子 | openshift(打开 hift) | 在浏览器中，进入 plugins.netbeans.org，搜索 OpenShift。安装插件并在服务窗口中查看云节点以开始。 | | 弹性的 | 弹性的 | 在浏览器中，去 plugins.netbeans.org 搜索 Jelastic。安装插件并在服务窗口中查看云节点以开始。 | | 亚马孙 | 亚马逊豆茎 | 在 IDE 中，转至“服务”窗口。展开云节点并开始使用 Amazon Beanstalk 提供程序。 |一旦您设置了一个云服务提供商，您就可以指定将一个 Java EE 应用部署到它上面。与其他任何服务器一样，在项目的“项目属性”窗口中，您可以指定要使用的服务器。在这种情况下，服务器将是您已经注册的远程云服务提供商。
例如，如果您注册了 Oracle Cloud，您将在 Cloud 节点中看到一个新节点，如图 4-11 所示。此外，您将在 Servers 节点中看到一个新节点，当您将应用部署到 Oracle Cloud 时，您将能够在 Servers 节点中展开 Oracle Cloud 节点并管理部署的工件。
图 4-11。
Java EE applications deployed to the Oracle Cloud
某些云服务提供商为部署应用提供了不止一个远程位置。例如，Oracle Developer Cloud Service 通过支持完整开发生命周期的自动供应开发平台简化了开发。Oracle 开发人员云服务的重点是让您能够进行远程开发、部署和协作。插件管理器提供了一个插件，将 Oracle 开发人员云服务集成到 IDE 中，以便您可以远程使用 Oracle 开发人员云服务提供的服务，如 GitHub 和 Hudson。详情请访问以下网址: https://cloud.oracle.com/developer_service 。
五、将碎片拼在一起
NetBeans provides comprehensive and complete end-to-end support for Java EE platform. Happily develop, deploy, debug and analyze your Java EE application on multiple application servers! —— —Arun Gupta, Director of Technology Marketing and Developer Rights of Red Hat
在这一章中，你要做一些工作！前几章向您介绍了在 NetBeans IDE 中开始 Java 开发所需要了解的一切，而本章提供了一系列步骤，您可以通过这些步骤将各个部分组合在一起，用 IDE 创建一个真正的应用。
本章开始时，您需要设置一些工具和技术，比如服务器和数据库，您将需要这些工具和技术来为您将要创建的应用提供服务并提供其数据。随后，您将创建 JPA 实体类，它代表数据库中的表。JPA 实体类将从您的数据库中生成，换句话说，您将看到 IDE 中的工具帮助您避免将代码放在一起的复杂性。很多都是可以自动化的，事实上，只要可能，任何可以自动化的东西都是由 IDE 自动化的。一旦有了 JPA 实体类，您将学习如何将它们作为 RESTful Web 服务公开，以及如何在基于 JSF 的前端和 JavaScript 前端使用它们。
到本章结束时，你将具备创建任何类型的实际应用所需的所有技能和理解，特别是当你需要为需要部署到浏览器的应用这样做时。
安装
在本节中，您将学习如何连接到数据库并启动应用服务器。
从服务窗口(Ctrl+3)开始，在这里可以注册数据库服务器，连接到数据库，并根据需要修改数据。在这种情况下，对于您正在处理的场景，请连接到 Sample 数据库，这是一个 Derby 数据库，包含在 NetBeans IDE 的 Java EE 发行版中。在服务窗口中，展开数据库节点，右键单击jdbc:derby节点，然后单击连接。IDE 将连接到示例数据库。
图 5-1 显示了扩展了数据库节点的服务窗口。IDE 已经连接到示例数据库，因此它的表在 IDE 中是可见的。
图 5-1。
Sample database started from the IDE
接下来，让我们设置应用服务器。
再次在“服务”窗口(Ctrl+3)中，展开“服务”节点以查看可用的应用服务器。始终确保您将要使用的应用服务器支持您想要使用的技术和技术版本。在本章中，您将向 GlassFish 部署一个 Java EE 应用。在撰写本文时，GlassFish 的当前版本是 4.1，而 Java EE 的当前版本是 Java EE 7。GlassFish 4.1 支持 Java EE 7，因此，这种组合是 Java EE 应用的坚实基础。
GlassFish 与 IDE 捆绑在一起。因此，当您安装 IDE 时，应该已经安装了 GlassFish。
右键单击 GlassFish 节点，然后选择“启动”。输出窗口(Ctrl+4)显示了启动过程的输出。当服务器正在运行时，您应该会看到一个绿色箭头图标，并且应该能够展开节点并看到应用和资源子节点。当一个应用被部署到 GlassFish 时，您应该会看到一个新节点被添加到 Applications 节点中。这个新节点将已部署的应用可视化，并允许您在右键单击该节点并选择“取消部署”后取消部署它。
图 5-2 显示了服务器节点展开且 GlassFish 服务器正在运行的服务窗口。
图 5-2。
GlassFish application server started from the IDE
既然数据库和应用服务器已经可用并启动，那么让我们创建并部署 Java EE 后端。
创建 Java EE 服务器应用
Java EE 是一个社区驱动的基于规范的平台，它提供了在 Java 平台上创建企业应用的工具和技术，主要用于部署到浏览器。在本节中，您将创建一个 Java EE 应用，它利用了与通过 web 服务访问数据库和公开数据相关的 Java EE 规范。
让我们从设置一个新的 Java EE 应用开始。Java 应用事实上的标准构建系统是 Maven，它在 IDE 中得到方便的支持，您将在下面的步骤中看到这一点。
To get started creating the application, go the New Project window, which you can do via File ➤ New Project or by clicking Ctrl+Shift+N. In the New Project window, choose Maven ➤ Web Application, as shown in Figure 5-3.
图 5-3。
Getting started creating a Maven-based Java EE application When you click Next, the “Name and Location” step of the wizard, shown in Figure 5-4, enables you to fill in Maven-specific settings. Aside from the name of the project and its location, you’re prompted to specify the group ID, version, and optionally a package name, which will be treated as the main package of the application that will be created.
图 5-4。
Maven settings for Maven-based Java EE application Note
Maven 组 ID 是一个组织设置；通常你会把你的网站的 URL 反过来，这样如果你的网站是mycompany.com，组 ID，以及包设置，就会以com.mycompany开始。这将为应用的基本结构创建一个唯一的标识符或命名空间。
After clicking Next, select the application server to which the application will be deployed, as well as the Java EE version to which its artifacts and structure will comply; see Figure 5-5. Wizards and templates in the IDE will generate code conforming to the selected Java EE version. Here, choose GlassFish and Java EE.
图 5-5。
Server name and Java EE settings for Maven-based Java EE application
当您单击 Finish 时，应用结构及其初始内容被创建并显示在 IDE 的 Projects 窗口中，如图 5-6 所示。
图 5-6。
Newly created Maven-based Java EE application
花点时间探索 IDE 提供的与 Maven 相关的工具。例如，当您打开 POM ( pom.xml)文件时，您会注意到多个选项卡，包括一个图表视图。当您打开导航器(Ctrl+7)时，您会注意到一个 Maven 目标列表，它是在 POM 中定义的，您可以右键单击来执行它。当您转到项目的项目属性窗口中的 Action 选项卡时，您可以将 Maven 目标绑定到项目命令，例如 Build 和 Run，您可以通过键盘快捷键调用它们。
现在您已经创建了 Java EE 后端的结构和初始内容，您已经准备好从示例数据库生成 JPA 实体类，这是您在本章前面设置的。
生成 JPA 实体类
Java 持久性 API (JPA)规范专注于简化和标准化数据访问。通过定义应用和它需要访问的数据库之间的连接，这是通过诸如 Java 注释和称为“持久性单元”的一致 XML 文件之类的工具来实现的。IDE 通过允许您从数据库中的表生成 JPA 实体类，进一步简化了 JPA 规范，您将在本节中发现这一点。
在新建文件窗口中，可以通过文件➤新建文件或 Ctrl+N 访问，从数据库中选择持久化➤实体类，如图 5-7 所示。
图 5-7。
Generating JPA entity classes from a database
还要注意，新文件窗口中的持久性类别提供了许多其他文件生成器。例如，如果您想要将您的数据公开为 RESTful Web 服务，请在图 5-7 所示的窗口中选择 RESTful Web 服务 from Database，因为这将在一个进程中同时生成您的 JPA 实体类和 RESTful Web 服务。同时，将创建一个永久单元。注意，也可以通过持久性单元模板单独创建持久性单元，如图 5-7 所示。
点击下一步，选择一个数据源，在本场景中为jdbc/sample，数据源中的可用表会列在可用表列表中，如图 5-8 所示。
图 5-8。
Available tables in selected data source
请注意，表格列表与图 5-1 中所示的表格列表相匹配。换句话说，在 IDE 中设置数据库连接时可以访问的表可以在“从数据库新建实体类”向导的“数据库表”步骤中找到。
要选择要在应用中使用的表，请在可用表列表中选择它们，然后单击添加。这将把它们移动到数据库表窗口右侧的已选表列表中，如图 5-8 和 5-9 所示。
图 5-9。
Tables with foreign key relationships automatically included
在本场景中，选择CUSTOMER并点击添加。这将把CUSTOMER表移动到数据库表窗口的选定表列表中。
如图 5-9 所示，具有外键关系的表被自动选中。
当你点击下一步，你移动到实体类步骤，如图 5-10 所示。“新建实体类”步骤在顶部显示“类名”列表，向您显示所选的表，以及 IDE 自动生成 JPA 实体类以访问相关表中的数据时将使用的类名。
图 5-10。
Entity Classes step in New Entity Classes from Database wizard
此外，如果该类已经存在，如图 5-10 所示，生成列显示“更新”，而不是“新建”，通知您 IDE 将在“从数据库新建实体类”向导的末尾用新的 JPA 实体类覆盖现有的 JPA 实体类。
请注意，默认情况下会选中几个复选框，因此 IDE 会自动为持久性字段、JAXB 注释和持久性单元生成命名查询。
虽然你可以在这里点击完成，如图 5-10 所示，但是你也可以点击下一步来微调设置，使生成的代码完全符合你的要求，如图 5-11 所示。
图 5-11。
Fine-tuning the settings to define the code to be generated
当您单击“完成”时，会根据您在向导的前面步骤中提供的设置生成 JPA 实体类。
默认情况下，持久化单元也被创建，如图 5-12 所示。
图 5-12。
Generated JPA entity classes, with related dependencies and persistence unit
基于 Maven 的应用需要访问的所有依赖关系都在 POM 中注册，并在 dependencies 节点中可视化，如图 5-12 所示。
现在您已经有了 JPA 实体类，您可以使用 IDE 中的各种工具来访问您的数据库并对相关数据做一些事情。
向前端客户端公开数据
IDE 提供了支持多种技术的工具，在提供对 JPA 实体类中数据的访问时，您可以使用这些技术。
- 从实体类生成 JSF 页面。
- 从实体类生成 RESTful Web 服务。
- 从 RESTful Web 服务生成 RESTful JavaScript 客户端。
从实体类生成 JSF 页面
IDE 提供了在 JPA 实体类上创建 JSF 页面的工具。此外，JSF 页面可以使用流行的 PrimeFaces 组件库，对它的支持直接集成到了 IDE 中。
In the IDE, open the New File window (Ctrl+N) and choose Web ➤ JSF Pages from Entity Classes. Click Next, select the entity classes for which you would like to create JSF pages, and click Next again. Figure 5-13 is shown. Specify the templates you would like to use, which can be standard JSF pages or JSF pages that use the PrimeFaces component library.
图 5-13。
Generating PrimeFaces pages from entity classes
请注意，您可以自定义模板。例如，您可能希望更改它们，以便在 IDE 创建 JSF 页面时使用您的样式准则和公司徽标。如果要创建的文件已经存在，您可以通过覆盖现有文件复选框覆盖它们，如图 5-13 所示。
Click Next, configure JSF as needed, and click Finish.
现在，IDE 将使用您在“从实体类新建 JSF 页面”向导中定义的模板和其他设置来创建您的 JSF 页面。
从实体类生成 RESTful Web 服务
您可以通过 RESTful Web 服务公开数据，而不是自己创建前端。RESTful Web 服务(JAX-RS)是 Java EE 平台的一部分，就像 JPA 一样。任何客户机都可以访问通过 RESTful Web 服务公开的 XML 或 JSON 有效负载，解析有效负载，并根据需要进行处理。
例如，您可以通过解析 RESTful Web 服务提供的有效负载，为移动设备(如 iOS 或 Android)创建一个前端。通常，您将创建一个响应式设计，通过它，相同的代码库被用于为不同的设备创建不同的用户体验。所有这些活动的起点是创建 RESTful Web 服务，通过 JPA 实体类访问您的数据。
IDE 使得创建 RESTful Web 服务变得很简单。
In the IDE, open the New File window (Ctrl+N) and choose Persistence ➤ RESTful Web Services from Entity Classes. Click Next, select the entity classes for which you would like to create RESTful Web Services, and click Next again. Figure 5-14 is shown, enabling you to specify where the RESTful Web Services will be created.
图 5-14。
Generating RESTful Web Services from entity classes
当您单击 Finish 时，RESTful Web 服务将在指定的包中创建，同时还有一个ApplicationConfig类，它使用javax.ws.rs.ApplicationPath注释来指定应用的 URL 子根，后面是您使用向导生成的每个 RESTful Web 服务的路径。
从 RESTful Web 服务生成 RESTful JavaScript 客户端
另一种方法是创建一个 JavaScript 前端。尽管 JavaScript 不是本书的重点，但在 IDE 中创建的 JPA 实体类之上创建 JavaScript 前端是多么容易，这是值得一试的。
在开始创建您的 JavaScript 客户端之前，您需要有一个 HTML5 项目，也就是一个单独的新项目，它为 HTML5/JavaScript 应用提供支持。
In the IDE, choose File ➤ New Project (Ctrl+Shift+N) and then choose HTML5 ➤ HTML5 Application. For purposes of this scenario, click Next and then click Finish. You now have the basis of a new HTML5 application that has support for technologies such as HTML, JavaScript, and CSS. In the IDE, choose File ➤ New File (Ctrl+N), which brings up the New File window. In the New File window, choose HTML5 ➤ RESTful JavaScript Client and click Next. Figure 5-15 is shown, where you can browse to the RESTful Web Service for which you would like the IDE to create a JavaScript client. By default, the IDE will use the Backbone.js framework to design the JavaScript frontend, although plugins exist for generating an AngularJS or KnockoutJS frontend, instead.
图 5-15。
Generating a RESTful JavaScript client from RESTful Web Services Since you will be interacting with the backend from a different domain in your frontend, you will need a cross-origin resource sharing filter, which the IDE can create for you, as shown in Figure 5-16. This is done in the New File window, via Web Services ➤ Cross-Origin Resource Sharing Filter. Create this filter in your Java EE application, so that your JavaScript frontend will be able to access and use its payload.
图 5-16。
Creating a cross-origin resource-sharing filter
部署应用
现在您已经有了后端和前端，是时候看看您的应用在运行了！例如，当您部署 RESTful Web 服务时，在浏览器中查看有效负载可能会有所帮助，如图 5-17 所示。确保 URL 正确无误，如图所示。它由基本 URL、应用配置类和您想要公开的 web 服务的路径构成。
图 5-17。
Seeing the payload in the browser
通过访问这个 URL，任何客户端都可以解析有效负载，并构建一个允许用户访问和操作底层数据的用户界面。
您可能不想部署 RESTful Web 服务，而是希望通过您创建的前端公开您的数据。默认情况下，使用Backbone.js框架的 JavaScript 前端显示如图 5-18 所示。用户可以查看并更改数据。部署的应用提供完整的 CRUD 特性，也就是说，用户可以创建、读取、更新和删除底层数据。请注意，您不必为支持这一基本功能而向应用添加任何代码。
图 5-18。
Deployed JavaScript front-end displaying Java EE payload
最后，当您在“服务”窗口中查看“服务器”节点时，您应该看到 Java EE 后端应用已经部署，如图 5-19 所示。如果需要，右键单击已部署的节点以取消部署应用。
图 5-19。
Deployed application shown in Services window
在本章中，您已经学习了在 IDE 中构建连贯的功能性应用的完整而真实的用例。
七、测试和代码质量
NetBeans 以简单而详细的方式呈现质量问题和测试结果，这使我能够专注于我的主要任务——编写代码。除了 NetBeans，我很少需要使用其他工具。——Sven Reimers，系统工程师，空客防务&航天
测试应用是开发周期中不可或缺的一部分，而编写和维护测试有助于确保单个方法和应用整体代码的质量。NetBeans IDE 对测试相关框架、库和相关代码质量解决方案的集成支持是本章的重点。
比较测试解决方案超出了本书的范围。本章将向您介绍不同的解决方案，并学习如何在 IDE 中使用它们。由您来决定这些解决方案是否适用于您正在进行的项目，并确定这些解决方案之间的比较情况。同样，注意你应该结合本章阅读第六章“分析和重构”，因为本章描述的通过测试的代码质量和第六章描述的分析工具有一定的协同和重叠。
表 7-1 列出了与测试和代码质量相关的解决方案，您将在 IDE 的上下文中了解这些解决方案。
表 7-1。
Frameworks Related to Testing and Code Quality
| 结构 | 描述 | | --- | --- | | 单元测试 | 最广泛建立的单元测试框架。如果您的需求仅限于非常详细的单元测试，并且它们之间没有依赖关系，那么 JUnit 是一个合适的单元测试框架。 | | 测试 | 一个在 JUnit 几年后创建的单元测试框架，使其开发人员能够从 JUnit 的见解中获益。特别是，如果您的需求包括单元测试之间的数据依赖和共享(在这个上下文中称为“参数”)，那么可以考虑使用 TestNG。 | | 硒 | Selenium 自动化浏览器。它是一个测试框架，主要关注自动化 web 应用的测试；例如，它为测试服务提供了生命周期管理。 | | 阿奎连 | Arquillian 特别专注于成为 Java EE 应用的集成测试解决方案，它继承了其他测试框架的不足。Arquillian 处理容器管理的管道，以及部署和框架初始化。与“简单的”模块测试相反，Arquillian 的目标是在运行时使用所有可用的必要资源测试项目，特别是针对 Java EE 环境，同时与各种其他测试框架紧密集成，比如上面列出的那些。 | | 复盖面 | 一个 Java 代码覆盖解决方案，通知您正在测试的应用的百分比。 | | 杰柯 | 一个 Java 代码覆盖解决方案，通知您正在测试的应用的百分比。 | | 声纳员 | 一个管理代码质量的开源平台。它以前被称为“声纳”。 |当然，Java 生态系统中还存在许多其他测试框架和其他相关解决方案。然而，表 7-1 中列出的那些通常与在 IDE 中开发的项目结合使用。要探索本章范围之外的测试框架和代码质量，建议您调查软件质量环境( sqe-team.github.io )，它旨在成为各种代码质量框架的一站式商店，以及 EasyPmd ( github.com/giancosta86/EasyPmd )插件，它在第四章中提到。
JUnit 和 TestNG
在 IDE 中，为帮助您使用 JUnit 和 TestNG 而提供的工具是相同的，因此您将在同一部分中了解它们。两者都适用于单元测试，也就是说，当您在应用中测试单独的方法时，应该使用其中的一种。
在这两种情况下，使用这些框架的起点都是在“项目”窗口中选择一个项目，然后转到“新建文件”窗口(Ctrl+N)。在单元测试类别中，你会找到 JUnit 和 TestNG 的入门模板，如图 7-1 所示。
图 7-1。
File templates for unit tests
或者，在“项目”窗口中右键单击 Java 文件，然后选择“工具”“➤”“创建/更新测试”( Ctrl+Shift+U)。为当前选定的文件打开“创建测试”窗口，允许您选择 JUnit 或 TestNG。您还可以使用图 7-1 所示的单元测试类别中的向导中的所有其他设置。
如图 7-2 所示，单元测试类别中的向导非常详细，可以帮助您准确地生成您需要的测试。有关 JUnit 和 TestNG 的详细信息，请参见它们的在线文档，分别位于junit.org和testng.org。
图 7-2。
New Test for Existing Class wizard
对于 JUnit，当你点击图 7-2 中的 Finish 时，会提示你选择生成的测试应该基于 JUnit 3 还是 JUnit 4，如图 7-3 所示。使用 JUnit 4，您的测试可以使用 JDK 5 中引入的 Java 特性，比如泛型和注释。为了使用 JUnit 4，应用使用的 JDK 版本至少应该是 JDK 5。
图 7-3。
Select JUnit Version window
当您完成任何单元测试向导时，IDE 都会创建一个符合所选单元测试框架的起点。此外，相关的 jar 被添加到应用的类路径中，对于基于 Maven 的应用，它们被注册到 POM 文件中，同时也显示在“项目”窗口的“测试依赖项”节点中。它们相互关联的依赖关系可以在 Maven POM 的图形视图中可视化，如图 7-4 所示。
图 7-4。
Test dependencies shown in the Projects window and Graph view
一个有用的相关提示是，您可以很容易地找到 Java 文件的单元测试文件。在编辑器中打开 Java 文件，比如双击它，然后按 Ctrl+Alt+T。如果相关的测试文件存在，它将被打开。如果文件不存在，系统会提示您创建该文件。
一旦你写好了测试，你就可以运行它们了。若要运行项目中的所有测试，请右击该项目，然后选择“测试”(Alt+F6)。要运行特定 Java 文件的测试文件，请右键单击该 Java 文件，然后选择“测试”(Ctrl+F6)。要运行特定的测试方法，请在源代码编辑器中打开测试文件，右键单击要测试的方法的签名，然后选择“运行焦点测试方法”。
测试结果窗口(Alt+Shift+R)打开，显示测试结果，如图 7-5 所示。
图 7-5。
Test Results window
在“测试结果”窗口中，双击一个条目以跳转到定义测试方法的相关源代码。“测试结果”窗口左侧的按钮允许您重新运行测试方法，并从“测试结果”窗口中筛选出项目。
更多的特性可以被合并到你的单元测试中。例如，当您使用 JUnitReport Ant 任务或 Maven surefire-report 插件时，可以在测试过程中自动生成各种格式的报告。
硒
硒(seleniumhq.org)自动化浏览器。它是一个测试框架，主要关注自动化 web 应用的测试，例如，它为测试服务提供生命周期管理。
使用 Selenium 的起点是在“项目”窗口中选择一个项目，然后转到“新建文件”窗口(Ctrl+N)。在 Selenium Tests 类别中，您可以找到开始使用 Selenium 的模板，如图 7-6 所示。
图 7-6。
File templates for Selenium tests
当您完成任何 Selenium 测试向导时，IDE 都会创建一个符合您所选 Selenium 测试类型的起点。此外，相关的 jar 被添加到应用的类路径中，对于基于 Maven 的项目，它们被添加到 POM 文件中。
与上一节讨论的单元测试一样，测试结果窗口(Alt+Shift+R)打开，如图 7-5 所示，显示测试结果。
阿奎连
Arquillian ( arquillian.org)是一个与使用 Java EE 平台的应用相关的测试框架。Arquillian 是一个面向社区的项目，由 Red Hat 发起。它起源于 JBoss Test Harness，一个由 Red Hat 的 Pete Muir 创建的实用程序，作为 JSR-299 (CDI 1.0)和 JSR-303 (Bean Validation 1.0)的测试相关工具包的基础。
Arquillian 背后的基本思想是，在 Java EE 环境中通过 JUnit 和 TestNG 编写测试是一项挑战。在 Java EE 环境中，有多种 Java EE 容器可用，比如 WebLogic、GlassFish、JBoss 和 WildFly。每个 Java EE 容器都提供了各种各样的库和工具。Arquillian 使您能够无缝地使用特定 Java EE 容器提供的资源，并让您轻松地在它们之间切换。虽然它的部分好处是与容器无关，但更普遍的是，Arquillian 将服务器端集成测试作为其重点，而 plain JUnit 和 TestNG 根本没有考虑服务器端问题。
与本章讨论的其他解决方案一样，我不会提供比目前为止你所收到的粗略介绍更多的内容，因为如果你对学习 Arquillian 感兴趣的话，还有各种其他的书籍和在线文章。一如既往，这里的重点是如何在 IDE 中使用 Arquillian。
用 Arquillian 编写 Java EE 应用测试的一个有用的起点是 Arquillian 项目负责人 Aslak Knutsen 的“hello world”Arquillian 项目，可从以下位置获得:
github.com/aslakknutsen/arquillian-example-helloworld
当您使用 Git 签出这个项目时，您将拥有一个 Maven 项目。转到 IDE 中的文件➤打开，并浏览到包含 POM 文件的文件夹。IDE 将允许您打开该项目。浏览该项目，并注意所有使用 Arquillian 的 Java EE 应用共有的以下特征:
- 在
src/test/resources文件夹中找到一个arquillian.xml文件。 - POM 文件有一个
dependency-management部分，它注册了arquillian-bom和jboss-javaee-7.0的依赖关系。 - POM 文件在
dependencies部分注册了许多依赖项，包括org.jboss.arquillian.junit、org.arquillian.container和junit。 GreetingServiceTestCase.java文件显示可以使用典型的 Java EE 结构，比如@Inject注释，而 Arquillian 注释，比如@RunWith和@Deployment可以帮助您设置和初始化测试的生命周期。
在 IDE 中，通过 Arquillian 定义的测试可以按照前面章节中描述的相同方式运行，并产生相同类型的结果，如图 7-7 所示。
图 7-7。
Running Arquillian tests in the IDE
总之，IDE 是用 Arquillian 设置、开发和运行测试的自然环境。
Java 代码覆盖率
JaCoCo ( eclemma.org/jacoco)和 Cobertura ( cobertura.github.io/cobertura)是免费的 Java 代码覆盖库。这些项目的目标是为基于 Java VM 的环境中的代码覆盖分析提供标准技术。他们的重点是提供轻量级的、灵活的、文档良好的库，以便与各种构建和开发工具集成。
Java 代码覆盖库中的特性包括对指令、分支、行、方法、类型和圈复杂度的代码分析。在 JaCoCo 的例子中，分析是基于 Java 字节码的，因此不需要源文件。集成很简单，没有痛苦，因为一切都是通过一个基于动态工具的 Java 代理完成的。此外，这些解决方案是框架不可知的，因为它们可以与基于 Java VM 的应用顺利集成，例如普通的 Java 应用、OSGi 框架、web 容器和 EJB 服务器。支持各种报告格式，包括 HTML、XML 和 CSV。
在 IDE 中，与 JaCoCo 和 Cobertura 的集成对于 Maven 应用来说是现成的。在 Maven 应用中设置 Java 代码覆盖率就像在 POM 中添加用于 JaCoCo 的 Maven 插件一样简单:
<build>
<plugins>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.7.5.201505241946 </version>
<executions>
<execution>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<execution>
<id>report</id>
<phase>prepare-package</phase>
<goals>
<goal>report</goal>
</goals >
</execution>
</executions>
</plugin>
</plugins>
</build>
对于 Cobertura，Maven Cobertura 插件在 POM 中注册如下:
<reporting>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>cobertura-maven-plugin</artifactId>
<version>2.7</version>
</plugin>
</plugins>
</reporting>
当一个 Java 代码覆盖插件(不超过一个！)已在项目的 POM 中注册，IDE 会立即检测到该插件已被添加。很快，新的菜单项就可以用来检查基于 Maven 的项目的代码覆盖率。当您右键单击一个项目时，这些菜单项是可用的，该项目中的 Java 代码覆盖 Maven 插件已经被添加到 POM 中，如图 7-8 所示。
图 7-8。
Code Coverage menu items
选择显示报告菜单项，打开代码覆盖率报告窗口，如图 7-9 所示。
图 7-9。
Code Coverage Report window
当你点击运行所有测试时，应用中的测试运行，Java 代码覆盖率库分析代码覆盖率并收集结果，IDE 在代码覆盖率报告窗口显示结果，如图 7-9 所示。
接下来，在文件窗口(Ctrl+2)中，展开项目的target文件夹。在site子文件夹中，你会看到已经创建了一个jacoco或cobertura文件夹。它包含生成的报表和其他输出，如图 7-10 所示。
图 7-10。
JaCoCo reports and output in the Files window
每个 Java 文件，当在编辑器中打开时，显示正在测试(绿色)和没有测试(红色)的语句，如图 7-11 所示。Java 代码覆盖库和 IDE 的结合有助于支持测试驱动开发，因为当您为类中定义的语句编写新的测试时，编辑器中的绿色/红色标记会不断更新。
图 7-11。
Code coverage shown in Java source file
要在基于 Ant 的项目中使用类似的特性，进入工具➤插件，安装 TikiOne JaCoCoverage 插件，如图 7-12 所示。
图 7-12。
Code coverage for Ant-based Java projects
声纳员
sonar cube(sonarqube.org)是一个管理代码质量的在线开放平台。它涵盖了代码质量的一系列领域，特别关注与架构、设计、复制、单元测试、复杂性、潜在缺陷、编码规则和注释相关的代码分析。
在 IDE 中，通过 Radar 插件可以与 SonarQube 集成，该插件可以从以下 URL 下载: github.com/hmvictor/radar-netbeans 。插件的源代码可以在以下网址找到: github.com/hmvictor/radar-netbeans 。使用 Radar 插件，您可以从 SonarQube 服务器检索问题，或者运行本地分析。
一旦安装了 Radar 插件，右键单击 Maven 项目并选择“从服务器获取问题”或“从 Sonar Runner 获取问题”,就可以访问 SonarQube。
SonarQube 窗口中列出了问题，如图 7-13 所示。
图 7-13。
SonarQube window
