| // |
| // 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. |
| // |
| |
| = 使用 Hibernate 创建 Maven Swing 应用程序 - NetBeans IDE 教程 |
| :jbake-type: tutorial |
| :jbake-tags: tutorials |
| :jbake-status: published |
| :icons: font |
| :syntax: true |
| :source-highlighter: pygments |
| :toc: left |
| :toc-title: |
| :description: 使用 Hibernate 创建 Maven Swing 应用程序 - NetBeans IDE 教程 - Apache NetBeans |
| :keywords: Apache NetBeans, Tutorials, 使用 Hibernate 创建 Maven Swing 应用程序 - NetBeans IDE 教程 |
| |
| 在本教程中,您将使用 NetBeans IDE 通过 Maven 原型创建 Java Swing 应用程序。该应用程序使用 Hibernate 框架作为持久层来检索关系数据库中的 POJO (plain old Java object) 对象。本教程演示了 IDE 中的向导将如何帮助您创建所需的 Hibernate 文件并将 Hibernate 依赖关系添加到 POM。创建 Java 对象并将应用程序配置为使用 Hibernate 后,您将创建一个 GUI 界面,用于搜索并显示数据。 |
| |
| NetBeans IDE 中完全集成了对 Maven 的支持,并且 Maven 3 已随 IDE 捆绑提供。在新建项目向导中,可以从捆绑的 Maven 原型或者从远程资源库中的原型创建应用程序。使用 Maven 资源库浏览器,可以浏览本地和远程 Maven 资源库,检查工件以及将项目依赖关系添加到项目的 POM 中。 |
| |
| 要使用 Ant 构建此应用程序,请参见link:hibernate-java-se.html[+在 Java Swing 应用程序中使用 Hibernate+]。 |
| |
| 要构建 Maven Java EE 应用程序,请参见link:../javaee/maven-entapp.html[+使用 Maven 创建企业应用程序+]。 |
| |
| |
| image::images/netbeans-stamp-80-74-73.png[title="此页上的内容适用于 NetBeans IDE 7.2、7.3、7.4 和 8.0"] |
| |
| |
| *要学习本教程,您需要具备以下软件和资源。* |
| |
| |=== |
| |软件或资源 |要求的版本 |
| |
| |link:http://download.netbeans.org/[+NetBeans IDE+] |7.2、7.3、7.4、8.0、Java 包 |
| |
| |link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Java 开发工具包 (JDK)+] |版本 7 或 8 |
| |
| |link:http://maven.apache.org/[+Maven+] |版本 2.09 或更高 |
| |
| |link:http://www.mysql.com/[+MySQL 数据库服务器+] |版本 5.x |
| |
| |Sakila 数据库 |更新中心上可用的插件 |
| |=== |
| |
| 在开始本教程之前,您可以先阅读下面这些文档。 |
| |
| |
| 您可以下载link:https://netbeans.org/projects/samples/downloads/download/Samples/Java/DVDStoreAdmin-Maven.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"(确定)后,IDE 将运行脚本以创建 Sakila 数据库,并填充数据库表。您可以在 "Output"(输出)窗口中查看运行脚本的结果。此时,还会在 MySQL 服务器节点下方添加 Sakila 数据库的节点。 |
| |
| |
| [start=5] |
| . 右键单击 "Sakila" 节点,然后选择 "Connect"(连接)。 |
| |
| 单击 "Connect"(连接)后,"Databases"(数据库)节点下面将列出 Sakila 数据库连接节点 ( ``jdbc:mysql://localhost:3306/sakila [_username_ on Default]`` )。打开连接时,可通过展开该连接节点查看数据库中数据。 |
| |
| |
| == 配置 Maven |
| |
| Maven 与 IDE 捆绑在一起,并在安装 IDE 时进行安装,但如果这是您首次创建 Maven 项目,则需要在 "Options"(选项)窗口中检查 Maven 配置设置。 |
| |
| 1. 在 IDE 中打开“选项”窗口(“工具”>“选项”;在 Mac 上为 "NetBeans" >“首选项”)。 |
| 2. 在 "Options"(选项)窗口中选择 "Java" 类别,然后单击 "Maven" 标签。 |
| 3. 确认指定了 Maven Home 目录。 |
| |
| 您可以使用与 IDE 捆绑在一起的 Maven 版本,也可以指定 Maven 在本地的安装位置(要求为 2.0.9 或更高版本)。 |
| |
| |
| [start=4] |
| . 选择 "OK"(确定)以关闭 "Options"(选项)窗口。 |
| |
| *注:* |
| |
| * 在 IDE 中启用 Java 后,会自动启用 Maven 支持。您将需要启用 Java EE 插件(如果尚未启用)。 |
| * 在 NetBeans IDE 7.1 和 IDE 的早期版本中,"Options"(选项)窗口的 "Maven" 标签位于 "Miscellaneous"(其他)类别下。 |
| |
| |
| === 查看 Maven 资源库 |
| |
| Maven 用于构建所有项目的工件均存储在本地 Maven 资源库中。如果某一工件被声明为项目依赖关系,则会将其从已注册的某个远程资源库下载到您的本地资源库中。 |
| |
| 默认情况下,已注册一些常见的索引 Maven 资源库,并将其列在资源库浏览器中。已注册的资源库包含构建项目所需的大多数公共工件。大多数情况下,无需注册任何其他资源库,除非项目需要使用只包含在专用资源库中的工件。 |
| |
| 在 "Services"(服务)窗口中,可以浏览本地和远程 Maven 资源库和执行即时更新检查。本地或远程资源库中的所有工件都可以作为项目依赖关系进行添加。在 "Service"(服务)窗口中,可以展开 "Local repository"(本地资源库)节点以查看本地存在的工件。远程资源库节点下列出的工件可以作为项目依赖关系进行添加,但并非所有这些工件都在本地存在。仅当这些工件声明为项目依赖关系时,才会将其添加到本地资源库。 |
| |
| 要浏览和更新 Maven 资源库,请执行以下步骤。 |
| |
| 1. 选择 "Window"(窗口)> "Services"(服务)以打开 "Services"(服务)窗口。 |
| 2. 在 "Services"(服务)窗口中展开 "Maven Repositories"(Maven 资源库)节点以查看资源库。 |
| 3. 展开资源库节点以查看工件。 |
| 4. 右键单击资源库节点并在弹出菜单中选择 "Update Index"(更新索引)以更新资源库。 |
| image::images/maven-repositories.png[title=""Services"(服务)窗口中的 "Maven Repositories"(Maven 资源库)"] |
| |
| 当将光标置于某个工件上时,IDE 将显示包含其坐标的工具提示。可以双击工件的 JAR 文件以查看有关该工件的其他详细信息。 |
| |
| 在 "Services"(服务)窗口中右键单击 "Maven Repositories"(Maven 资源库)并选择 "Find"(查找)可搜索工件。 |
| |
| 有关管理 Maven 类路径依赖关系和在 IDE 中使用 Maven 资源库的详细信息,请参见 link:http://wiki.netbeans.org/MavenBestPractices#section-MavenBestPractices-DependencyManagement[+NetBeans IDE 中的 Apache Maven 最佳做法+]的link:http://wiki.netbeans.org/MavenBestPractices[+依赖关系管理+]部分。 |
| |
| *NetBeans IDE 7.1 和 IDE 较早版本的注释。* |
| |
| * 选择 "Window"(窗口)> "Other"(其他)> "Maven Repositories Browser"(Maven 资源库浏览器)以查看 Maven 资源库。 |
| * 可以使用 Maven 资源库浏览器的工具栏中的按钮来更新索引和搜索工件。 |
| |
| |
| == 创建 Maven 应用程序 |
| |
| 在本教程中,您将创建一个简单的 Java Swing 应用程序项目 DVDStoreAdmin。您将通过某个捆绑的 Maven 原型创建项目,然后修改默认项目设置。 |
| |
| |
| === 选择原型 |
| |
| 使用新建项目向导可以通过 Maven 原型创建 Maven 项目。IDE 包含一些常用 NetBeans 项目类型的原型,但是您也可以在该向导中找到并选择远程资源库中的原型。 |
| |
| 1. 从主菜单中选择 "File"(文件)> "New Project"(新建项目)(Ctrl-Shift-N 组合键;在 Mac 上为 ⌘-Shift-N 组合键),以打开新建项目向导。 |
| 2. 从 "Maven" 类别中选择 "Java Application"(Java 应用程序)。单击 "Next"(下一步)。 |
| image::images/maven-project-wizard.png[title="新建项目向导中的 "Maven Archetypes"(Maven 原型)"] |
| |
| [start=3] |
| . 键入 *DVDStoreAdmin* 作为项目名称并设置项目位置。 |
| |
| [start=4] |
| . 修改默认的组 ID 和版本(可选)。 |
| |
| 构建项目时,组 ID 和版本将作为工件在本地资源库中的坐标使用。 |
| |
| |
| [start=5] |
| . 单击 "Finish"(完成)。 |
| |
| 单击 "Finish"(完成)后,IDE 将创建 Maven 项目并在 "Projects"(项目)窗口中打开该项目。IDE 将自动在 ``com.mycompany.dvdstoreadmin`` 包中创建类 ``App.java`` 。您可以删除 ``App.java`` ,因为应用程序不需要使用该类。 |
| |
| *注:*如果这是首次创建 Maven 项目,则 Maven 需要将一些必需的插件和工件下载到本地资源库中。这可能会花费一些时间。 |
| |
| |
| === 修改项目属性 |
| |
| 使用向导创建 Maven 项目时,默认项目属性是基于原型的。在某些情况下,您可能需要根据自己所用的系统及项目的要求对默认属性进行修改。例如,对于本项目,由于项目使用标注,因此您需要确认将源代码级别设置为 1.5 或更高版本。 |
| |
| 1. 右键单击项目节点,然后选择 "Properties"(属性)。 |
| 2. 在 "Properties"(属性)窗口中选择 "Sources"(源)类别。 |
| 3. 确认在下拉列表中选择的 "Source/Binary Format"(源代码/二进制格式)为 1.5 或更高版本。 |
| 4. 从 "Encoding"(编码)属性的下拉列表中选择 "UTF-8"。单击 "OK"(确定)。 |
| |
| |
| == 添加 Hibernate 文件和依赖关系 |
| |
| 要添加对 Hibernate 的支持,您需要使 Hibernate 库可用,方法是在 POM 中将所需工件声明为依赖关系。IDE 提供的向导可以帮助您创建在项目中需要的 Hibernate 文件。您可以使用 IDE 中的向导来创建 Hibernate 配置文件和实用程序帮助类。如果您使用向导创建 Hibernate 配置文件,IDE 将自动更新 POM,以将 Hibernate 依赖关系添加到项目中。 |
| |
| 您可以在 "Projects"(项目)窗口中将依赖关系添加到项目,也可以直接编辑 ``pom.xml`` 。要在 "Projects"(项目)窗口中添加依赖关系,请右键单击 "Projects"(项目)窗口中的 "Dependencies"(依赖关系)节点,然后从弹出菜单中选择 "Add Dependency"(添加依赖关系)以打开 "Add Dependency"(添加依赖关系)对话框。添加依赖关系时,IDE 将更新 POM 并将本地尚不存在的任何所需工件下载到本地资源库。 |
| |
| 要直接编辑 ``pom.xml`` ,请在 "Projects"(项目)窗口中展开 "Project Files"(项目文件)节点,然后双击 ``pom.xml`` 以打开该文件。 |
| |
| |
| === 创建 Hibernate 配置文件 |
| |
| Hibernate 配置文件 ( ``hibernate.cfg.xml`` ) 包含关数据库连接、资源映射和其他连接属性的信息。在使用向导创建 Hibernate 配置文件时,您可以从 IDE 的注册数据库连接列表中选择数据库连接。生成配置文件时,IDE 会根据所选的数据库连接自动添加连接详细信息和方言信息。IDE 还会自动修改 POM 以添加所需的 Hibernate 依赖关系。创建配置文件之后,您可以使用多视图编辑器来编辑文件,也可以直接在 XML 编辑器中编辑 XML 文件。 |
| |
| 1. 右键单击 "Services"(服务)窗口中的 Sakila 数据库连接,然后选择 "Connect"(连接)。 |
| 2. 在 "Projects"(项目)窗口中右键单击 "Source Packages"(源包)节点,并选择 "New"(新建)> "Other"(其他)以打开新建文件向导。 |
| 3. 从 "Hibernate" 类别中选择 Hibernate 配置向导。单击 "Next"(下一步)。 |
| 4. 保留默认文件名 ( ``hibernate.cfg`` )。 |
| 5. 单击 "Browse"(浏览)并指定 ``src/main/resources`` 目录作为位置(如果尚未指定)。单击 "Next"(下一步)。 |
| 6. 在 "Database Connection"(数据库连接)下拉列表中,选择 sakila 连接。单击 "Finish"(完成)。 |
| image::images/hib-config.png[title="用于选择数据库连接的对话框"] |
| |
| 单击 "Finish"(完成)后,IDE 在编辑器中打开 ``hibernate.cfg.xml`` 。配置文件包含关于单一数据库的信息。 |
| |
| 如果在 "Projects"(项目)窗口中展开 "Dependencies"(依赖关系)节点,则可以看到 IDE 已添加了所需的 Hibernate 工件。IDE 会在 "Dependencies"(依赖关系)节点下列出编译项目所需的所有直接依赖关系和传递依赖关系。作为直接依赖关系(项目的 POM 中指定的依赖关系)的工件以彩色 JAR 图标表示。作为传递依赖关系的工件(该工件是一个或多个直接依赖关系的依赖关系)以灰色显示。 |
| |
| image::images/maven-project-libs.png[title=""Projects"(项目)窗口中的 "Libraries"(库)节点下的依赖关系"] |
| |
| 通过右键单击某个 JAR 并选择 "View Artifact Details"(查看工件详细信息),可以查看工件的详细信息。工件查看器包含一些标签,其中提供了有关选定工件的详细信息。例如,"Basic"(基本)标签提供了有关工件坐标和可用版本的详细信息。"Graph"(图形)标签提供了选定工件的依赖关系的可视表示。 |
| |
| image::images/maven-artifacts-viewer.png[title="显示依赖关系的 "Graphs"(图形)标签或工件查看器"] |
| |
| 您也可以使用 "Graph"(图形)标签发现并解决依赖关系间的版本冲突问题。 |
| |
| |
| === 修改 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*。单击 "OK"(确定)。 |
| |
| *注:*不要从下拉列表中选择值。 |
| |
| image::images/add-property-factoryclass-4.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"(下一步)。 |
| 3. 键入 *HibernateUtil* 作为类名,并键入 *sakila.util* 作为包名。单击 "Finish"(完成)。 |
| image::images/maven-hibutil-wizard.png[title="Hibernate 实用程序向导"] |
| |
| 单击 "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 和映射文件>>的步骤。 |
| |
| |
| === 创建逆向工程文件 |
| |
| 要使用通过数据库生成 POJO 和映射文件向导,您需要首先在 ``src/main/resources`` 目录(在其中创建了 ``hibernate.cfg.xml`` )中创建 ``reveng.xml`` 逆向工程文件。 |
| |
| 1. 右键单击 "Source Packages"(源包)节点并选择 "New"(新建)> "Other"(其他),打开新建文件向导。 |
| 2. 从 "Categories"(类别)列表中选择 "Hibernate",然后从 "File Types"(文件类型)列表中选择 Hibernate 逆向工程向导。单击 "Next"(下一步)。 |
| 3. 键入 *hibernate.reveng* 作为文件名。 |
| 4. 指定 * ``src/main/resources`` * 作为位置。单击 "Next"(下一步)。 |
| 5. 在 "Available Tables"(可用表)窗格中选择 *actor*,然后单击 "Add"(添加)。单击 "Finish"(完成)。 |
| |
| 该向导将生成 ``hibernate.reveng.xml`` 逆向工程文件。可将该逆向工程文件关闭,因为无需对其进行编辑。 |
| |
| *注:*此项目需要 MySQL 连接器 jar 库(例如, ``mysql-connector-jar-5.1.13.jar`` )。如果在 "Dependencies"(依赖关系)节点下面未将适当的 JAR 作为项目依赖关系列出,则可以右键单击 "Dependencies"(依赖关系)节点并选择 "Add Dependency"(添加依赖关系)以添加依赖关系。 |
| |
| |
| === 通过数据库创建 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.png[title=""Generate Hibernate Mapping Files and POJOs"(生成 Hibernate 映射文件和 POJO)向导"] |
| |
| 单击 "Finish"(完成),此时 IDE 将在 ``src/main/java/sakila/entity`` 目录中生成包含所有必需字段的 POJO ``Actor.java`` 。IDE 还会在 ``src/main/resources/sakila/entity`` 目录中生成 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" 标签旁边,并删除默认文本。 |
| |
| 删除默认文本后,文本字段将折叠起来。您可以稍后调整文本字段的大小,以调整窗体元素的对齐方式。 |
| |
| |
| [start=4] |
| . 从 "Palette"(组件面板)中拖出一个 "Label"(标签)元素,并将文本更改为 *Last Name*。 |
| |
| [start=5] |
| . 拖放一个 "Text Field"(文本字段)元素到 "Last Name" 标签旁边,并删除默认文本。 |
| |
| [start=6] |
| . 从 "Palette"(组件面板)中拖出一个 "Button"(按钮)元素,并将文本更改为 *Query*。 |
| |
| [start=7] |
| . 从 "Palette"(组件面板)中拖放一个 "Table"(表)元素到窗体中。 |
| |
| [start=8] |
| . 根据下表中的值更改以下 UI 元素的 "Variable Name"(变量名称)值。 |
| |
| 您可以更改元素的 "Variable Name"(变量名称)值,方法是右键单击 "Design"(设计)视图中的元素并选择 "Change Variable Name"(更改变量名称)。或者,您可以直接在 "Inspector"(检查器)窗口中更改变量名称。 |
| |
| 您不需要为 "Label"(标签)元素指定变量名称。 |
| |
| |=== |
| |元素 |变量名称 |
| |
| |"First Name" 文本字段 | ``firstNameTextField`` |
| |
| |"Last Name" 文本字段 | ``lastNameTextField`` |
| |
| |"Query" 按钮 | ``queryButton`` |
| |
| |表 | ``resultTable`` |
| |=== |
| |
| [start=9] |
| . 调整文本字段的大小并对齐窗体元素。 |
| |
| 您可以对文本字段启用 "Horizontal Resizable"(可水平调整大小)属性,以确保文本字段的大小可随窗口进行调整且元素间距保持不变。 |
| |
| |
| [start=10] |
| . 保存所做的更改。 |
| |
| 在 "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"(构建)。 |
| |
| 单击 "Build"(构建)后,IDE 会将所需的工件下载到您本地的 Maven 资源库。 |
| |
| |
| [start=2] |
| . 在 "Projects"(项目)窗口中的 "Other Sources"(其他源)节点下展开 ``<默认包>`` 源包节点。 |
| |
| [start=3] |
| . 右键单击 ``hibernate.cfg.xml`` 配置文件,然后选择 "Run HQL Query"(运行 HQL 查询)以打开 HQL 编辑器。 |
| |
| [start=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] |
| . 修复您的导入,为 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] |
| . 修复导入(Ctrl+Shift+I 组合键)以添加 ``java.util.Vector`` ,然后保存所做的更改。 |
| |
| 保存窗体之后,您可以运行项目。 |
| |
| |
| == 运行 Maven 项目 |
| |
| 现在您已完成了编码工作,接下来可以构建项目并启动应用程序了。在 IDE 中构建 Maven 项目时,Maven 将读取项目的 POM 以识别项目依赖关系。要构建项目,指定为依赖关系的所有工件都必须位于本地 Maven 资源库中。如果某个所需的工件不在本地资源库中,Maven 将先从远程资源库中检出该工件,然后再尝试构建并运行项目。构建项目后,Maven 会将构建的二进制文件作为工件安装到本地资源库中。 |
| |
| *注:* |
| |
| * 如果 IDE 需要检出任何项目依赖关系,则首次构建并运行项目可能要花费一些时间。之后的构建过程将会加快。 |
| * 要运行此应用程序,首先需要指定“主类”。 |
| |
| 要编译并启动此应用程序,请执行以下任务。 |
| |
| 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"(运行项目)以启动应用程序。 |
| |
| 在 IDE 中对 Maven 项目调用 "Run"(运行)操作时,IDE 将运行与 "Run"(运行)操作关联的 Maven 目标。IDE 具有绑定到 IDE 操作的默认目标,这些目标依据项目包而定。在项目 "Properties"(属性)窗口的 "Actions"(操作)窗格中,可以查看绑定到 "Run"(运行)操作的目标。 |
| |
| image::images/maven-projectproperties.png[title="DVDStoreAdmin 项目属性窗口的 "Actions"(操作)窗格"] |
| |
| 在项目 "Properties"(属性)窗口的 "Actions"(操作)窗格中,可以定制操作的绑定目标。 |
| |
| 启动应用程序时,GUI 窗体打开。在 "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-Maven.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-Maven*。单击 "OK"(确定)。 |
| |
| [start=5] |
| . 指定用于存储源代码的本地文件夹(本地文件夹必须为空)。 |
| |
| [start=6] |
| . 单击 "Finish"(完成)。 |
| |
| 单击 "Finish"(完成),此时 IDE 会将本地文件夹初始化为 Subversion 资源库,并检出项目源代码。 |
| |
| |
| [start=7] |
| . 在完成检出操作后将会显示一个对话框,在该对话框中单击 "Open Project"(打开项目)。 |
| |
| *注:* |
| |
| * 从 Kenai 检出源代码的步骤仅适用于 NetBeans IDE 6.7 和 6.8。 |
| * 需要 Subversion 客户端以从 Kenai 检出源代码。有关安装 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] |
| . 为字段生成 getter 和 setter 方法,方法是将光标放置在源代码编辑器中,按下 Alt-Insert 并选择 "Getter and 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 Wizard"(Hibernate 映射向导)。单击 "Next"(下一步)。 |
| 3. 键入 *Actor.hbm* 作为文件名,并将 "Folder"(文件夹)设置为 *src/main/resources/sakila/entity*。单击 "Next"(下一步)。 |
| 4. 键入 *sakila.entity.Actor* 作为要映射的类。 |
| 5. 从 "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=6] |
| . 对 ``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=7] |
| . 单击工具栏中的 "Validate XML"(验证 XML)按钮并保存更改。 |
| |
| 如果要进一步定制应用程序,单独创建 POJO 和 Hibernate 映射文件可能是一种非常方便的方法。 |
| |
| link:/about/contact_form.html?to=3&subject=Feedback:%20Creating%20a%20Maven%20Project[+发送有关此教程的反馈意见+] |
| |
| |
| |
| == 另请参见 |
| |
| 有关创建 Swing GUI 应用程序的附加信息,请参见以下教程。 |
| |
| * link:quickstart-gui.html[+在 NetBeans IDE 中设计 Swing GUI+] |
| * link:gui-functionality.html[+构建 GUI 应用程序简介+] |
| * link:../../trails/matisse.html[+Java GUI 应用程序学习资源+] |