Java-开发者的-NetBeans-IDE-入门手册-全-

Java 开发者的 NetBeans IDE 入门手册（全）

原文：Beginning NetBeans IDE for Java developers

协议：CC BY-NC-SA 4.0

一、安装和设置

由于其开箱即用的体验，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

八、故障排除

我喜欢 NetBeans 的一点是它不断追求创新。NetBeans 调试器是第一个提供混合语言支持(例如 Java/JavaScript)的，并将很快帮助为 Oracle 实验室基于新的 Truffle 框架构建的任何语言提供现成的调试，例如 JRuby、FastR、Python 等！—Jaroslav Tulach，NetBeans 的创始人

NetBeans IDE 提供了一个丰富的环境，用于识别错误、排除瓶颈故障以及优化 Java 应用中的代码。内置的 Java 调试器允许您在 Java 代码执行的同时逐步调试您的 Java 代码，使您能够监视正在运行的应用的各个方面，例如它的变量值、它的方法调用的当前序列、它的线程状态以及它的对象的创建。

当使用调试器时，如图 8-1 所示，你没有理由用System.out.println语句来诊断应用中出现的问题。(使用前面章节中描述的“检查&转换”功能来识别并删除所有的System.out.println语句。)相反，您可以使用调试器来指定代码中带有断点的“关注点”(断点不存储在代码中，而是存储在 IDE 中)，在这些断点处暂停程序，并使用 IDE 中的调试工具来评估正在运行的程序的当前状态。

图 8-1。

NetBeans Debugger

此外，您可以在调试时更改代码，并动态地将类重新加载到调试器中，而无需重新启动调试会话。

表 8-1 列出了您可以使用调试器执行的活动。

表 8-1。

Debugger Activities

| 活动 | 描述 | | --- | --- | | 步骤 | 逐句通过应用代码，包括 JDK 源代码。需要时，您可以在当前调用栈中退回到以前调用的方法的开头(“弹出”调用)。 | | 执行 | 使用断点作为分隔符，一次执行特定的代码块。 | | 暂停 | 当满足指定的条件时暂停执行，例如当迭代器达到某个值时，或者在导致异常的代码行或异常本身处暂停执行。监视线程时，可以单独或集体挂起它们。 | | 轨道 | 通过“监视”功能跟踪变量或表达式的值或变量引用的对象。 | | 应用 | 动态应用代码更改并继续调试会话。 | | 识别 | 识别和分析死锁。 | | 奔跑 | 可以同时运行单个或多个调试会话。 |

入门指南

调试器使您能够在称为“断点”的关键点暂停程序的执行，并检查变量值、线程状态等。一旦在断点处暂停执行，就可以一行一行地单步执行代码。

开始调试程序包括以下步骤。

Determine the “point of interest” in your code where you want to start debugging and set a breakpoint at that line by clicking in the left margin of that line. A red icon appears in the left margin to mark the breakpoint. In addition, the whole line is highlighted in red.   Start the Debugger by choosing Debug Project or by pressing Ctrl+F5. The IDE builds (or rebuilds) the application and then opens up Debugger windows, by default in the lower half of the IDE.   When the execution of the program stops at the breakpoint, which you can see when the red breakpoint highlight is replaced by the green highlight, you can use the buttons in the toolbar, or their related keyboard shortcuts, to step through the code line by line while viewing the status of variables, threads, and other information.   Observe the program flow, while monitoring and analyzing the evolving values of variables in the Variables window.   Based on your analysis, fix your code and, where applicable, apply code changes and continue the debugging session.

或者，除了设置断点之外，您还可以使用另外两个在特定情况下可能有用的工具来开始调试程序。

• 运行到光标处。在源代码编辑器中，单击要暂停执行的行，然后单击工具栏中的“运行到光标处”。仅当您选择项目主类中的一行代码或主项目中由主类直接调用的类时，此命令才可用于启动调试会话。
• 调试文件。如果项目中有多个可执行类，有时您可能希望从指定为项目主类的类之外的类启动调试器。要在项目主类以外的类上启动调试器，请在“项目”窗口或“文件”窗口中右键单击文件的节点，然后选择“调试文件”。如果文件有 main 方法，则只能对该文件启动调试器。

调试器窗口

开始调试程序时，会出现各种调试器窗口。调试器窗口记录被调试程序的执行状态，例如代码是否在断点处停止。“输出”窗口中会打开选项卡，用于记录任何应用输出，以及 IDE 在运行命令时使用的脚本的输出。

调试器窗口(如监视、变量和调用栈)以选项卡的形式打开，并提供有关调试会话的当前信息，如变量的当前值和当前方法调用的列表。它们在表 8-2 中描述。还可以通过从“窗口”“➤调试”菜单中选择来打开各个调试窗口。

表 8-2。

Debugger Windows

| 工具 | 始于 | 描述 | | --- | --- | --- | | 变量 | Alt+Shift+1 | 显示调试器当前上下文中的所有字段和局部变量及其当前值。该节点下列出了字段。 | | 手表 | Alt+Shift+2 | 显示您已监视的字段、局部变量或表达式的名称。尽管无论当前上下文如何，都会显示您的所有监视，但显示的值是该上下文的值(而不是设置监视的上下文的值)。例如，如果您有一个对`this`关键字的监视，那么在监视窗口中引用的`this`将总是对应于从当前方法调用中引用的对象。 | | 调用栈 | Alt+Shift+3 | 显示当前调用链中的所有方法调用。“调用栈”窗口使您能够直接跳转到方法调用的代码，将程序的执行备份到以前的方法调用，或者选择一个上下文来查看局部变量值。 | | 班级 | Alt+Shift+4 | 为当前调试的应用提供按类加载器分组的类的树视图。 | | 断点 | Alt+Shift+5 | 显示您在所有正在运行的调试会话中设置的所有断点。 | | 线 | Alt+Shift+6 | 显示当前会话中的线程。在此窗口中，您可以通过将另一个线程指定为当前线程来切换上下文。 | | 会议 | Alt+Shift+7 | 为 IDE 中的每个调试会话显示一个节点。在此窗口中，您可以切换当前会话。 | | 来源 | Alt+Shift+8 | 显示可用于调试的源代码，并使您能够指定要使用的源代码。例如，您可以使用此窗口来启用对 JDK 源代码的调试。 |

大多数调试器窗口根据调试器的当前上下文显示值。通常，当前上下文对应于一个会话中一个线程中的一个方法调用。您可以更改上下文(例如，在“线程”窗口中指定不同的当前线程)，而不会影响被调试程序的运行方式。

步伐

一旦程序暂停，有几种方法可以恢复代码的执行。您可以逐行(逐步)或以更大的增量单步执行代码，如表 8-3 所示。

表 8-3。

Debugger Steps

| 步进命令 | 捷径 | 描述 | | --- | --- | --- | | 进入 | F7 | 执行当前行。如果该行是对方法或构造函数的调用，并且有可供被调用代码使用的源代码，则程序计数器移到方法或构造函数的声明。否则，程序计数器移动到文件中的下一行。 | | 跨过 | F8 | 执行当前行并将程序计数器移动到文件中的下一行。如果执行的行是对方法或构造函数的调用，则方法或构造函数中的代码也会被执行。 | | 走出去 | Ctrl+F7 | 执行当前方法或构造函数中的其余代码，并将程序计数器移动到方法或构造函数的调用方之后的行。如果您已经单步执行了不需要分析的方法，此命令非常有用。 | | 运行到光标处 | 法乐四联症 | 在源代码编辑器中执行程序中当前行和插入点之间的所有行。 | | 中止 | - | 停止当前会话中的所有线程。 | | 继续 | Ctrl+F5 | 继续执行程序，直到下一个断点。 |

逐行执行代码

通过选择“调试➤单步执行”(F7)，可以让调试器一次单步执行一行。

如果在方法调用中使用“单步执行”命令，调试器将进入该方法并在第一行暂停，除非该方法是尚未指定在调试器中使用的库的一部分。

执行一个方法而不单步执行它

通过选择“调试➤单步调试”(F8)，可以执行方法，而无需调试器在方法中暂停。

使用“单步执行”命令后，调试器在方法调用后的行再次暂停。

在方法结束时继续执行

如果已经单步执行了不需要继续分析的方法，可以让调试器完成该方法的执行，然后在方法调用后的行处再次暂停。

要以这种方式完成方法的执行，请选择“调试➤单步执行(Ctrl+F7)”。

继续到下一个断点

如果在调试时不需要观察每一行代码，可以继续执行，直到下一点，或者直到执行被挂起。

若要继续执行已在断点处暂停的程序，请选择“调试”“➤”“继续”或按 F5。

继续到光标位置

当执行暂停时，您可以继续执行特定的行，而不设置断点，方法是将光标放在该行，然后选择“调试➤运行到光标处”(F4)。

走进 JDK 和其他图书馆

调试时，如果在 IDE 的库管理器中注册了与 JDK 和任何其他库相关联的源代码，就可以单步执行这些库的代码。

默认情况下，在调试时，IDE 不会单步执行 JDK 源代码。如果在 JDK 方法调用中使用“单步执行”命令，IDE 将执行该方法，并将程序计数器返回到方法调用后的行(就像使用“单步执行”命令一样)。

若要允许单步执行已调试应用的 JDK 源代码，请启动该应用的调试器，然后通过从“窗口”菜单的“调试”菜单中选择“源代码”或按 Alt-Shift+8 打开“源代码”窗口。选中 JDK 的“用于调试”复选框。

限制可以进入库的类

如果您使用库进行调试，可以设置一个筛选器来排除一些正在使用的源代码。

要排除在调试器中使用的类，首先要启动应用的调试器。通过从“窗口”菜单的“调试”菜单中选择“源代码”或按 Alt-Shift+8 打开“源代码”窗口。右键单击要为其创建排除过滤器的库所在的行，然后选择“添加类别排除过滤器”。

在“添加类别排除筛选器”对话框中键入一个筛选器。过滤器可以是以下一种或多种:

• 完全限定的类名。
• 末尾带有星号(*)的包名或类名，用于创建通配符。例如，您可以键入以下命令来排除javax.swing包中的所有类:javax.swing.*

以通配符开头的表达式。例如，要排除名称末尾有Test的所有类，可以使用*Test。

您可以创建多个类别排除过滤器。

若要禁用该过滤器，请在“源代码”窗口中取消选择该过滤器旁边的“在调试中使用”复选框。

要删除类别排除过滤器，请右键单击该过滤器，然后选择删除。

从一个方法备份到它的调用

在某些情况下，退回到代码中可能会有用。例如，如果您遇到了一个断点，并且想要查看通向该断点的代码是如何工作的，您可以从调用栈中移除(“弹出”)当前调用，以重新执行该方法。

您可以打开“调用栈”窗口，查看当前线程中当前方法调用链内的所有方法调用。当前呼叫标有图标。栈中的其他调用用图标标记。

若要备份到上一个方法调用，请打开“调用栈”窗口(Alt+Shift+3)，右键单击“调用栈”窗口中代表代码中要返回的位置的那一行，然后选择“弹出到此处”。程序计数器返回到发出呼叫的线路。然后，您可以重新执行该方法。要备份到最近的方法调用，还可以从“调试”菜单的“栈”菜单中选择“弹出最顶层调用”。

断点

如图 8-2 所示，断点是一个标记，当您在调试器中运行应用时，您可以设置它来指定执行应该暂停的位置。

图 8-2。

Breakpoint

断点存储在 IDE 中，而不是存储在应用的代码中，并且在调试会话和 IDE 会话之间保持不变。

设置断点

当执行在断点处暂停时，执行暂停的行在源代码编辑器中以绿色突出显示，如图 8-3 所示。

图 8-3。

Paused execution

调试器控制台会打印一条消息，如图 8-4 所示，其中包含已到达断点的信息。

图 8-4。

Message printed in the Debugger Console

最简单的形式是，断点提供了一种在特定点暂停正在运行的程序的方法。当程序到达断点时，您可以执行表 8-4 中列出的活动和诊断任务。

表 8-4。

Breakpoint Tasks

| 工作 | 描述 | | --- | --- | | 班长 | 在程序执行的那一点监控变量的值。 | | 控制 | 通过逐行或逐个方法单步执行代码来控制程序的执行。 | | 检测变化 | 检测字段或局部变量的值何时更改(例如，这可以帮助您确定代码的哪一部分为字段分配了不适当的值)。 | | 检测创作 | 检测对象的创建时间(例如，在试图跟踪内存泄漏时，这可能很有用)。 |

您可以设置多个断点，并且可以设置不同类型的断点。

最简单的断点类型是行断点，其中程序的执行在特定行停止。您还可以在其他情况下设置断点，例如调用方法、引发异常或更改变量值。此外，您可以在某些类型的断点中设置条件，以便它们仅在特定情况下暂停程序的执行。

断点类型汇总见表 8-5 。

表 8-5。

Breakpoint Types

| 类型 | 描述 | | --- | --- | | 线条 | 在一行代码上设置。当调试器到达该行时，它会在执行该行之前停止。断点以红色背景突出显示。您还可以指定行断点的条件。 | | 班级 | 当从另一个类引用该类时，并且在执行该类中带有断点的任何行之前，执行被挂起。 | | 例外 | 当异常发生时，执行被挂起。您可以指定是在捕获到异常、未捕获到异常时停止执行，还是两者都停止执行。 | | 方法 | 当调用方法时，执行被挂起。 | | 可变的 | 当变量被访问时，执行被挂起。您还可以配置断点，使其仅在变量被修改时暂停执行。 | | 线 | 每当线程启动或终止时，执行都被挂起。还可以在线程死亡时设置断点(或者在线程开始和死亡时都设置断点)。 |

线条

要设置行断点，如图 8-5 所示，点击要设置断点的行的左边距。或者，在编辑器中单击该行的任意位置，然后按 Ctrl+F8。

图 8-5。

Line breakpoint

断点创建后，会自动注册到断点窗口(Alt+Shift+5)，如图 8-6 所示。

图 8-6。

Line breakpoint registered in the Breakpoints window

若要删除断点，请单击定义断点的行的左边距，或者单击该行并按 Ctrl+F8。通过反复单击 Ctrl+F8，可以在行断点和删除之间切换。还可以使用“断点”窗口删除断点。

要自定义行断点，请右键单击左边的红色图标，然后选择断点➤属性。或者，使用“断点”窗口(Alt+Shift+5)。在“断点”窗口中，右击断点并选择“属性”。断点属性窗口打开，如图 8-7 所示。

图 8-7。

Breakpoint Properties window

班级

你可以在一个类上设置一个断点，如图 8-8 所示，这样当类中的代码将要被访问时或者当类从内存中卸载时，调试器就会暂停。

图 8-8。

Class breakpoint

若要设置类调用断点，请单击定义该类的行的左边距。或者，选择调试➤新断点(Ctrl+Shift+F8)，从断点类型下拉列表中选择类，如图 8-9 所示。

图 8-9。

Class breakpoint type in the New Breakpoint window

断点窗口显示类调用断点，如图 8-10 所示。

图 8-10。

Class breakpoint registered in the Breakpoints window

方法

您可以设置一个断点，以便调试器在调用方法或构造函数时暂停，在方法或构造函数的任何行被执行之前，如图 8-11 所示。

图 8-11。

Method breakpoint

若要在方法或构造函数上设置断点，请单击定义该方法的行的左边距。或者，选择调试➤新断点(Ctrl+Shift+F8)，并从断点类型下拉列表中选择方法。断点属性窗口打开，停止于下拉菜单设置为方法入口，如图 8-12 所示。

图 8-12。

Stop On Method Entry in the Breakpoint Properties window

通过选中给定类的所有方法复选框，可以使断点应用于该类中的所有方法和构造函数，这将导致断点窗口注册该类中的所有方法。断点窗口显示方法调用断点，如图 8-13 所示。

图 8-13。

All methods in class registered in the Breakpoints window

例外

您可以设置断点，以便调试器在程序中引发异常时暂停。要在异常上设置断点，请选择调试➤新断点(Ctrl+Shift+F8)，然后从断点类型下拉列表中选择异常。新断点窗口打开，断点类型下拉框设置为异常，如图 8-14 所示。

图 8-14。

Exception breakpoint type in the New Breakpoint window

在“异常类名”字段中，键入要在其上设置断点的异常类。可以按 Ctrl+Space 让代码补全功能帮你补全类名，如图 8-14 所示。在“停止于”下拉列表中，选择是否希望断点应用于已捕获的异常、未捕获的异常或两者。

断点窗口显示异常断点，如图 8-15 所示。

图 8-15。

Exception breakpoint in the Breakpoints window

田

您可以设置断点，以便调试器在访问字段时暂停，或者仅在修改字段时暂停。要在字段上设置断点，选择调试➤新断点(Ctrl+Shift+F8)，从断点类型下拉列表中选择字段，如图 8-16 所示。

图 8-16。

Field breakpoint in the New Breakpoint window

填写类名和字段名字段。从停止于下拉列表中选择一个选项。如果选择“字段访问”或“修改”，则每次在代码中访问该字段时，执行都会挂起。如果选择字段修改，则仅当字段被修改时，执行才会暂停。

如果您在按 Ctrl+Shift+F8 时选择了该变量，则新断点窗口的大多数字段都会为您正确填充。

断点窗口显示字段断点，如图 8-17 所示。

图 8-17。

Field breakpoint registered in the Breakpoints window

线

通过设置一个断点，在每次创建或结束新线程时暂停执行，可以监视程序中线程的创建或死亡。

要在线程上设置断点，选择调试➤新断点(Ctrl+Shift+F8)，从断点类型下拉列表中选择线程，如图 8-18 所示。

图 8-18。

Thread breakpoint in the New Breakpoint window

在“停止于”下拉列表中，选择“线程开始”、“线程死亡”或“线程开始或死亡”。

断点窗口显示线程断点，如图 8-19 所示。

图 8-19。

Thread breakpoint registered in the Breakpoints window

管理断点

您可以使用如图 8-19 所示的断点窗口和之前的图在一个地方管理断点。您可以在断点上定义条件，并将断点分组，这对于测试指定的功能集非常有用。您还可以暂时禁用断点，并在此窗口中为断点提供其他自定义设置。

要打开“断点”窗口，请选择窗口➤调试➤断点或按 Alt+Shift+5。

情况

您可以设置一个断点，仅在满足特定条件时暂停执行。例如，如果您有一个很长的*For*循环，并且您想看看在循环结束之前发生了什么，那么您可以根据迭代器达到某个值来设置断点。

表 8-6 列出了您可以在断点上定义的条件示例。

表 8-6。

Example Breakpoint Conditions

| 工作 | 描述 | | --- | --- | | `i==4` | 如果变量`i`在当前范围内等于`4`，执行将仅在断点处停止。 | | `ObjectVariable!=null` | 执行不会在断点处停止，直到`ObjectVariable`被赋值。 | | `MethodName` | 如果`Method`具有布尔返回类型，只有当`Method`返回`true`时，执行才会在断点处停止。 | | `CollectionX.contains(ObjectX)` | 如果`ObjectX`在集合中，执行将仅在断点处停止。 |

若要使断点有条件，请打开“断点”窗口(Alt+Shift+5)。在“断点”窗口中，右键单击要在其上放置条件的断点，然后选择“属性”。

在“断点属性”窗口中，在“条件”字段中填入在断点处暂停执行所需满足的条件。

组

在某些情况下，您可能有几个相关的断点，您希望能够一起启用、禁用或删除它们。或者，您可能只想将一些断点合并到一个节点下，以使断点窗口不那么杂乱。

若要对断点进行分组，请通过选择窗口➤调试➤断点(Alt+Shift+5)来打开“断点”窗口。按住 Shift 键或 Ctrl 键单击以选择要分组的断点。右键单击选择，选择“设置组名”，然后输入组的名称。

在“断点”窗口中，断点分组在一个可展开的节点下。

允许

您可能会发现在整个应用中保持断点设置很有用，但是您可能不希望所有的断点都一直处于活动状态。如果是这种情况，您可以禁用断点或断点组，并保留它供以后使用。

若要禁用断点或断点组，请通过选择窗口➤调试➤断点(或按 Alt+Shift+5)打开“断点”窗口。在“断点”窗口中，右键单击断点或断点组，然后选择“禁用”。

若要删除一行断点，请单击有断点的行的左边距，或者单击该行并按 Ctrl+F8。若要删除另一种类型的断点，请通过选择“窗口”“➤调试”“➤断点”(或按 Alt+Shift+5)来打开“断点”窗口。在“断点”窗口中，右键单击断点，然后选择“删除”。

记录

如果您希望在遇到断点时进行监视，而不是每次遇到断点时都挂起执行，则可以将断点配置为不挂起执行。当程序在代码中到达这样的断点时，将在调试器控制台窗口中打印一条消息。

若要在命中断点时关闭执行挂起，请通过选择窗口➤调试➤断点(Alt+Shift+5)来打开“断点”窗口。在“断点”窗口中，右击断点并选择“属性”以打开“断点属性”窗口。在“操作”组合框中，选择“无线程(继续)”。

信息

您可以自定义在代码中遇到断点时打印到控制台的文本。

要自定义到达断点时打印的控制台消息，请通过选择窗口➤调试➤断点(Alt+Shift+5)打开“断点”窗口。在“断点”窗口中，右击断点并选择“属性”以打开“断点属性”窗口。在“打印文本”组合框中，修改要打印的文本。为了使打印文本更有意义，可以使用替代代码来打印螺纹名称和行号。

表 8-7 列出了替代代码。

表 8-7。

Example Messages and Substitution Codes

| 替代代码 | 印刷品 | | --- | --- | | `{className}` | 命中断点的类的名称。此代码不适用于线程断点。 | | `{lineNumber}` | 执行被挂起的行号。此代码不适用于线程断点。 | | `{methodName}` | 暂停执行的方法。此代码不适用于线程断点。 | | `{threadName}` | 命中断点的线程。 | | `{variableValue}` | 变量值(对于变量上设置的断点)或异常值(对于异常断点)。 | | `{variableType}` | 变量类型(针对变量上设置的断点)或异常类型(针对异常断点)。 |

手表

当您单步执行程序时，您可以监视字段和局部变量的运行值。

变量窗口(Alt+Shift+1)如图 8-20 所示，显示程序当前执行上下文中的所有变量，并列出它们的类型和值。

图 8-20。

Variables window

如果变量的值是一个对象引用，则该值由井号(#)和一个数字给出，该数字用作对象实例的标识符。

双击变量名称可以跳转到变量的源代码。

您还可以通过设置监视并在“监视”窗口(Alt+Shift+2)中查看，来创建与您的分析相关的变量和表达式的自定义视图，如图 8-21 所示，该窗口不同于变量窗口。

图 8-21。

Watches window

“监视”窗口在三个方面不同于“变量”窗口。

• “监视”窗口显示您指定的变量或表达式的值，这使窗口保持整洁。
• “监视”窗口显示您设置的所有监视，无论变量是否在上下文中。如果变量分别存在于不同的上下文中，则“监视”窗口中给定的值适用于当前上下文中的值(不一定是设置监视的上下文)。
• 监视在调试会话中持续存在。

在变量或字段上设置监视

要对变量或表达式设置监视，请在源代码编辑器中右键单击该变量，然后选择“新建监视”。然后，变量或表达式被添加到"监视"窗口中。

调试时，您还可以在当前调试上下文中检查变量的值，方法是将鼠标悬停在源代码编辑器中的变量上，以显示带有该值的工具提示，如图 8-22 所示。

图 8-22。

Tooltip showing value of current variable

监控分配给变量的对象

您可以创建一个所谓的“固定观察器”来监视分配给变量的对象，而不是变量本身的值。

要创建固定观察器，请启动调试会话并打开变量窗口(Alt+Shift+1)。在编辑器中，右键单击要为其设置固定监视的变量，然后选择“创建固定监视”。

然后，一个固定的监视被添加到“监视”窗口中。因为固定监视应用于调试会话期间创建的特定对象实例，所以当调试会话完成时，固定监视被移除。

显示类的 toString 方法的值

您可以在“局部变量”和“监视”窗口中添加一列，以显示对象的to String方法的结果。这样做提供了一种方法，可以获得比值列中的对象实例的数字标识符更有用的信息(如当前分配的字段的值)。

要在其中一个窗口中显示toString()列，请打开“局部变量”窗口(Alt+Shift+1)或“监视”窗口(Alt+Shift+2)。点按窗口右上角的按钮。在“更改可见列”对话框中，选择toString()复选框。

改变变量或表达式的值

调试程序时，可以更改“局部变量”或“监视”窗口中显示的变量或表达式的值。例如，您可以增加迭代器的值，以便更快地到达循环的末尾。

要更改变量值，请打开“监视”窗口或“变量”窗口。在变量或表达式的值字段中，键入新值，然后按 Enter 键。

显示以前方法调用的变量

调用栈窗口(Alt+Shift+3)显示当前方法调用链中的所有调用，如图 8-23 所示。

图 8-23。

Call Stack window

如果要查看链中另一个调用的变量状态，可以打开“调用栈”窗口，右键单击该方法的节点，然后选择“设为当前”。您也可以双击某个方法使其成为当前方法。

您可以使用“使被调用方成为当前方”( Ctrl+Alt+Up)和“使调用方成为当前方”( Ctrl+Alt+Down)命令浏览调用栈中的项目。

将不同的方法设为当前方法不会改变程序计数器的位置。如果用一个 step 命令或 continue 命令继续执行，程序将从暂停执行的地方继续执行。

线

IDE 的线程窗口(Alt+Shift+7)可以让你查看当前调试程序中线程的状态，如图 8-24 所示。

图 8-24。

The Threads window

它还使您能够更改在其他调试器窗口(如“调用栈”窗口和“变量”窗口)中监视的线程，并挂起单个线程。

切换当前监控的线程

“调用栈”和“变量”窗口的内容取决于调试器中当前正在监视的线程(也称为当前线程)。

若要切换当前监视的线程，请通过按 Alt+Shift+7 打开“线程”窗口。右键单击要监视的线程，然后选择“设为当前线程”。

挂起和恢复线程

您可以通过在“线程”窗口中右键单击线程节点并选择“挂起”来挂起线程的执行。

右键单击挂起线程的节点并选择“恢复”,可以恢复该线程的执行。

在断点处挂起单个线程

默认情况下，当程序遇到断点时，所有线程都被挂起。但是，您可以配置一个断点，以便在命中断点时只挂起其线程。通过按 Alt+Shift+5 打开“断点”窗口。在“断点”窗口中，右击断点并选择“属性”。在“断点属性”窗口中，从“挂起”组合框中选择“当前”。

将调试隔离到单个线程

默认情况下，应用中的所有线程都在调试器中执行。

如果希望隔离调试，以便调试器中只运行一个线程，请确保要调试的线程在“线程”窗口中被指定为当前线程(Alt+Shift+7)。当前线程标有图标。通过按 Alt+Shift+6 打开会话窗口。在“会话”窗口中，右键单击该会话的节点，然后选择“范围➤调试当前线程”。

识别死锁

IDE 可以通过在所有挂起的线程中自动搜索死锁来帮助您识别潜在的死锁情况。当检测到死锁时，IDE 会在调试窗口中显示一个通知，并识别涉及的线程，如图 8-25 所示。

图 8-25。

Detecting deadlocks

调试应用时，从主菜单中选择“调试➤检查死锁”,检查挂起的线程是否存在死锁。

代码更改

使用“应用代码更改”功能，可以在调试会话过程中微调代码，并在不启动新的调试会话的情况下继续调试。这可以为您节省大量时间，否则这些时间将花费在等待重新构建源代码和重新启动调试会话上。

应用代码更改功能对于表 8-8 中列出的一组特定场景非常有用。

表 8-8。

Scenarios for “Apply Code Changes”

| 方案 | 支持？ | | --- | --- | | 微调您创建的可视组件的外观。 | 是 | | 改变方法中的逻辑。 | 是 | | 添加或移除方法或字段。 | 不 | | 更改类、字段或方法的访问修饰符。 | 不 | | 重构类层次结构。 | 不 | | 更改尚未加载到虚拟机中的代码。 | 不 |

有关更高级的代码更改功能，请参见 NetBeans 合作伙伴 ZeroTurnaround 在zeroturnaround.com提供的 JRebel 产品。JRebel 是一个 JVM 插件，它允许你重新加载你对代码所做的修改，而不需要重启/重新部署。它将您的项目工作区直接映射到一个正在运行的应用，因此当您对项目中的任何类或资源进行更改时，该更改会立即反映在应用中，从而跳过构建和重新部署阶段。您可以将 JRebel 与 NetBeans 调试器一起使用，并在重新加载代码更改时调试您的应用。

要在 IDE 中安装 JRebel，请转到plugins.netbeans.org，找到 JRebel NetBeans 插件，可以从以下网址下载: http://plugins.netbeans.org/plugin/22254/jrebel-netbeans-plugin 。此外，在 IDE 的大多数版本中，您应该能够在插件管理器中找到 JRebel NetBeans 插件，方法是在 IDE 中转到“工具”“➤插件”。

GUI 快照

如图 8-26 和 8-27 所示，GUI 快照是一个可视化调试工具，可以帮助您定位 GUI 组件的源代码。GUI 组件的源代码有时很难找到，快照为您提供了一种基于 GUI 找到代码的方法，而不是搜索代码。

图 8-27。

GUI Snapshot for JavaFX components

图 8-26。

GUI Snapshot for Java Swing components

如本节所述，一旦创建了 GUI 的快照，就可以在快照中选择组件，并从弹出菜单中调用任务，以查看组件的源代码，显示侦听器，并在组件上设置断点。

要制作 GUI 快照，请在调试 Java Swing 或 JavaFX 应用时从主菜单中选择 Debug ➤ Take GUI Snapshot。当您选择获取 GUI 快照时，IDE 将获取 GUI 的快照，并在主窗口中打开该快照。

当您在快照中选择一个组件时，IDE 会在“属性”窗口中显示所选组件的详细信息。如果属性窗口不可见，可以从主菜单中选择窗口➤属性来打开该窗口。IDE 还会在“导航”窗口中显示组件在层次结构中的位置。右键单击快照中的组件，然后从弹出菜单中选择“转到组件声明”。IDE 将在编辑器中打开源文件，并将光标移动到代码中声明组件的那一行。再次右键单击快照中的组件，然后选择转到组件源。IDE 将在编辑器中打开源文件，并将光标移动到组件源代码中的行。

最后，您可以使用 GUI 快照和 Events 窗口来浏览组件事件，使您能够定位组件侦听器和由组件触发的事件。

九、分析和调整

NetBeans 中包含的内存分析器是唯一能够提供真实世代计数的分析器。这一特色本身的价值要比免费门票高出许多许多倍。一切正常，所以我在想代码，而不是 IDE。—Kirk Pepperdine，Java 性能专家

想象一下，经过几个月的开发时间和大量的测试，您的应用终于可以进行生产部署了。应用开始运行，最初几分钟一切似乎都很成功。突然，你接到一个用户的电话，告诉你他不能访问这个应用，因为它似乎无限期地加载。过了一会儿，你接到另一个电话，又一个。似乎您的应用不允许足够多的用户同时访问。

这是一个噩梦般的场景，在这个场景中，应用开发团队必须在极大的压力下做出关键的性能调优决策，并且他们必须直接对生产环境做出每一项更改。在这种情况下，你从哪里开始？会有什么问题呢？服务器配置是否妨碍了生产环境的足够连接，或者应用代码是否包含迫使用户等待的瓶颈？

许多应用直到投入生产后才进行性能调优。不幸的是，许多组织并不认为性能调优是他们开发生命周期的一个重要部分，而是把它作为出现问题时的一个分流步骤。更糟糕的是，Java 性能调优就像大海捞针一样。性能问题的原因可能在任何地方，从应用源代码到服务器配置。

在本章中，您将了解分析和调整过程，尤其是与内置 NetBeans IDE 分析器(如图 9-1 所示)和 Apache JMeter 相关的过程。您可以在主动分析和调优 Java 应用时使用这些过程，这样就可以避免在应用没有调优或调优不正确时可能出现的噩梦场景。

图 9-1。

NetBeans Profiler

性能调整

性能调优应该是开发生命周期的一个标准部分。应用的设计应该以性能为中心。前瞻性地考虑性能意味着仔细考虑实现应用解决方案的所有方法，而不仅仅是最快的方法或最容易实现的方法。

特别是，在开发 Java EE 应用时很难考虑性能，尤其是因为 Java EE 环境中的几个争用点会给应用增加性能负担。Java EE 应用环境中遇到的主要性能问题往往与配置和环境问题有关。通常情况下，应用本身编码得很好，而应用部署到的应用服务器没有正确调优，或者配置不适合应用或预期的用户容量。

要针对生产应用进行适当调整，请按列出的顺序执行以下步骤:

Application tuning   Server tuning   Java runtime tuning   Server operating system and platform tuning

性能编码

在 Java 应用中，有许多编码情况可能会导致性能开销。特别是因为 Java EE 应用是并发执行的，所以它们会导致瓶颈。用户可能会争夺资源，如 web 服务和数据库。每个远程调用都会增加延迟，而序列化等过程会占用大量 CPU 资源，导致性能进一步下降。

考虑到这些问题，您需要仔细设计 Java EE 应用，确保使用正确的资源处理。应用的性能调优应该从其源代码开始。即使 Java EE 应用中性能问题的主要原因指向环境，正确的编码仍然可以在性能良好的应用中发挥关键作用。

除其他外，以下糟糕的编码实践可能会导致性能问题:

• 过度序列化和反序列化
• 终结器的过度使用
• 太多的同步
• 不丢弃未使用的变量
• 太多动态变量
• System.out.println的泛滥使用
• 不再需要时不释放的会话
• 无法关闭资源(例如，数据库和网络连接)

第六章，讨论了分析和重构，应该有助于识别你的代码中存在不良编码实践的区域，比如这里列出的。

执行代码审查对于减少抑制应用性能的问题是必不可少的。虽然粗制滥造的代码可能会逃过多个开发人员的眼睛，但检查它的眼睛越多越好。除了代码审查之外，应该有多个人对应用运行性能和负载测试，并将当前测试的结果与之前运行的结果进行比较。

调整环境

许多环境因素会影响应用的性能。您应该学习理解应用服务器的管理控制台和命令行实用程序，因为您将花费大量时间使用它们。例如，对于 GlassFish 4，默认域是为测试目的而适当配置的，而它很可能不适合生产环境，至少在没有进一步配置的情况下不适合。

确保为您的应用正确配置了部署设置。如果您的应用服务器允许自动部署或动态应用重载，请确保在生产环境中禁用这些设置，因为它们会对性能产生重大影响。还要注意日志的写入频率，因为频繁的日志记录会导致不合时宜的性能问题。考虑企业组件的应用服务器配置设置，例如企业 JavaBeans (EJB)容器、Java 消息服务(JMS)和 Java 事务服务(JTS)。始终检查默认配置设置，并修改它们以支持生产环境。适当时，配置服务器群集以通过负载平衡提供高可用性。

请记住，不要将数据库视为数据的黑匣子。无论是查询大型数据集还是执行太多小型查询，数据库访问都可能成为应用的争用点。无论是哪种情况，都要有一个数据库管理员(DBA)的联系电话，他可能能够在数据库表上创建索引，或者甚至在有意义的时候将应用逻辑合并到数据库中。

容量规划

许多工具可以帮助您为产品发布准备应用。分析工具在应用的开发生命周期中扮演着重要的角色。此类工具可用于预测应用在正常或重负载下发布到生产环境后的性能。

在 NetBeans IDE 环境中，两个这样的工具是内置的 NetBeans Profiler(以下称为“Profiler”)和 Apache JMeter 插件。这两个特性都有助于您在将应用部署到生产环境之前检测有关应用的重要运行时信息，使您能够监控与线程状态、CPU 性能、内存使用和锁争用相关的数据。

评测器入门

该分析器内置于 NetBeans IDE 中。不需要单独的安装或启用过程。

通过使用探查器，您可以在 IDE 中对项目或文件执行一组特定的分析任务。探查器执行的分析任务如下:

• 遥测:应用监控，带有 CPU 和内存使用情况的图表
• 方法:分析方法执行和时间，也称为 CPU 分析
• 对象:分析对象分配和大小，也称为内存分析
• 线程:在时间轴中监视和可视化线程状态
• 锁:锁争用的分析和可视化

图 9-2 显示了 NetBeans IDE 8.1 中新增的配置和启动分析窗口。它列出了前面讨论过的分析任务，并为您提供了开始使用这些任务的简单方法。

图 9-2。

Configure and Start Profiling window

在接下来的小节中，您将依次了解每一项性能分析任务。

基本分析术语

在继续之前，让我们快速浏览一下使用 profiler 时需要熟悉的一些术语。虽然 NetBeans Profiler 使您可以轻松地分析应用，即使您以前从未使用过分析工具，但它确实有助于理解所有分析工具通用的基本术语。

• 侧写员。一个向您展示应用在 Java 虚拟机(JVM)中运行时的行为的工具。
• 仪器仪表。将分析方法(计数器、计时器等)插入到应用的 Java 字节码中。这些方法不会改变程序的逻辑，并且会在分析停止时被移除。
• 剖析开销。执行分析方法而不是应用代码所花费的时间。
• 堆。JVM 为 new 操作符在程序中分配的所有对象使用的内存池。
• 垃圾收集。从内存中移除应用不再使用的对象。JVM 定期执行垃圾收集。
• 内存泄漏。您的应用不再使用的对象，但由于有一个或多个对它的无意引用，它不能被 JVM 垃圾收集。
• 自我时间。执行一个方法中的指令所需的时间。这不包括该方法调用的任何其他方法所花费的时间。
• 热点。一种自身时间相对较长的方法。
• 分析根目录。为性能分析选择的类或方法。
• 呼叫树。从分析根可到达的所有方法。

遥感勘测

遥测任务有助于在应用运行时监控高级统计数据。遥测任务不执行检测，因此启动速度很快，因为它没有强加分析开销。

要使用遥测任务，请右键单击某个应用，然后选择配置文件。在“配置和启动性能分析”窗口中，单击“配置会话”按钮，然后选择“遥测”。单击个人资料。或者，您可以通过主菜单栏中的“配置文件➤附加”菜单项附加到已经运行的进程。分析会话开始。

遥测窗口打开，如图 9-3 所示。

图 9-3。

Telemetry window

遥测任务显示应用的基本信息:

• 分配的堆内存
• 正在使用的堆内存
• 花费在垃圾收集上的时间百分比
• 正在运行的线程和类的数量

遥测窗口还显示堆上幸存的代。有关幸存代的说明，请参考下面的“了解幸存代”一节。

了解幸存的几代

为了理解幸存的几代，考虑一下 JVM 的垃圾收集过程。每次垃圾收集器运行时，每个对象要么存活下来并继续占用堆内存，要么被移除并释放其内存。如果一个对象存活下来，它的年龄增加 1。换句话说，对象的年龄就是它存活下来的垃圾收集次数。幸存代的值是不同对象的年龄数。

例如，假设有几个对象在应用启动时都被分配了。此外，还有另一组对象是在应用运行的中点分配的。最后，有一些对象刚刚被分配，只经历了一次垃圾收集。如果垃圾收集器已经运行了 80 次，那么第一组中的所有对象的年龄都将是 80；第二组中的所有对象将具有 40 岁的年龄；第三组中的所有对象的年龄都是 1。在这个例子中，存活代的值是 3，因为堆上的所有对象有三个不同的年龄:80、40 和 1。

在大多数 Java 应用中，幸存代的值最终会稳定下来。这是因为应用已经到达了一个所有长期对象都已被分配的点。预期寿命较短的对象不会影响幸存代计数，因为它们最终会被垃圾回收。

如果应用的存活代数值随着应用的运行而不断增加，这可能表明存在内存泄漏。换句话说，随着时间的推移，您的应用将继续分配对象，每个对象都有不同的年龄，因为它经历了不同次数的垃圾收集。如果对象被正确地垃圾收集，不同对象年龄的数量将不会增加。

方法

当您想要获得有关应用中哪些方法使用最多 CPU 时间的详细信息时，请使用 Methods 任务。通过方法任务，您正在分析应用的性能。Methods 任务还会告诉您每个方法被调用了多少次。

您可以分析整个应用的方法性能，也可以只分析部分方法的性能。对于方法任务，所有类和项目类模式使用开销非常低的采样，因此它们是大型应用初始性能分析的理想选择。(对象任务也是如此。)选择分析整个应用意味着所有被调用的方法都将被检测。大量的检测会显著降低性能，因此该选项最好用于较小的应用。另一个因素是，对整个应用进行分析会产生大量的分析信息，您必须解释这些信息。你需要解释的越多，某些东西被误解的可能性就越大。

如果您怀疑应用的某些部分导致了性能问题，那么只分析这些部分可能是最好的方法。如果选择只分析应用的一部分，则必须选择一个或多个分析根。

查看实时结果

要使用“方法”任务，请右键单击应用，然后选择“配置文件”。在“配置和启动性能分析”窗口中，单击“配置会话”按钮，然后选择“方法”。单击个人资料。或者，您可以通过主菜单栏中的“配置文件➤附加”菜单项附加到已经运行的进程。分析会话开始。

方法窗口打开，如图 9-4 所示。

图 9-4。

Methods window

该窗口显示至少调用过一次的所有方法。默认的排序顺序是按自己的时间降序排列。应用中使用时间最多的方法显示在列表的顶部。所用时间显示在两列中，一列用图形显示每种方法所用时间的百分比，另一列用文本显示原始时间值和百分比。调用次数也显示在 Hits 列中。随着应用的运行，探查器将更新这些值。

要更改排序顺序，请单击列标题。这将使用列中的值对表进行降序排序。再次单击以升序排序。单击工具栏中的 Hot Spots 按钮，该列将按照包、类和方法名对表进行排序。

要更快地找到特定方法，请在窗口中右键单击，然后选择筛选或查找。输入方法名称，然后按 Enter 键。该窗口显示符合您的标准的项目。

拍摄结果快照

要查看更详细的信息，请选择配置文件➤获取收集结果的快照(Alt+F2)。将显示 CPU 快照窗口，快照的时间作为其标题。

CPU 快照窗口打开，如图 9-5 所示。

图 9-5。

CPU Snapshot window

“CPU 快照”窗口显示按线程组织的调用树。要切换到热点视图，请点按工具栏中的“热点”按钮。

当您单击选项卡右上角的信息图标时，您将看到一个窗口，显示快照信息的摘要:日期、时间、过滤器设置等。快照窗口顶部的图标允许您保存快照、控制快照的粒度(方法、类或包)以及搜索快照。

目标

使用 Objects 任务跟踪应用使用的堆内存。如果 JVM 在运行您的应用时报告了一个OutOfMemoryError，分析器可以帮助您确定问题的原因。

查看实时结果

要使用对象任务，请右键单击应用，然后选择配置文件。在“配置和启动性能分析”窗口中，单击“配置会话”按钮，然后选择“对象”。单击个人资料。或者，您可以通过主菜单栏中的“配置文件➤附加”菜单项附加到已经运行的进程。分析会话开始。

对象窗口打开，如图 9-6 所示。

图 9-6。

Objects window

显示的列如下:

• 分配的对象。探查器正在跟踪的对象数。默认情况下，这个数字大约是应用实际分配的对象的 10%。使用 Profiler 工具栏中的“限制分配深度”复选框来更改默认值。通过只监视所创建对象的一个子集，分析器可以极大地减少 JVM 上的开销，从而使应用以接近全速的速度运行。
• 活的物体。当前在堆上并因此占用内存的已分配对象的数量。
• 活字节。活动对象使用的堆内存量。
• 平均值。年龄。活体的平均年龄。每个对象的年龄是它存活下来的垃圾收集次数。年龄的总和除以活动对象的数量就是平均值。年龄。
• 使用活体计算的世代。一个对象的年龄是它经历的垃圾收集的次数。世代值是活动对象不同年龄的数量。有关幸存代的详细信息，请参见本主题前面的部分。

要更改排序顺序，请单击列标题。这将使用列中的值对表进行降序排序。再次单击以升序排序。按代对表进行排序通常有助于识别导致内存泄漏的类。这是因为世代值的增加通常表示内存泄漏。

拍摄结果快照

为了查看应用中的哪些方法正在分配对象，您必须拍摄快照。您还可以相互比较快照，以确定差异和其他感兴趣的方面。

使用配置文件➤获取收集结果的快照(Alt+F2)。将显示 CPU 快照窗口，快照的时间作为其标题。

图 9-7。

CPU Snaphot window

线

Threads 任务对于在应用运行时监视每个线程的状态非常有用。

要监视线程，请右键单击某个应用，然后选择“配置文件”。在“配置并启动性能分析”窗口中，单击“配置会话”按钮，然后选择“线程”。单击个人资料。或者，您可以通过主菜单栏中的“配置文件➤附加”菜单项附加到已经运行的进程。分析会话开始。

螺纹窗口如图 9-8 所示。

图 9-8。

The Threads window

螺纹以下列颜色编码显示:

• 绿色。线程正在运行或准备运行。
• 紫色。线程正在Thread.sleep()中休眠。
• 黄色。线程正在等待对Object.wait()的调用。
• 红色。尝试进入同步方法或块时，线程被阻止。

您可以使用显示颜色的列下方的滚动条来滚动时间，并检查从应用启动时开始的线程状态。点按工具栏中的“放大”和“缩小”按钮，以控制“线程”窗口中显示的细节级别。

锁定争用

当一个线程试图获取一个锁，而另一个线程持有它，迫使它等待时，就会发生锁争用。

锁争用会扼杀您通过并行使用多个内核可能获得的任何性能提升，因为您是通过使用锁来按顺序组织工作的。在最坏的情况下，只有一个线程会运行。

“锁争用”窗口显示关于锁争用的详细信息。它显示了对性能瓶颈的分析，这可以帮助您确定负责的线程。

要识别锁争用，请右键单击某个应用，然后选择“配置文件”。在“配置和启动性能分析”窗口中，单击“配置会话”按钮，然后选择“锁定争用”。单击个人资料。或者，您可以通过主菜单栏中的“配置文件➤附加”菜单项附加到已经运行的进程。分析会话开始。

锁竞争窗口如图 9-9 所示。

图 9-9。

Lock Contention window

图 9-9 中显示的锁争用分析适用于 Java 教程 docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html 中在此 URL 讨论的死锁示例。

将探查器附加到外部进程

NetBeans Profiler 可以分析不是由 IDE 启动的应用。换句话说，它可以附加到一个 JVM 上。要使用此功能，请选择“配置文件➤附加到外部进程”,然后在“配置文件外部进程”中单击“附加”。附加设置窗口打开，如图 9-10 所示。

图 9-10。

The Attach Settings window

“附加设置”窗口允许您选择正在运行的应用进行性能分析。或者，您可以在本地或远程将分析器附加到手动启动的 Java 进程。

Apache JMeter 入门

Java EE 应用环境中最成问题的性能问题之一是用户容量。多少用户可以同时访问应用？在开发环境中，这个问题是不可能回答的，因为有太多的变量在起作用。即使开发环境的配置方式与生产环境完全相同，生产环境和开发环境之间也几乎总是会出现不一致。通常情况下，用户能力测试会变成一场碰运气的游戏。

Apache JMeter 工具( jmeter。阿帕奇。org )在这种情况下会有所帮助。Apache JMeter 是一个测量性能和负载测试的 Java 应用。IDE 可以很好地与 Apache JMeter 集成，一旦安装了 Apache JMeter 插件，就不需要安装 Apache JMeter，也不需要手动打开它。

要在 IDE 中开始使用 Apache JMeter，进入工具➤插件并安装插件，如图 9-11 所示。

图 9-11。

Installingthe Apache JMeter plugin

使用 Apache JMeter

一旦在 IDE 中安装了 Apache JMeter 插件，使用新的文件窗口(Ctrl+N)来创建 JMeter 计划，如图 9-12 所示。

图 9-12。

JMeter Plan in the New File window

要将 JMeter 测试作为构建的一部分来运行，您可以使用这里显示的 XML 条目在 POM 中注册 Maven JMeter 插件( jmeter.lazerycode.com )。

<build>

<plugins>

<plugin>

<groupId>com.lazerycode.jmeter</groupId>

<artifactId>jmeter-maven-plugin</artifactId>

<version>1.10.1</version>

<executions>

<execution>

<id>jmeter-tests</id>

<phase>verify</phase>

<goals>

<goal>jmeter</goal>

</goals>

</execution>

</executions>

</plugin>

</plugins>

</buil d>

请注意，Maven JMeter 插件希望您的 JMeter 计划位于src/test/jmeter文件夹中。在 IDE 中，你可以右击 JMeter 计划来运行它们或者打开 Apache JMeter 进行编辑，如图 9-13 所示。当您为 Apache JMeter 安装 NetBeans 插件时，会自动安装 Apache JMeter。

图 9-13。

Menu items for editing and running JMeter plans

您可以在不启动 Apache JMeter 的情况下执行 JMeter 计划的基本编辑。只需点击属性，这是列表中的最后一个菜单项，如图 9-13 所示。这将打开一个属性窗口，您可以在其中更改基本设置，如用户数量和目标服务器。

十、版本控制

像 Git 这样的版本控制系统看起来像编程语言一样复杂。将 Git 集成到 NetBeans 中降低了复杂性，因此程序员和我的学生可以完成这项工作。—Ken Fogel，加拿大道森学院计算机科学技术系主任

使用版本控制系统(VCS)来共享您的项目并整合来自多个开发人员的贡献是在团队开发环境中工作的最重要的部分之一。在 NetBeans IDE 中，版本控制功能已集成到您的日常工作流程中，因此您不必一直切换到命令行或外部工具来执行更新和提交本地更改。

您可以选择仅共享您的源代码，或者共享您正在使用的完整 NetBeans 项目。当您将 NetBeans 项目(即 NetBeans 元数据)签入存储库时，在 IDE 中处理该项目的其他开发人员就不必自己设置项目了。他们只需检查项目并立即开始工作。

IDE 中的版本控制支持提供了:

• IDE 中版本状态的显示。
• 能够在 IDE 中对文件运行版本控制命令。
• 帮助您将变更签入到存储库中并在分支之间进行合并的工具。
• 用于搜索文件版本历史和查看文件修订之间差异的高级工具。

IDE 为 Git ( git-scm.com )提供了最全面的支持，Git 是目前最流行、最广泛使用的版本控制系统。它对 Mercurial 和 Subversion 的支持与其对 Git 的支持不相上下，而 CVS、ClearCase 和 Perforce 都有插件。本章的重点是 Git，但是如果您使用的是 Mercurial、Subversion、CVS、ClearCase 或 Perforce，在大多数情况下这里描述的命令和设置是相似的。

Git 是一个免费的开源分布式版本控制系统，旨在快速高效地处理从小型到大型的项目。每一个 Git 克隆都是一个成熟的存储库，具有完整的历史和完整的版本跟踪功能，不依赖于网络访问或中央服务器。分支和合并既快速又容易，Git 用于文件以及文件夹和文件组的版本控制，例如 NetBeans 项目。

在 IDE 中设置 Git

使用 Git 中的文件不需要任何设置。不需要安装额外的插件，尽管 Git 工具栏插件在提供对常用 Git 操作的访问时非常有用: plugins.netbeans.org/plugin/51604/git-toolbar 。

每当您访问 Git 存储库中的文件时，IDE 都会为文件提供完整的 Git 命令和状态显示。您可以通过右键单击项目并选择 Git 来判断目录或项目是否在 Git 工作目录中。Git 存储库中的项目还会在项目名称旁边显示一个蓝色的存储库图标。

IDE 可以帮助您完成使用 Git 库的每一步。然而，假设您已经在某个地方创建了一个实际的 Git 存储库，比如在 GitHub ( github.com )。一旦您创建了一个 Git 存储库——在 GitHub 等互联网上或本地——您就可以按照下面的说明开始了。

初始化 Git 存储库

要从不在源代码控制中的现有文件初始化 Git 存储库，您需要转到“项目”窗口，选择一个未版本化的项目，并右键单击项目名称。在右键弹出菜单中选择版本控制➤初始化 Git 库，如图 10-1 所示。

图 10-1。

Initializing a Git repository

或者，在主菜单中，选择团队➤ Git ➤初始化。

指定要存储版本化文件的存储库的路径。您可以使用“初始化 Git 存储库”窗口或单击“浏览”,然后浏览所需的目录来完成此操作。

在您指定的文件夹中会创建一个.git子文件夹，默认情况下，该文件夹是您的 NetBeans 项目文件夹。这是您的本地 Git 存储库，其中存储了您的项目快照的所有数据。Git 开始对您指定的文件夹中的所有文件进行版本控制。您可以打开➤输出➤输出窗口，查看 IDE 在您本地工作目录下创建库的进度报告，如图 10-2 所示。

图 10-2。

Output window showing initialization process

所有项目文件都被标记为已添加到您的工作树中。要查看文件的状态，请将光标放在“项目”窗口中的文件名上。在工具提示中，工作树中文件的状态以绿色显示在斜杠的右侧，如图 10-3 所示。

图 10-3。

Versioning status in tooltip

在初始化 Git 存储库之后，您可以添加文件或者直接将它们提交给 Git 存储库。

克隆 Git 存储库

要获得一个已经存在的 Git 存储库的副本，比如在 GitHub 上，您需要“克隆”它。在执行帮助您在 IDE 中完成克隆存储库向导的后续步骤之前，请确保您知道 Git 存储库的 URL。

此外，在执行下一步操作时，请确保没有在 IDE 中打开版本控制项目，因为 IDE 是上下文相关的，如果当前选择了版本控制项目，IDE 将假定您要对该项目执行版本控制任务。因此，如果在“项目”窗口中未选择任何版本化项目，请从主菜单中选择“➤团队 Git ➤克隆”。克隆存储库向导打开，如图 10-4 所示。

图 10-4。

Clone Repository wizard

在存储库步骤中，指定 Git 存储库位置的路径、用户名和密码(如果需要，可以保存它们以备将来使用)。或者，单击代理配置以显示选项窗口并设置代理服务器设置。完成后，点按“好”。单击“下一步”转到向导的下一步。

在“远程分支”页面中，选择要提取(下载)到本地存储库的存储库分支。单击下一步。

在“目标目录”页面中，指定以下内容:

• 在“父目录”字段中，指定硬盘上用于克隆存储库的目录的路径(或者，单击“浏览”按钮并导航到该目录)。“父目录”字段中填充了默认NetBeansProjects目录的路径，所有 NetBeans 项目都存储在该目录中。
• 在“克隆名称”字段中，指定将在其中克隆原始项目的本地文件夹的名称。默认情况下，克隆名称由 Git 存储库名称填充。
• 在“检出分支”字段中，选择要检出到工作树中的分支。
• 在“远程名称”字段中，表示要克隆的原始存储库的名称。origin是正在克隆的存储库的默认别名。这是推荐值。
• 保持选中“克隆后扫描 NetBeans 项目”复选框，以便在克隆完成后立即激活后扫描。这将允许在克隆的资源中搜索 NetBeans 项目，IDE 将提供打开找到的项目。

单击完成。在 Git 存储库被克隆之后，元数据.git文件夹被创建在您在向导中选择的文件夹中。

向 Git 存储库添加文件

要开始跟踪一个新文件，并将更改转移到 Git 存储库中已经跟踪的文件，您需要将它添加到 Git 存储库中。当向 Git 存储库添加文件时，IDE 首先在索引中合成并保存项目的快照。执行提交后，IDE 会将这些快照保存在本地 Git 存储库中的文件头中。

IDE 允许您在两个工作流之间进行选择，如下所述。

• 向索引中显式添加新的或修改过的文件，然后只将那些存放在索引中的文件提交到文件头。为此，请打开“项目”窗口，右键单击要添加的文件。在上下文菜单中，选择 Git ➤添加。这将在提交文件之前将文件内容添加到索引中。在“项目”窗口中，右键单击要提交的文件。在提交窗口中，选择头和索引之间的变化切换按钮。这将显示已经转移的文件列表。提交文件，如下面的“将源代码提交到存储库”一节所述。
• 跳过向索引添加新的或修改过的文件，将所需的文件直接提交到文件头。要开始这样做，请打开“项目”窗口，右键单击要提交的文件。在上下文菜单中，选择 Git ➤提交。在提交窗口中，选择选择索引和工作树之间的更改切换按钮。这将显示未转移的文件列表。提交文件，如下面的“将源代码提交到存储库”一节所述。

文件在文件头中的状态以绿色显示在斜线的左侧，如本章前面的图 10-3 所示。

如果在文件夹上调用该操作，并且遵循 NetBeans IDE 平面文件夹内容结构，则该操作将以递归方式工作。

编辑文件

一旦在 IDE 中打开了 Git 版本的项目，就可以开始对源代码进行更改了。与在 NetBeans IDE 中打开的任何项目一样，当文件出现在 IDE 的窗口中时，可以通过双击其节点在源代码编辑器中打开文件，例如，“项目”(Ctrl+1)、“文件”(Ctrl+2)和“收藏夹”(Ctrl+3)窗口。

在 IDE 中处理源文件时，您可以使用各种 UI 组件来帮助查看和操作版本控制命令。现在我们将探讨这些方面——在源代码编辑器中查看更改、查看文件状态信息、比较文件修订以及恢复更改。

在源代码编辑器中查看更改

当您在 IDE 的源代码编辑器中打开受版本控制的文件时，您可以查看根据 Git 存储库中的基本版本修改文件时发生的实时更改。工作时，IDE 会在源代码编辑器的边距中使用颜色编码来传达以下信息:

• 蓝色:表示自早期版本以来已更改的行。
• 绿色:表示自早期版本以来添加的行。
• 红色:表示自早期版本以来已删除的行。

源代码编辑器的左边显示了逐行发生的更改。当你修改一个给定的行时，修改会立即显示在左边的空白处，如图 10-5 所示。

图 10-5。

Left margin shows changes

您可以单击空白处的颜色分组，以使版本控制命令可用。例如，在图 10-6 中，当点击蓝色图标时，您会看到可用的版本控制按钮，这表示行已经从您的本地副本被更改。

图 10-6。

Versioning commands for a color grouping

源代码编辑器的右边为您提供了一个概览，从上到下显示了对文件所做的整体更改，如图 10-7 所示。当您对文件进行更改时，会立即生成颜色编码。

图 10-7。

Right margin shows overview

您可以单击页边距中的特定点，将行内光标立即带到文件中的该位置。要查看受影响的行数，请将鼠标悬停在右边的彩色图标上。

查看文件状态信息

当您在“项目”( Ctrl+1)、“文件”( Ctrl+2)、“收藏夹”( Ctrl+3)或“版本控制”视图中工作时，IDE 提供了多种可视化功能来帮助您查看文件的状态信息。在图 10-8 中，请注意徽章(即扩展包上的蓝色图标徽章)和文件名的颜色是如何重合的，这为您提供了一种简单而有效的方法来跟踪文件的版本信息。

图 10-8。

Viewing file status information

再次在图 10-8 中，注意已添加或更改的文件名后的灰色草书文本。这些标签称为“文件状态标签”，如果您从主菜单中选择“查看➤”“显示版本控制标签”，它们将显示在添加或更改的文件旁边。

徽章、颜色编码、文件状态标签，以及最重要的 Git Diff Viewer，这些都有助于您在 IDE 中有效地查看和管理版本信息。

徽章和颜色编码

徽章应用于项目、文件夹和包节点，并通知您该节点中包含的文件的状态。

下面的列表显示了用于徽章的配色方案。

• 蓝色标记:表示工作树中存在已被修改、添加或删除的文件。对于包，这个标记只适用于包本身，而不适用于它的子包。对于项目或文件夹，徽章表示该项目或任何包含的子文件夹中的更改。
• 红色标记:标记包含冲突文件的项目、文件夹或包。对于包，这个标记只适用于包本身，而不适用于它的子包。对于项目或文件夹，该标记指示该项目或任何包含的子文件夹中的冲突。对文件名进行颜色编码，以表明它们在存储库中的当前状态。
• 黑色:表示文件没有更改。
• 蓝色:表示文件已被本地修改。
• 绿色:表示文件已在本地添加。
• 红色:表示文件存在合并冲突。
• 灰色:表示文件被 Git 忽略，不会包含在版本控制命令中(例如，更新和提交)。如果文件有版本，则不能忽略它们。

文件状态标签

IDE 可以通过“文件状态标签”显示文件的两个状态值。通过从主菜单中选择查看➤显示版本控制标签，可以打开和关闭文件状态标签。

这些是 IDE 提供的文件状态标签:

• 描述文件的工作树和索引状态之间差异的状态。
• 描述文件索引状态和当前头提交之间差异的状态。

文件状态标签提供了 ide 窗口中版本化文件状态的文本指示:

• 答:已添加
• u:已更新但未合并
• 男:修改
• d:删除
• I:忽略
• r:已重命名

IDE 在文件右侧以灰色文本显示状态(新建、修改、忽略等)和文件夹信息，如图 10-9 所示。

图 10-9。

File status labels

合并冲突中的文件具有未合并状态，通常用红色标注，直到文件未被您的显式操作解决。未合并文件的状态标签取决于方案(例如，A/A 未合并，两者均已添加)。

Git 版本视图

Git Versioning 视图为您提供了对本地工作树的选定文件夹中的文件所做的所有更改的实时列表。默认情况下，它在 IDE 的底部面板中打开，列出添加、删除或修改的文件。

要打开“版本控制”视图，请选择一个版本控制文件或文件夹(例如从“项目”、“文件”或“收藏夹”窗口中)，然后从右键菜单中选择“➤显示更改”或从主菜单中选择“➤团队显示更改”。图 10-10 所示的窗口出现在 IDE 的底部。

图 10-10。

Git Versioning view

默认情况下，版本控制视图显示工作树中所选包或文件夹内所有已修改文件的列表。使用工具栏中的按钮，您可以选择显示索引和文件头之间、工作树和索引之间或工作树和文件头之间有差异的文件列表。您也可以单击所列文件上方的列标题，按名称、状态或位置对文件进行排序。

版本控制视图工具栏还包括一些按钮，使您能够对列表中显示的所有文件调用最常见的 Git 任务。您可以在 Versioning 视图中访问其他 Git 命令，方法是选择一个对应于已修改文件的表格行，然后从右键菜单中选择一个命令。

比较文件修订

使用版本化项目时，比较文件版本是一项常见任务。IDE 允许您使用 Diff 命令来比较修订。IDE 中提供了几种比较模式——比较到磁头、比较到跟踪和比较到。

选择受版本控制的文件或文件夹(例如从“项目”、“文件”或“收藏夹”窗口中)。从主菜单中选择➤队➤队队长。在 IDE 的主窗口中，会为所选文件和修订打开一个图形化的比较查看器，如图 10-11 所示。

图 10-11。

Diff window

比较查看器在并排的面板中显示两个副本。更新的副本出现在右侧，因此如果您将存储库修订与您的工作树进行比较，工作树会显示在右侧面板中。比较查看器使用与其他地方相同的颜色编码来显示版本控制更改。在图 10-11 中，绿色块表示已经添加到最新版本中的内容。红色块表示早期版本中的内容已从较新版本中删除。蓝色表示突出显示的行中发生了变化。其他修订可以从比较查看器工具栏下面的比较和来源下拉列表中选择。

比较查看器工具栏还包括一些按钮，使您能够对列表中显示的所有文件调用最常见的 Git 任务。

如果在工作树中对本地副本执行比较，IDE 允许您直接从比较查看器中进行更改。为此，您可以将光标放在比较查看器的右窗格中，并相应地修改您的文件，也可以使用显示在每个突出显示的更改旁边的内嵌图标。当您在右侧滚动时，左侧编辑器将滚动，以便您可以看到在比较中所做的更改。

还原更改

要丢弃对工作树中选定文件所做的本地更改，并用索引或文件头中的文件替换它们，请选择一个版本化文件或文件夹(例如从“项目”、“文件”或“收藏夹”窗口中)。从主菜单中选择团队➤恢复修改。恢复修改窗口打开，如图 10-12 所示。

图 10-12。

Reverting changes

指定附加选项(如仅将索引中未提交的更改还原到 HEAD)。单击还原。

IDE 会用您指定的文件替换选定的文件。

将源代码提交给存储库

要将文件提交到 Git 存储库，请在“项目”窗口中，右键单击要提交的文件。在上下文菜单中，选择 Git ➤提交。提交窗口打开，如图 10-13 所示。

图 10-13。

Commit window

提交窗口包含以下字段:

• 提交消息:用于描述正在提交的更改的文本区域。
• 作者和提交者:下拉列表，让您区分谁进行了更改和谁实际提交了文件。
• 要提交的文件:列出所有修改过的文件、所有已经从工作树中删除的文件(本地)、所有新文件(Git 存储库中尚不存在的文件)以及所有已经重命名的文件。这里有两个切换按钮，用于切换实际提交的执行模式。头和索引之间的变化显示转移的文件列表。标题和工作树之间的更改显示已暂存或已修改/创建但尚未暂存的文件列表。要在此指定是否从提交中排除单个文件，请取消选中第一列“提交”中的复选框，或者右键单击“提交操作”列中的文件行，然后从弹出菜单中选择“从提交中排除”。要在此显示比较查看器，请右键单击“提交操作”列中的文件行，然后从弹出菜单中选择“比较”。
• 更新问题:用于跟踪与提交的变更相关的问题的部分。您需要安装 JIRA 或 Subversion 插件来开始在 IDE 中跟踪问题。

在提交消息文本区域中键入提交消息。或者，您可以执行以下操作:

• 单击位于右上角的“最近的消息”图标，查看并选择您以前使用过的消息列表。
• 单击位于右上角的加载模板图标，选择一个消息模板。

为单个文件指定操作后，单击提交。

IDE 将执行提交，并将您的快照存储到存储库中。IDE 的状态栏位于界面的右下角，在提交操作发生时显示。成功提交后,“项目”、“文件”和“收藏夹”窗口中的版本标记消失，已提交文件的颜色代码恢复为黑色。

使用分支

IDE 的 Git 支持使您能够通过使用分支来维护整个代码库的不同版本。

在 IDE 中处理分支时，可以创建、签出、合并和删除分支。在接下来的几节中，我们将研究每一个 Git 术语，并学习如何在 IDE 中执行这些操作。

创造

要创建本地分支，如果出于稳定或试验的目的，您想在不干扰主干的情况下使用文件系统的单独版本，请在“项目”或“文件”窗口中，从要在其中创建分支的存储库中选择一个项目或文件夹。

在主菜单中，选择团队➤分支/标签➤创建分支。另一种方法是，右键单击受版本控制的项目或文件夹，然后在弹出菜单中选择“Git ➤分支/Tag ➤创建分支”。创建分支窗口打开，如图 10-14 所示。

图 10-14。

Create Branch window

在分支名称字段中，输入正在创建的分支的名称。通过在“修订”字段中输入提交 ID、现有分支或标记名称，键入选定项目的特定修订，或者单击“选择”查看存储库中维护的修订列表。或者，在“选择版本”窗口中，展开分支并选择所需的分支，在相邻的列表中指定提交 ID，然后单击选择。查看特定于分支版本的提交 ID、作者和消息字段，然后单击创建。

该分支被添加到 Git 资源库的 Branches/Local 文件夹中，可以在 Git 资源库浏览器中看到，如图 10-15 所示。

图 10-15。

Git Repository Browser

您可以通过右键单击 Git 版本化项目并选择 Git ➤存储库➤浏览器来打开 Git 存储库浏览器。

退房

如果您需要编辑已经存在的分支上的文件，您可以检出该分支，将文件复制到您的工作树中。要签出修订，请从主菜单中选择团队➤签出➤签出修订。“签出所选版本”窗口打开，如图 10-16 所示。

图 10-16。

Checkout Selected Revision window

通过在“修订”字段中输入提交 ID、现有分支或标记名来指定所需的修订，或者单击“选择”来查看存储库中维护的修订列表。如果在上一步中没有单击选择，请跳过。在“选择修订”窗口中，展开分支并选择所需的分支，如果需要，在相邻的列表中指定提交 ID，然后单击选择。如果指定的修订引用了一个没有用分支名称标记的有效提交，那么您的头将被分离，并且您不再位于任何分支上。查看特定于所签出版本的提交 ID、作者和消息字段。要从已签出的版本创建新分支，请选择“签出为新分支”选项，并在“分支名称”字段中输入名称。单击“检出”以检出修订。

工作树和索引中的文件被更新以匹配指定修订中的版本。

合并

要将修改从存储库版本移植到工作树，请从主菜单中选择团队➤分支/标签➤合并版本。合并修订窗口打开，如图 10-17 所示。

图 10-17。

Merge Revision window

通过在“修订”字段中输入提交 ID、现有分支或标记名来指定所需的修订，或者单击“选择”来查看存储库中维护的修订列表。

如果在上一步中没有单击选择，请跳过此步骤。在“选择修订”窗口中，展开分支并选择所需的分支，如果需要，在相邻的列表中指定提交 ID，然后单击选择。单击合并。完成当前分支、工作树内容和指定分支之间的三向合并。如果发生合并冲突，冲突文件会用红色标记来表示。合并后，您仍然必须提交更改，以便将它们添加到头中。

如果自从创建特征分支以来主分支已经分叉，则将特征分支合并到主分支将创建合并提交。这是典型的合并。如果主节点没有分叉，Git 不会创建新的提交，而是将主节点指向特性分支的最新提交。这是一种“快进”。传递--no-ff会创建一个新的提交来表示合并，即使 Git 通常会快进。在以下网址可以找到有用的相关解释: 365git.tumblr.com/post/504140728/fast-forward-merge 。

删除

要删除不必要的本地分支，请从主菜单中选择团队➤存储库浏览器。在 Git 存储库浏览器中，选择要删除的分支。该分支必须是非活动的，也就是说，当前没有检出到工作树中。

右键单击选定的分支，并从弹出菜单中选择“删除分支”。在“删除分支”窗口中，单击“确定”确认分支删除。

该分支从本地存储库中删除，这反映在 Git 存储库浏览器中。

使用远程存储库

当您与其他开发人员一起工作时，您需要共享您的工作，这涉及到从 Internet 或内部网络上托管的远程存储库获取、推送和提取数据。

在接下来的几节中，我们将研究每一个 Git 术语，并学习如何在 IDE 中执行这些操作。

迷人的

获取从原始远程存储库中获取您还没有的更改。它永远不会改变您的任何本地分支。获取从远程存储库中获取所有分支，您可以在任何时候将它们合并到您的分支中或者进行检查。

要获取更新，首先选择团队➤远程➤获取。从远程存储库提取向导打开，如图 10-18 所示。

图 10-18。

Fetch from Remote Repository wizard

在向导的“远程存储库”步骤中，选择“选择已配置的 Git 存储库位置”选项(使用之前配置的存储库的路径)或“指定 Git 存储库位置”选项(定义尚未访问的远程存储库的路径、其名称、登录名、密码和代理配置，如果需要)。单击下一步。在向导的远程分支步骤中，选择要从中提取更改的分支，然后单击 Finish。

创建远程分支的本地副本。所选分支在 Git 存储库浏览器的分支➤远程目录中更新。接下来，可以将获取的更新合并到本地分支中。

拉

当从远程 Git 存储库中提取更新时，将从其中提取更改并合并到本地存储库的当前头中。要执行拉动，选择团队➤远程➤拉。“从远程存储库拉”向导打开，如图 10-19 所示。

图 10-19。

Pull from Remote Repository wizard

在向导的“远程存储库”步骤中，选择“选择已配置的 Git 存储库位置”选项(使用您之前配置的存储库的路径)或“指定 Git 存储库位置”选项(定义尚未访问的远程存储库的路径、其名称以及登录名和密码，如果需要)。单击下一步。在向导的“远程分支”页面中，选择将从中提取更改的分支，然后单击“完成”。

您的本地存储库与原始存储库同步。

推

当您要将您的提交推送到一个存储库中时，同时可能已经推送了一些其他的变更，您需要首先拉取并合并那些变更。

要将本地 Git 存储库中的更改贡献给公共 Git 存储库，请选择 Team ➤远程➤推送。Push to Remote Repository 向导打开，如图 10-20 所示。

图 10-20。

Push to Remote Repository wizard

在向导的“远程存储库”步骤中，选择“选择已配置的 Git 存储库位置”选项(使用您之前配置的存储库的路径)或“指定 Git 存储库位置”选项(定义尚未访问的远程存储库的路径、其名称以及登录名和密码，如果需要)。单击下一步。在“选择本地分支”页面中，选择要将编辑内容推送至的分支，然后单击“下一步”。在“更新本地引用”页面中，选择要在本地存储库的 Remotes 目录中更新的分支。单击完成。

指定的远程资料库分支将使用本地分支的最新状态进行更新。