在JSF2.0 Web 应用程序中使用 Hibernate（1）

 

在 Web 应用程序中使用 Hibernate

在本教程中，您将使用 NetBeans IDE 创建和部署显示数据库中数据的 Web 应用程序。Web 应用程序将 Hibernate 框架用作持久性层，以便检索简单的传统 Java 对象 (Plain Old Java Object, POJO)，并将其存储到关系数据库中。

Hibernate 是一个为对象关系映射 (ORM) 提供工具的框架。本教程介绍了如何向 IDE 添加对 Hibernate 框架的支持，以及如何创建所需的 Hibernate 文件。在创建 Java 对象并配置应用程序以使用 Hibernate 后，创建一个 JSF 受管 Bean 和 JSF 2.0 页面以显示数据。

在开始本教程之前，您可能需要熟悉以下文档。

• hibernate.org 上的 Hibernate 文档
• Web 应用程序开发简介
• JavaServer Faces 2.0 简介

目录

• 创建数据库
• 创建 Web 应用程序项目
• 修改 Hibernate 配置文件
• 创建 HibernateUtil.java 帮助文件
• 生成 Hibernate 映射文件和 Java 类
• 创建 FilmHelper.java Helper 类
• 创建 JSF 受管 Bean
• 创建 Web 页面
• 运行项目
• 下载解决方案项目

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

软件或资源	要求的版本
NetBeans IDE	6.8 和 6.9，Java 版本
Java Development Kit (JDK)	版本 6
GlassFish Server Open Source Edition	3.0.1
MySQL 数据库服务器	版本 5.x
Sakila 数据库	更新中心上可用的插件

注意：

• NetBeans IDE 6.9 和 GlassFish Server 3.0.1 需要 Java Development Kit (JDK) 6。
• 如果您使用的是 GlassFish Server 2.1 或较早版本的 NetBeans IDE，请参见在 Web 应用程序中使用 Hibernate - NetBeans IDE 6.7 教程。

您可以下载已完成项目的 zip 归档文件。

创建数据库

本教程使用一个名为 sakila 的 MySQL 数据库，这是一个免费的 MySQL 数据库，可从 MySQL 网站获得。安装 IDE 时并未包含 sakila 数据库，因此首先需要创建该数据库，以继续学习本教程。

要创建 sakila 数据库，可使用“插件”管理器下载并安装“Sakila 样例数据库”插件。安装该插件后，sakila 数据库即被添加到“创建 MySQL 数据库”对话框的数据库列表中。

有关配置 IDE 使用 MySQL 的更多信息，请参见连接 MySQL 数据库教程。

1. 打开“插件”管理器并安装“Sakila 样例数据库”插件。
2. 安装插件后，在“服务”窗口展开“数据库”节点以启动 MySQL 数据库，右键单击“MySQL 服务器”节点并选择“启动”。
3. 右键单击“MySQL 服务器”节点并选择“创建数据库”。
4. 在“创建 MySQL”对话框的“新数据库名称”下拉列表中选择 Sakila 数据库。单击“确定”。
   

   单击“确定”，“MySQL 服务器”节点下随即出现一个 Sakila 节点。

5. 右键单击 Sakila 节点并选择“连接”。

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

创建 Web 应用程序项目

在本练习中，您将创建一个 Web 应用程序项目并为该项目添加 Hibernate 库。创建该项目时，请在“新建项目”向导的“框架”面板中选择 Hibernate，并指定数据库。

1. 选择“文件”>“新建项目”(Ctrl-Shift-N)。从 "Java Web" 类别中选择“Web 应用程序”并单击“下一步”。
2. 键入 DVDStore 作为项目名称，并设置项目位置。
3. 取消选中“使用专用文件夹存储库”选项（如果该选项处于选中状态）。单击“下一步”。

   （对于本教程，没有理由将项目库复制到指定文件夹，因为您将需要与其他用户共享库）。

4. 将“服务器”设置为 "GlassFish Server 3" 并将“Java EE 版本”设置为 "Java EE 6 Web"。单击“下一步”。
5. 选中 "JavaServer Faces" 复选框并使用缺省 JSF 2.0 库。
6. 选中“Hibernate 3.2.5”复选框。
7. 从“数据库连接”下拉列表中选择 sakila 数据库。单击“完成”。

注意： 如果向导的“框架”面板中没有 sakila 数据库这一选项，请查看该连接是否列示于“服务”窗口的“数据库”节点下。如果此处没有该连接，则需要创建数据库连接。

单击“完成”后，IDE 将创建 Web 应用程序项目，并在编辑器中打开 hibernate.cfg.xml 文件和 index.xhtml。

如果展开“项目”窗口中的“库”节点，则可以看到 IDE 已向项目中添加了 Hibernate 库。

修改 Hibernate 配置文件

创建使用 Hibernate 框架的新项目时，IDE 会自动在应用程序的上下文类路径的根路径（“文件”窗口中的 src/java）上创建 hibernate.cfg.xml 配置文件。该文件位于“项目”窗口的“源包”节点下的 <缺省包> 中。该配置文件包含有关数据库连接、资源映射和其他连接属性的信息。您可以使用多视图编辑器编辑该文件或直接在 XML 编辑器中编辑 XML。

在本练习中，您将编辑在 hibernate.cfg.xml 中指定的缺省属性，以启用 SQL 语句的调试日志记录以及 Hibernate 的会话上下文管理。

1. 打开“设计”标签中的 hibernate.cfg.xml。可通过展开“项目”窗口中的“源包”> "<缺省包>"，然后双击 hibernate.cfg.xml 以打开该文件。
2. 在多视图 XML 编辑器中，展开“可选属性”下的“配置属性”节点。
3. 单击“添加”以打开“添加 Hibernate 属性”对话框。
4. 在此对话框中，选择 hibernate.show_sql 属性并将值设置为 true。这将启用 SQL 语句的调试日志记录。
   
5. 展开“其他属性”节点并单击“添加”。
6. 在此对话框中，选择 properties hibernate.current_session_context_class 并将值设置为 thread 以启用 Hibernate 的自动会话上下文管理。
   

   如果单击编辑器中的 "XML" 标签，则可以在 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.current_session_context_class">thread</property>
       </session-factory>
   </hibernate-configuration>

7. 保存对该文件所做的更改。

由于不需要再次编辑该文件，因此可以关闭该文件。

创建 HibernateUtil.java 帮助文件

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

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

1. 右键单击“源包”节点并选择“新建”>“其他”，打开“新建文件”向导。
2. 从“类别”列表中选择 Hibernate，从“文件类型”列表中选择 HibernateUtil.java。单击“下一步”。
3. 键入 HibernateUtil 作为类名，并键入dvdrental 作为包名。单击“完成”。

单击“完成”后，编辑器将打开 HibernateUtil.java。由于不需要编辑该文件，因此可以关闭该文件。

生成 Hibernate 映射文件和 Java 类

在本教程中，您将使用一个 POJO（简单传统 Java 对象）来表示您将要用到的数据库中的每个表中的数据。Java 类指定表的列字段，并使用简单的 setter 和 getter 方法检索数据和写数据。要将该 POJO 映射到表，可使用 Hibernate 映射文件或使用类标注。

您可以使用“通过数据库生成 Hibernate 映像文件和 POJO”向导根据数据库表创建多个 POJO 和映像文件。使用该向导时，选择希望从中创建 POJO 和映射文件的所有表，IDE 然后根据该数据库表生成文件并将映射条目添加到 hibernate.cfg.xml。使用向导时可选择希望 IDE 生成的文件（比如，只生成 POJO）并选择代码生成选项（比如，生成使用 EJB 3 标注的代码）

注意：IDE 还包含一些向导，以帮助您从头开始创建各个 POJO 和映射文件。

创建 Hibernate 逆向工程文件

如果要使用“通过数据库生成 Hibernate 映射文件和 POJO”向导，您首先需要创建一个 hibernate.reveng.xml 逆向工程文件。“通过数据库生成 Hibernate 映射文件和 POJO”向导需要 hibernate.reveng.xml 和 hibernate.cfg.xml。

通过使用逆向工程文件，您可以更好地控制数据库映射策略。“Hibernate 逆向工程”向导创建一个具有缺省配置的逆向工程文件，可以在 XML 编辑器中编辑该文件。

要创建 Hibernate 逆向工程文件，请执行以下步骤。

1. 在“项目”窗口中右键单击“源包”节点，并选择“新建”>“其他”以打开“新建文件”向导。
2. 从 "Hibernate" 类别中选择“Hibernate 逆向工程向导”。单击“下一步”。
3. 指定 hibernate.reveng 作为文件名，指定 src/java 作为文件夹。单击“下一步”。
4. 在“配置文件”下拉列表中选择 hibernate.cfg.xml（如果尚未选定）。
5. 从“可用表”中选择以下表，并单击“添加”将表添加到“选定表”。
   • actor
   • category
   • film
   • film_actor
   • film_category
   • language

   单击“完成”。

   

该向导生成一个 hibernate.reveng.xml 逆向工程文件，并在编辑器中打开该文件。可将该逆向工程文件关闭，因为无需对其进行编辑。

有关使用 hibernate.reveng.xml 文件的详细信息，请参见以下指南中的第 5 章“控制逆向工程”：《Hibernate 工具参考指南》。

创建 Hibernate 映射文件和 POJO

可以使用“通过数据库生成 Hibernate 映射文件和 POJO”向导来生成文件。该向导可以为您在向导中选择的每个表生成 POJO 和相应的映射文件。映射文件是 XML 文件，其中包含有关如何将表中的列映射到 POJO 中的字段的数据。您需要有 hibernate.reveng.xml 和 hibernate.cfg.xml 文件才能使用该向导。

要使用向导创建 POJO 和映射文件，请执行以下步骤。

1. 在“项目”窗口中右键单击“源包”节点，并选择“新建”>“其他”以打开“新建文件”向导。
2. 在 Hibernate 类别的数据库中选择 Hibernate 映射文件和 POJO。单击“下一步”。
3. 确保在下拉列表中选择 hibernate.cfg.xml 和 hibernate.reveng.xml 文件。
4. 在“常规设置”选项中选择 JDK 5 语言功能。
5. 确保 域代码 和 Hibernate XML 映射 选项为选定项。
6. 选择 dvdrental 作为包名。单击“完成”。
   

单击“完成”后，IDE 生成 POJO 和 Hibernate 映射文件，并将字段映射到在 hibernate.reveng.xml 中指定的列。IDE 也添加映射条目到 hibernate.cfg.xml 中。展开 dvdrental 包查看由向导生成的文件。

如果要创建 Hibernate 映射文件以将特定表映射到特定类，您可以使用“Hibernate 映射”向导。

有关使用 hibernate.reveng.xml 文件的详细信息，请参见以下文档中的第 5 章“基本 O/R 映射”：《Hibernate 参考文档》。

创建 FilmHelper.java Helper 类

现在，您将在 dvdrental 包中创建一个 helper 类，将用于在数据库中执行 Hibernate 查询。您将使用“Hibernate 查询语言（HQL）”编辑器来构造并测试用于检索数据的查询。测试了查询后，将在构造并运行查询的 helper 类中创建方法。然后，通过 JSF 受管 Bean 调用 helper 类中的方法。

创建类

在此部分，使用“新建文件”向导在 dvdrental 包中创建 helper 类 FilmHelper.java。您将通过调用 HibernateUtil.java 中的 getSessionFactory 来创建一个 Hibernate 会话，并创建一些 helper 方法以创建查询来检索数据库中的数据。将从 JSP 页面中调用这些 helper 方法。

1. 右键单击 dvdrental 源包节点，并选择“新建”>“Java 类”以打开“新建文件”向导。
2. 键入 FilmHelper 作为类名。
3. 检查包是否为 dvdrental。单击“完成”。
4. 添加以下代码（粗体），创建一个 Hibernate 会话。

   public class FilmHelper {
   
       Session session = null;      public FilmHelper() {         this.session = HibernateUtil.getSessionFactory().getCurrentSession();     }
   
   }

5. 修复导入 (org.hibernate.Session) 并保存更改。

现在将修改 FilmHelper.java 以添加查询数据库的方法。

使用 HQL 查询列举影片名称并检索演员

在本练习中，将创建一个 Hibernate 查询语言 (HQL, Hibernate Query Language) 查询，以便查询数据库以从 Film 表中检索影片名称列表。然后，添加一个方法以查询 Actor 和 Film_actor 表，以便获取特定影片中涉及的演员。

Film 表包含 1000 条记录，因此检索影片列表的方法应该能够基于 filmId 主键检索记录。您将使用 HQL 编辑器构造和测试 HQL 查询。在创建正确的查询后，将在类中添加一个方法以生成相应的查询。

1. 在“项目”窗口中右键单击 hibernate.cfg.xml 并选择“运行 HQL 查询”以打开 HQL 查询编辑器。
2. 从工具栏的下拉列表中选择 hibernate.cfg。
3. 在编辑器中键入以下内容并单击工具栏中的“运行 HQL 查询”按钮（）来测试该连接。

   from Film

   单击“运行 HQL 查询”可在 HQL 查询编辑器的 botton 窗口看到查询结果。

   如果单击 SQL 按钮，可以看到起相同作用的 SQL 查询。

   select film0_.film_id as col_0_0_ from sakila.film film0_

4. 键入以下查询在 film id 为 100 到 200 的 Film 表中检索记录。

   from Film as film where film.filmId between 100 and 200

   结果窗口中显示了一个记录列表。测试过该查询可返回期待的结果后，可在 helper 类中使用该查询。

5. 将下面的 getFilmTitles 方法添加到 FilmHelper.java 以检索影片，其中 film id 介于变量 startID 和 endID 所指定的特定范围之间。

   public List getFilmTitles(int startID, int endID) {
       List<Film> filmList = null;
       try {
           org.hibernate.Transaction tx = session.beginTransaction();
           Query q = session.createQuery ("from Film as film where film.filmId between '"+startID+"' and '"+endID+"'");
           filmList = (List<Film>) q.list();
       } catch (Exception e) {
           e.printStackTrace();
       }
       return filmList;
   }

6. 添加下面的 getActorsByID 方法以检索特定影片中的演员。该方法将 filmId 作为输入变量以构造查询。

   public List getActorsByID(int filmId){
       List<Actor> actorList = null;
       try {
           org.hibernate.Transaction tx = session.beginTransaction();
           Query q = session.createQuery ("from Actor as actor where actor.actorId in (select filmActor.actor.actorId from FilmActor as filmActor where filmActor.film.filmId='" + filmId + "')");
           actorList = (List<Actor>) q.list();
   
       } catch (Exception e) {
           e.printStackTrace();
       }
   
       return actorList;
   }

7. 修复导入并保存更改。

   修复导入时，要选择 java.util.List 和 org.hibernate.Query.

添加额外的 helper 方法

现在将添加一些额外的 helper 方法，创建基于输入变量的查询。可在 HQL 查询编辑器中检查这些查询。

1. 添加以下方法以根据 filmId 检索类别列表。

   public Category getCategoryByID(int filmId){
       List<Category> categoryList = null;
       try {
           org.hibernate.Transaction tx = session.beginTransaction();
           Query q = session.createQuery("from Category as category where category.categoryId in (select filmCat.category.categoryId from FilmCategory as filmCat where filmCat.film.filmId='" + filmId + "')");
           categoryList = (List<Category>) q.list();
   
       } catch (Exception e) {
           e.printStackTrace();
       }
   
       return categoryList.get(0);
   }

2. 添加以下方法以根据 filmId 检索单个影片。

   public Film getFilmByID(int filmId){
   
       Film film = null;
   
       try {
           org.hibernate.Transaction tx = session.beginTransaction();
           Query q = session.createQuery("from Film as film where film.filmId=" + filmId);
           film = (Film) q.uniqueResult();
       } catch (Exception e) {
           e.printStackTrace();
       }
   
       return film;
   }

3. 添加以下方法以根据 langId 检索影片语言。

   public String getLangByID(int langId){
   
       Language language = null;
   
       try {
           org.hibernate.Transaction tx = session.beginTransaction();
           Query q = session.createQuery("from Language as lang where lang.languageId=" + langId);
           language = (Language) q.uniqueResult();
       } catch (Exception e) {
           e.printStackTrace();
       }
   
       return language.getName();
   }