netbeans.apache.org/src/content/kb/docs/java/hibernate-java-se_zh_CN.asciidoc

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

= 在 Java Swing 应用程序中使用 Hibernate
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: 在 Java Swing 应用程序中使用 Hibernate - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, 在 Java Swing 应用程序中使用 Hibernate

在本教程中，使用 NetBeans IDE 来创建和部署显示数据库中数据的 Java Swing 应用程序。该应用程序使用 Hibernate 框架作为持久层来检索关系数据库中的 POJO (plain old Java object) 对象。

Hibernate 是一个为对象关系映射 (ORM) 提供工具的框架。本教程将演示 IDE 提供的 Hibernate 框架支持，以及如何使用向导创建必要的 Hibernate 文件。创建 Java 对象并将应用程序配置为使用 Hibernate 后，您将创建一个 GUI 界面，用于搜索并显示数据。

您在本教程中构建的应用程序是针对 link:../web/hibernate-webapp.html[+DVD Store Web 应用程序+]的配套管理应用程序。本教程创建的应用程序允许您根据演员的姓名来查询他们的简介信息。如果愿意，您可以扩展应用程序，添加查询影片详细信息和添加/更新/删除项目的功能。本教程使用 MySQL 和 Sakila 数据库，但是您可以使用任何支持 Hibernate 应用程序的数据库服务器。Sakila 数据库是一个样例数据库，您可以从 MySQL 站点下载它。以下部分提供了用于建立 Sakila DB 的信息。

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

* link:http://www.hibernate.org/[+hibernate.org+] 上的 Hibernate 文档。
* link:gui-functionality.html[+构建 GUI 应用程序简介+]
* link:../ide/mysql.html[+连接 MySQL 数据库+]教程。

要使用 Maven 构建此应用程序，请参见link:maven-hib-java-se.html[+使用 Hibernate 创建 Maven Swing 应用程序+]。


image::images/netbeans-stamp-80-74-73.png[title="此页上的内容适用于 NetBeans IDE 7.2、7.3、7.4 和 8.0"]


*要学习本教程，您需要具备以下软件和资源。*

|===
|软件或资源 |要求的版本 

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |7.2、7.3、7.4、8.0、Java 

|link:http://java.sun.com/javase/downloads/index.jsp[+Java 开发工具包 (JDK)+] |版本 7 或 8 

|link:http://www.mysql.com/[+MySQL 数据库服务器+] |版本 5.x 

|Sakila 数据库 |更新中心上可用的插件 
|===

您可以下载link:https://netbeans.org/projects/samples/downloads/download/Samples/Java/DVDStoreAdmin-Ant.zip[+已完成项目的 zip 档案文件+]。


== 创建数据库

本教程使用名为  ``sakila``  的 MySQL 数据库。当您安装 IDE 时，样例数据库并未包括在内，因此您需要先创建数据库才能完成本教程。

Sakila 数据库是一个免费的样例 MySQL 数据库，可从 MySQL 站点获取。要创建 sakila 数据库，可使用 "Plugins"（插件）管理器下载并安装 "Sakila Sample Database"（Sakila 样例数据库）插件。安装好插件之后，您可以在 "Services"（服务）窗口中创建 sakila 数据库。sakila 数据库已添加到 "Create MySQL Database"（创建 MySQL 数据库）对话框的数据库列表中。

有关配置 IDE 使用 MySQL 的详细信息，请参见link:../ide/mysql.html[+连接 MySQL 数据库+]教程。

1. 打开 "Plugins"（插件）管理器，并安装 "Sakila Sample Database"（Sakila 样例数据库）插件。
2. 安装插件之后，启动 MySQL 数据库，方法是在 "Services"（服务）窗口中展开 "Databases"（数据库）节点，右键单击 MySQL 服务器节点并选择 "Start"（启动）。
3. 右键单击 MySQL 服务器节点并选择 "Create Database"（创建数据库）。
4. 在 "Create MySQL Database"（创建 MySQL 数据库）对话框的 "New Database Name"（新数据库名称）下拉列表中选择 "Sakila" 数据库。单击 "OK"（确定）。
image::images/create-sakila-mysql.png[title=""Create MySQL Database"（创建 MySQL 数据库）对话框的屏幕快照"]

单击 "OK"（确定），MySQL 服务器节点下随即出现一个 Sakila 节点。


[start=5]
. 右键单击 "Sakila" 节点，然后选择 "Connect"（连接）。

单击 "Connect"（连接）后，"Databases"（数据库）节点下面将列出 Sakila 数据库连接节点 ( ``jdbc:mysql://localhost:3306/sakila [_username_ on Default]`` )。打开连接时，可通过展开该连接节点查看数据库中数据。


== 创建 Java Swing 应用程序项目

在本练习中，您将创建一个简单的 Java Swing 应用程序项目，名称为 DVDStoreAdmin。

1. 选择 "File"（文件）> "New Project"（新建项目）（Ctrl-Shift-N 组合键）。从 "Java" 类别中选择 "Java Application"（Java 应用程序），然后单击 "Next"（下一步）。
2. 键入 *DVDStoreAdmin* 作为项目名称并设置项目位置。
3. 取消选中 "Use Dedicated Folder"（使用专用文件夹）选项（如果该选项处于选中状态）。
对于本教程，没有理由将项目库复制到指定文件夹，因为您将需要与其他用户共享库。

[start=4]
. 取消选中 "Create Main Class"（创建主类）。单击 "Finish"（完成）。

单击 "Finish"（完成），此时 IDE 将创建 Java 应用程序项目。项目没有设置主类。您将创建一个窗体，然后将该窗体设置为主类。


== 在项目中添加 Hibernate 支持

要在 J2SE 项目中添加 Hibernate 支持，您需要将 Hibernate 库添加到项目中。Hibernate 库包含在 IDE 中，并且可以将它添加到任何项目中，方法是在 "Projects"（项目）窗口中右键单击 "Libraries"（库）节点，选择 "Add Library"（添加库），然后在 "Add Library"（添加库）对话框中选择 Hibernate 库。

IDE 提供的向导可以帮助您创建在项目中需要的 Hibernate 文件。您可以使用 IDE 中的向导来创建 Hibernate 配置文件和实用程序帮助类。如果您使用向导创建了 Hibernate 配置文件，则 IDE 会自动将 Hibernate 库添加到项目中。


=== 创建 Hibernate 配置文件

Hibernate 配置文件 ( ``hibernate.cfg.xml`` ) 包含关数据库连接、资源映射和其他连接属性的信息。在使用向导创建 Hibernate 配置文件时，您可以从 IDE 的注册数据库连接列表中选择数据库连接。生成配置文件时，IDE 会根据所选的数据库连接自动添加连接详细信息和方言信息。该向导还会自动将 Hibernate 库添加到项目类路径中。创建配置文件之后，您可以使用多视图编辑器来编辑文件，也可以直接在 XML 编辑器中编辑 XML 文件。

1. 在 "Projects"（项目）窗口中右键单击 "Source Packages"（源包）节点，并选择 "New"（新建）> "Other"（其他）以打开新建文件向导。
2. 从 "Hibernate" 类别中选择 Hibernate 配置向导。单击 "Next"（下一步）。
3. 保留 "Name and Location"（名称和位置）窗格中的默认设置（您将在  ``src``  目录中创建该文件）。单击 "Next"（下一步）。
4. 在 "Database Connection"（数据库连接）下拉列表中，选择 sakila 连接。单击 "Finish"（完成）。
image::images/hib-config.png[title="用于选择数据库连接的对话框"]

单击 "Finish"（完成），IDE 将在源代码编辑器中打开  ``hibernate.cfg.xml`` 。IDE 将在应用程序的上下文类路径的根目录下创建配置文件（"Files"（文件）窗口中的 WEB-INF/classes）。在 "Projects"（项目）窗口中，该文件位于  ``<default package>``  源包中。配置文件包含关于单一数据库的信息。如果您计划连接到多个数据库，您可以在项目中创建多个配置文件，每个文件用于各自的数据库服务器，但在默认情况下，帮助实用程序类将使用根目录中的  ``hibernate.cfg.xml``  文件。

如果您在 "Projects"（项目）窗口中展开 "Libraries"（库）节点，您可以看到 IDE 已经添加了必需的 Hibernate JAR 文件和 MySQL 连接器 JAR。

image::images/hib-libraries-config.png[title="显示 Hibernate 库的 "Projects"（项目）窗口的屏幕快照"]

*注：*NetBeans IDE 8.0 捆绑了 Hibernate 4 库。旧版本的 IDE 捆绑了 Hibernate 3。


=== 修改 Hibernate 配置文件

在本练习中，您将编辑  ``hibernate.cfg.xml``  中指定的默认属性来启用 SQL 语句的调试日志记录。

1. 在 "Design"（设计）标签中打开  ``hibernate.cfg.xml`` 。可以通过展开 "Projects"（项目）窗口的 "Configuration Files"（配置文件）节点并双击  ``hibernate.cfg.xml``  来打开该文件。
2. 在 "Optional Properties"（可选属性）下，展开 "Configuration Properties"（配置属性）节点。
3. 单击 "Add"（添加）以打开 "Add Hibernate Property"（添加 Hibernate 属性）对话框。
4. 在此对话框中，选择  ``hibernate.show_sql``  属性并将值设置为  ``true`` 。单击 "OK"（确定）。这将启用 SQL 语句的调试日志记录。
image::images/add-property-showsql.png[title="显示 hibernate.show_sql 属性的设置值的 "Add Hibernate Property"（添加 Hibernate 属性）对话框"]

[start=5]
. 单击 "Miscellaneous Properties"（其他属性）节点下的 "Add"（添加），然后选择 "Property Name"（属性名称）下拉列表中的  ``hibernate.query.factory_class`` 。

[start=6]
. 键入 *org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory* 作为属性值。

这是在随 IDE 捆绑提供的 Hibernate 4 中使用的转换器工厂类。

单击 "OK"（确定）。

image::images/add-property-factoryclass-4.png[title="显示 hibernate.query.factory_class 属性的设置值的 "Add Hibernate Property"（添加 Hibernate 属性）对话框"]

如果您使用的是 NetBeans IDE 7.4 或更早版本，则应当在对话框中选择 *org.hibernate.hql.classic.ClassicQueryTranslatorFactory* 作为属性值。NetBeans IDE 7.4 及更早版本捆绑了 Hibernate 3。

image::images/add-property-factoryclass.png[title="显示 hibernate.query.factory_class 属性的设置值的 "Add Hibernate Property"（添加 Hibernate 属性）对话框"]

如果单击编辑器中的 XML 标签，则可以在 XML 视图中看到此文件。该文件应该如下所示：


[source,xml]
----

<hibernate-configuration>
    <session-factory name="session1">
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/sakila</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">######</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.query.factory_class">org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory</property>
    </session-factory>
</hibernate-configuration>
----

[start=7]
. 保存对该文件所做的更改。

创建窗体并将其设置为主类之后，在运行项目时还将看到输出到 IDE 的 "Output"（输出）窗口中的 SQL 查询。


=== 创建  ``HibernateUtil.java``  帮助文件

要使用 Hibernate，您需要创建一个 helper 类，该类处理启动并访问 Hibernate 的  ``SessionFactory``  以获取 "Session"（会话）对象。该类将调用 Hibernate 的  ``configure()``  方法，加载  ``hibernate.cfg.xml``  配置文件，然后构建  ``SessionFactory``  来获取会话对象。

在此部分，使用新建文件向导创建 helper 类  ``HibernateUtil.java`` 。

1. 右键单击 "Source Packages"（源包）节点并选择 "New"（新建）> "Other"（其他），打开新建文件向导。
2. 从 "Categories"（类别）列表中选择 "Hibernate"，从 "File Types"（文件类型）列表中选择 HibernateUtil.java。单击 "Next"（下一步）。
image::images/hib-util.png[title="显示如何创建 HibernateUtil 的新建文件向导"]

[start=3]
. 键入 *HibernateUtil* 作为类名，并键入 *sakila.util* 作为包名。单击 "Finish"（完成）。

单击 "Finish"（完成），此时  ``HibernateUtil.java``  将在编辑器中打开。由于不需要编辑该文件，因此可以关闭该文件。


== 生成 Hibernate 映射文件和 Java 类

在本教程中，您将使用 POJO  ``Actor.java``  表示数据库中的 ACTOR 表的数据。该类为表中的列指定字段并使用简单的 setter 和 getter 检索和编写数据。要将  ``Actor.java``  映射到 ACTOR 表，您可以使用 Hibernate 映射文件或使用类中的注释。

您可以使用逆向工程向导和 "Hibernate Mapping Files and POJOs from a Database"（通过数据库生成 Hibernate 映射文件和 POJO）向导，基于所选的数据库表创建多个 POJO 和映射文件。或者，也可以使用 IDE 中的相应向导帮助您从头创建各个 POJO 和映射文件。

*注：*

* 要为多个表创建文件时，您很可能希望使用这些向导。在本教程中，您只需创建一个 POJO 和一个映射文件，因此单独创建各文件相当简单。本教程的末尾介绍了<<10,单独创建 POJO 和映射文件>>的步骤。


=== 创建逆向工程文件

逆向工程文件 ( ``hibernate.reveng.xml`` ) 是一个 XML 文件，可用于修改通过  ``hibernate.cfg.xml``  中指定的数据库元数据生成 Hibernate 文件时所用的默认设置。向导将使用基本的默认设置生成该文件。您可以修改该文件以明确指定所使用的数据库方案，从而过滤掉不应使用的表，并指定如何将 JDBC 类型映射到 Hibernate 类型。

1. 右键单击 "Source Packages"（源包）节点并选择 "New"（新建）> "Other"（其他），打开新建文件向导。
2. 从 "Categories"（类别）列表中选择 "Hibernate"，然后从 "File Types"（文件类型）列表中选择 Hibernate 逆向工程向导。单击 "Next"（下一步）。
3. 键入 *hibernate.reveng* 作为文件名。
4. 保留默认位置 * ``src`` *。单击 "Next"（下一步）。
5. 在 "Available Tables"（可用表）窗格中选择 *actor*，然后单击 "Add"（添加）。单击 "Finish"（完成）。

该向导将生成  ``hibernate.reveng.xml``  逆向工程文件。可将该逆向工程文件关闭，因为无需对其进行编辑。


=== 通过数据库创建 Hibernate 映射文件和 POJO

"Hibernate Mapping Files and POJOs from a Database"（通过数据库生成 Hibernate 映射文件和 POJO）向导生成基于数据库表的文件。使用该向导时，IDE 将基于  ``hibernate.reveng.xml``  中指定的数据库表生成 POJO 和映射文件，然后将映射条目添加到  ``hibernate.cfg.xml`` 。使用向导时可选择希望 IDE 生成的文件（比如，只生成 POJO）并选择代码生成选项（例如，生成使用 EJB 3 标注的代码）。

1. 在 "Projects"（项目）窗口中右键单击 "Source Packages"（源包）节点，并选择 "New"（新建）> "Other"（其他）以打开新建文件向导。
2. 在 "Hibernate" 类别中选择 "Hibernate Mapping Files and POJOs from a Database"（通过数据库生成 Hibernate 映射文件和 POJO）。单击 "Next"（下一步）。
3. 从 "Hibernate Configuration File"（Hibernate 配置文件）下拉列表中选择  ``hibernate.cfg.xml`` （如果未将其选定）。
4. 从 "Hibernate Reverse Engineering File"（Hibernate 逆向工程文件）下拉列表中选择  ``hibernate.reveng.xml`` （如果未将其选定）。
5. 确保选中了 *Domain Code*（域代码）和 *Hibernate XML Mappings*（Hibernate XML 映射）选项。
6. 键入 *sakila.entity* 作为包名。单击 "Finish"（完成）。
image::images/mapping-pojos-wizard-ant.png[title=""Generate Hibernate Mapping Files and POJOs"（生成 Hibernate 映射文件和 POJO）向导"]

单击 "Finish"（完成），此时 IDE 将生成包含所有必需字段的 POJO  ``Actor.java``  和一个 Hibernate 映射文件，并将映射条目添加到  ``hibernate.cfg.xml`` 。

您已经创建了 POJO 和所需的 Hibernate 相关文件，现在，您可以为应用程序创建一个简单的 Java GUI 前端。您还将创建并添加一个 HQL 查询，用于查询数据库以检索数据。在此过程中，我们还将使用 HQL 编辑器来构建和测试查询。


== 创建应用程序 GUI

在本练习中，您将创建一个简单的 JFrame 窗体，并添加一些字段用于输入和显示数据。您还将添加一个按钮，用于触发检索数据的数据库查询。

如果您不知道如何使用 GUI 构建器创建窗体，可以阅读link:gui-functionality.html[+构建 GUI 应用程序简介+]教程。


=== 创建 JFrame 窗体

1. 在 "Projects"（项目）窗口中右键单击项目节点，然后选择 "New"（新建）> "Other"（其他）以打开新建文件向导。
2. 从 "Swing GUI Forms"（Swing GUI 窗体）类别中选择 "JFrame Form"（JFrame 窗体）。单击 "Next"（下一步）。
3. 键入 *DVDStoreAdmin* 作为类名，并键入 *sakila.ui* 作为包名。单击 "Finish"（完成）。

单击 "Finish"（完成），此时 IDE 将创建类并在编辑器的 "Design"（设计）视图中打开 JFrame 窗体。


=== 在窗体中添加元素

现在，您需要在窗体中添加 UI 元素。在编辑器的 "Design"（设计）视图中打开窗体后，"Palette"（组件面板）将出现在 IDE 的左侧。在窗体中添加元素的方法是将 "Palette"（组件面板）中的元素拖至窗体区域。将元素添加到窗体之后，您需要修改元素 "Variable Name"（变量名称）属性的默认值。

1. 从 "Palette"（组件面板）中拖出一个 "Label"（标签）元素，并将文本更改为 *Actor Profile*。
2. 从 "Palette"（组件面板）中拖出一个 "Label"（标签）元素，并将文本更改为 *First Name*。
3. 拖放一个 "Text Field"（文本字段）元素到 "First Name" 标签旁边，并删除默认文本。
4. 从 "Palette"（组件面板）中拖出一个 "Label"（标签）元素，并将文本更改为 *Last Name*。
5. 拖放一个 "Text Field"（文本字段）元素到 "Last Name" 标签旁边，并删除默认文本。
6. 从 "Palette"（组件面板）中拖出一个 "Button"（按钮）元素，并将文本更改为 *Query*。
7. 从 "Palette"（组件面板）中拖放一个 "Table"（表）元素到窗体中。
8. 根据下表中的值更改以下 UI 元素的 "Variable Name"（变量名称）值。

您可以更改元素的 "Variable Name"（变量名称）值，方法是右键单击 "Design"（设计）视图中的元素并选择 "Change Variable Name"（更改变量名称）。或者，您可以直接在 "Inspector"（检查器）窗口中更改变量名称。

您不需要为 "Label"（标签）元素指定变量名称。

|===
|元素 |变量名称 

|"First Name" 文本字段 | ``firstNameTextField``  

|"Last Name" 文本字段 | ``lastNameTextField``  

|"Query" 按钮 | ``queryButton``  

|表 | ``resultTable``  
|===

[start=9]
. 保存所做的更改。

在 "Design"（设计）视图中，您的窗体应与下图类似。

image::images/hib-jframe-form.png[title="编辑器设计视图中的 GUI 窗体"]

现在，您已经创建了窗体。接下来，您需要创建为窗体元素指定活动的代码。在下一练习中，您将根据 Hibernate 查询语言构建查询来检索数据。构建查询之后，您将在窗体中添加一些方法，用于在单击 "Query" 按钮时调用适当的查询。


== 在 HQL 查询编辑器中创建查询

在 IDE 中，您可以使用 HQL 查询编辑器根据 Hibernate 查询语言来构建和测试查询。键入查询时，编辑器将显示等价的（经过转换的）SQL 查询。单击工具栏中的 "Run HQL Query"（运行 HQL 查询）按钮后，IDE 将执行查询并在编辑器底部显示结果。

在本练习中，您将使用 HQL 编辑器构建简单的 HQL 查询，用于根据姓氏和名字查询演员的详细信息。将查询添加到类中之前，您需要使用 HQL 查询编辑器测试连接运行正常，且查询生成了预期的结果。在运行该查询之前，您首先需要对应用程序进行编译。

1. 右键单击项目节点，然后选择 "Build"（构建）。
2. 展开 "Projects"（项目）窗口中的 <default package> 源包节点。
3. 右键单击  ``hibernate.cfg.xml``  配置文件，然后选择 "Run HQL Query"（运行 HQL 查询）以打开 HQL 编辑器。
4. 通过在 HQL 查询编辑器中键入  ``from Actor``  来测试连接。单击工具栏中的 "Run HQL Query"（运行 HQL 查询）按钮 (image::images/run_hql_query_16.png[title=""Run HQL Query"（运行 HQL 查询）按钮"])。

单击 "Run HQL Query"（运行 HQL 查询）按钮之后，您应该能在 HQL 查询编辑器的底部窗格中看到查询结果。

image::images/hib-query-hqlresults.png[title="显示 HQL 查询结果的 HQL 查询编辑器"]

[start=5]
. 在 HQL 查询编辑器中键入以下查询，然后单击 "Run HQL Query"（运行 HQL 查询）查询搜索字符串为 "PE" 时的查询结果。

[source,java]
----

from Actor a where a.firstName like 'PE%'
----

该查询返回姓氏以 'PE' 开头的演员详细信息列表。

如果您单击结果上方的 SQL 按钮，您应该能看到与以下等价的 SQL 查询。


[source,java]
----

select actor0_.actor_id as col_0_0_ from sakila.actor actor0_ where (actor0_.first_name like 'PE%' )
----

[start=6]
. 打开一个新的 HQL 查询编辑器标签，在编辑器窗格中键入以下查询。单击 "Run HQL Query"（运行 HQL 查询）按钮。

[source,java]
----

from Actor a where a.lastName like 'MO%'
----

该查询返回名字以 'MO' 开头的演员详细信息列表。

测试表明，查询返回了预期结果。下一步需要在应用程序中实现查询，以便单击窗体中的 "Query" 按钮能调用正确的查询。


== 在窗体中添加查询

现在，您需要修改  ``DVDStoreAdmin.java`` ，添加一些查询字符串并创建一些方法，用于构建和调用合并输入变量的查询。您还需要修改按钮事件处理程序，以调用正确的查询，并添加一个用于在表中显示查询结果的方法。

1. 打开  ``DVDStoreAdmin.java``  并单击 "Source"（源）标签。
2. 将以下查询字符串（粗体）添加到类中。

[source,java]
----

public DVDStoreAdmin() {
    initComponents();
}

*private static String QUERY_BASED_ON_FIRST_NAME="from Actor a where a.firstName like '";
private static String QUERY_BASED_ON_LAST_NAME="from Actor a where a.lastName like '";*
----

可以将 HQL 查询编辑器标签中的查询复制到文件中，然后再修改代码。


[start=3]
. 添加以下方法，以根据用户输入字符串创建查询。

[source,java]
----

private void runQueryBasedOnFirstName() {
    executeHQLQuery(QUERY_BASED_ON_FIRST_NAME + firstNameTextField.getText() + "%'");
}
    
private void runQueryBasedOnLastName() {
    executeHQLQuery(QUERY_BASED_ON_LAST_NAME + lastNameTextField.getText() + "%'");
}
----

这些方法调用一个名称为  ``executeHQLQuery()``  的方法，并通过结合查询字符串与用户输入的搜索字符串来创建查询。


[start=4]
. 添加  ``executeHQLQuery()``  方法。

[source,java]
----

private void executeHQLQuery(String hql) {
    try {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        Query q = session.createQuery(hql);
        List resultList = q.list();
        displayResult(resultList);
        session.getTransaction().commit();
    } catch (HibernateException he) {
        he.printStackTrace();
    }
}
----

 ``executeHQLQuery()``  方法调用 Hibernate 来执行选定的查询。该方法利用  ``HibernateUtil.java``  实用程序类来获取 Hibernate 会话。


[start=5]
. 在编辑器中右键单击并选择 "Fix Imports"（修复导入）（Ctrl-Shift-I；在 Mac 上为 ⌘-Shift-I）可为 Hibernate 库（ ``org.hibernate.Query`` 、 ``org.hibernate.Session`` ）和  ``java.util.List``  生成导入语句。保存所做的更改。

[start=6]
. 切换到 "Design"（设计）视图并双击 "Query" 按钮，创建一个 "Query" 按钮事件处理程序。

IDE 将创建  ``queryButtonActionPerformed``  方法并在 "Source"（源）视图中显示该方法。


[start=7]
. 在 "Source"（源）视图中修改  ``queryButtonActionPerformed``  方法，添加以下代码，以便查询能在用户单击按钮时正确运行。

[source,java]
----

private void queryButtonActionPerformed(java.awt.event.ActionEvent evt) {
    *if(!firstNameTextField.getText().trim().equals("")) {
        runQueryBasedOnFirstName();
    } else if(!lastNameTextField.getText().trim().equals("")) {
        runQueryBasedOnLastName();
    }*
}
----

[start=8]
. 添加以下方法，在 JTable 中显示结果。

[source,java]
----

private void displayResult(List resultList) {
    Vector<String> tableHeaders = new Vector<String>();
    Vector tableData = new Vector();
    tableHeaders.add("ActorId"); 
    tableHeaders.add("FirstName");
    tableHeaders.add("LastName");
    tableHeaders.add("LastUpdated");

    for(Object o : resultList) {
        Actor actor = (Actor)o;
        Vector<Object> oneRow = new Vector<Object>();
        oneRow.add(actor.getActorId());
        oneRow.add(actor.getFirstName());
        oneRow.add(actor.getLastName());
        oneRow.add(actor.getLastUpdate());
        tableData.add(oneRow);
    }
    resultTable.setModel(new DefaultTableModel(tableData, tableHeaders));
}
----

[start=9]
. 在编辑器中右键单击并选择 "Fix Imports"（修复导入）（Ctrl-Shift-I；在 Mac 上为 ⌘-Shift-I）可为  ``java.util.Vector``  和  ``java.util.List``  生成导入语句。保存所做的更改。

保存窗体之后，您可以运行项目。


== 运行项目

现在您已完成了编码工作，接下来可以启动应用程序了。在运行项目之前，您需要在项目的属性对话框中指定应用程序的“主类”。如果未指定“主类”，系统将在您首次运行应用程序时提示您进行设置。

1. 右键单击 "Projects"（项目）窗口中的项目节点，然后选择 "Properties"（属性）。
2. 在 "Project Properties"（项目属性）对话框中选择 "Run"（运行）类别。
3. 键入 *sakila.ui.DVDStoreAdmin* 作为主类。单击 "OK"（确定）。

或者，您可以单击 "Browse"（浏览）按钮并在对话框中选择主类。

image::images/browse-main-class.png[title="在 "Browse Main Classes"（浏览主类）对话框中设置主类"]

[start=4]
. 单击主工具栏中的 "Run Project"（运行项目）以启动应用程序。

在 "First Name" 或 "Last Name" 字段中键入搜索字符串，并单击 "Query" 来搜索演员并查看详细信息。

image::images/application-run.png[title="显示结果的 DVDStoreAdmin 应用程序"]

如果您查看 IDE 的 "Output"（输出）窗口，您可以看到检索显示结果的 SQL 查询。


=== 下载解决方案项目

您可以采用下列方法下载本教程的解决方案（作为一个项目）。

* 下载link:https://netbeans.org/projects/samples/downloads/download/Samples/Java/DVDStoreAdmin-Ant.zip[+已完成项目的 zip 档案文件+]。
* 通过执行以下步骤从 NetBeans 样例检出项目源代码：
1. 从主菜单中选择 "Team"（团队开发）> "Subversion" > "Checkout"（检出）。
2. 在 "Checkout"（检出）对话框中，输入以下资源库 URL：
 ``https://svn.netbeans.org/svn/samples~samples-source-code`` 
单击 "Next"（下一步）。

[start=3]
. 单击 "Browse"（浏览）以打开 "Browse Repostiory Folders"（浏览资源库文件夹）对话框。

[start=4]
. 展开根节点，然后选择 *samples/java/DVDStoreAdmin-Ant*。单击 "OK"（确定）。

[start=5]
. 指定用于存储源代码的本地文件夹（本地文件夹必须为空）。

[start=6]
. 单击 "Finish"（完成）。

单击 "Finish"（完成），此时 IDE 会将本地文件夹初始化为 Subversion 资源库，并检出项目源代码。


[start=7]
. 在完成检出操作后将会显示一个对话框，在该对话框中单击 "Open Project"（打开项目）。

*注：*需要 Subversion 客户端检出源代码。有关安装 Subversion 的更多信息，请参见 link:../ide/subversion.html[+NetBeans IDE 中的 Subversion 指南+]中有关link:../ide/subversion.html#settingUp[+设置 Subversion+] 的部分。


== 单独创建 POJO 和映射文件

由于 POJO 是一个简单的 Java 类，因此您可以使用新建 Java 类向导创建类，然后在源代码编辑器中编辑该类，添加必要的字段以及 getter 和 setter 方法。创建 POJO 之后，您可以使用相应的向导创建一个将类映射到表的 Hibernate 映射文件，并将映射信息添加到  ``hibernate.cfg.xml`` 。从头开始创建映射文件时，您需要在 XML 编辑器中将字段映射到列。

*注：*此练习是可选的，说明了如何使用 "Hibernate Mapping Files and POJOs from Database"（通过数据库生成 Hibernate 映射文件和 POJO）向导创建 POJO 和映射文件。

1. 右键单击 "Projects"（项目）窗口中的 "Source Packages"（源包）节点并选择 "New"（新建）> "Java Class"（Java 类）以打开新建 Java 类向导。
2. 在该向导中，键入*类名*作为类名，键入 *sakila.entity* 作为包名。单击 "Finish"（完成）。
3. 对类进行以下更改（显示为粗体）以实现“可串行化”接口并为表列添加字段。

[source,java]
----

public class Actor *implements Serializable* {
    *private Short actorId;
    private String firstName;
    private String lastName;
    private Date lastUpdate;*
}
----

[start=4]
. 在编辑器中右键单击，选择 "Insert Code"（插入代码）（Alt-Insert；在 Mac 上为 Ctrl-I）并在弹出菜单中选择 "Getter and Setter"（Getter 和 Setter），可以为字段生成 getter 和 setter。

[start=5]
. 在 "Generate Getters and Setters"（生成 Getter 和 Setter）对话框中，选择所有字段并单击 "Generate"（生成）。
image::images/getters-setters.png[title=""Generate Getters and Setters"（生成 getter 和 setter）对话框"]

在 "Generate Getters and Setters"（生成 Getter 和 Setter）对话框中，您可以使用键盘中的向上箭头将所选项目移动到 Actor 节点中，然后按空格键选择 Actor 中的所有字段。


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

为表创建 POJO 之后，您需要为  ``Actor.java``  创建一个 Hibernate 映射文件。

1. 在 "Projects"（项目）窗口中右键单击  ``sakila.entity``  源包节点，然后选择 "New"（新建）> "Other"（其他）以打开新建文件向导。
2. 从 "Hibernate" 类别中选择 "Hibernate Mapping File"（Hibernate 配置文件）。单击 "Next"（下一步）。
3. 键入 *Actor.hbm* 作为文件名，并检查文件夹为 *src/sakila/entity*。单击 "Next"（下一步）。
4. 键入 *sakila.entity.Actor* 作为要映射的类，然后从 "Database Table"（数据库表）下拉列表中选择 *actor*。单击 "Finish"（完成）。
image::images/mapping-wizard.png[title="生成 Hibernate 映射文件向导"]

单击 "Finish"（完成），此时将在源代码编辑器中打开 Hibernate 映射文件  ``Actor.hbm.xml`` 。IDE 还会自动在  ``hibernate.cfg.xml``  中添加一个映射资源条目。您可以通过在  ``hibernate.cfg.xml``  "Design"（设计）视图或在 XML 视图中展开 "Mapping"（映射）节点来查看条目详细信息。XML 视图中的  ``mapping``  条目如下所示：


[source,xml]
----

        <mapping resource="sakila/entity/Actor.hbm.xml"/>
    </session-factory>
</hibernate-configuration>
----

[start=5]
. 对  ``Actor.hbm.xml``  执行以下更改（黑体），将  ``Actor.java``  中的字段映射到 ACTOR 表中的列。

[source,xml]
----

<hibernate-mapping>
  <class name="sakila.entity.Actor" *table="actor">
    <id name="actorId" type="java.lang.Short">
      <column name="actor_id"/>
      <generator class="identity"/>
    </id>
    <property name="firstName" type="string">
      <column length="45" name="first_name" not-null="true"/>
    </property>
    <property name="lastName" type="string">
      <column length="45" name="last_name" not-null="true"/>
    </property>
    <property name="lastUpdate" type="timestamp">
      <column length="19" name="last_update" not-null="true"/>
    </property>
  </class>*
</hibernate-mapping>
----

在修改映射文件时，可以使用编辑器中的代码完成功能完成各个值。

*注：*默认情况下，生成的  ``class``  元素具有一个结束标记。因为需要在打开和关闭  ``class``  元素标记之间添加属性元素，所以需要进行以下更改（显示为粗体）。进行更改之后，可以在  ``class``  标记之间使用代码完成。


[source,xml]
----

<hibernate-mapping>
  <class name="sakila.entity.Actor" *table="actor">
  </class>*
</hibernate-mapping>
----

[start=6]
. 单击工具栏中的 "Validate XML"（验证 XML）按钮并保存更改。

如果要进一步定制应用程序，单独创建 POJO 和 Hibernate 映射文件可能是一种非常方便的方法。

link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20Hibernate%20in%20a%20Java%20Swing%20Application[+发送有关此教程的反馈意见+]



== 另请参见

有关创建 Swing GUI 应用程序的附加信息，请参见以下教程。

* link:quickstart-gui.html[+在 NetBeans IDE 中设计 Swing GUI+]
* link:gui-functionality.html[+构建 GUI 应用程序简介+]
* link:../../trails/matisse.html[+Java GUI 应用程序学习资源+]