读书笔记《advanced-java-ee-development-with-wildfly》Hibernate4中的关系映射

Chapter 2. Developing Object/Relational Mapping with Hibernate 4

Hibernate 是一个对象/关系映射 Java 框架，通过它可以将 POJO 域对象映射到关系数据库。尽管 Hibernate 已经不仅仅是一个对象/关系框架，我们将只讨论它的对象/关系映射方面。 Hibernate 相对于传统 Java Database Connectivity 的优势（JDBC) 是它提供了 Java 对象到关系数据库表的映射以及 Java 数据类型到 SQL 数据类型的映射，而无需开发人员提供映射，这意味着有减少 API 调用并消除 SQL 语句。 Hibernate 通过使用方言配置的供应商特定映射提供与数据库的松散耦合。 Hibernate 实现了缓存、查询调优和连接池等功能，这些功能必须由 JDBC 开发人员实现。

本章包含以下部分：

创建 Java EE Web 项目
创建 Hibernate XML 映射文件
创建属性文件
创建休眠配置文件
为 CRUD 创建 JSP
创建 JavaBean 类
导出架构
创建表数据
检索表数据
更新表格行
删除表格行
安装 Maven 项目
运行模式导出
创建表行
检索表数据
更新表
删除表格行

Setting up the environment

我们需要安装以下软件（同第 1 章，EJB 3.x 入门）：

WildFly 8.1.0.Final：从 wildfly-8.1.0.Final.zip 下载 <一个类="ulink" href="http://wildfly.org/downloads/" target="_blank">http://wildfly.org/downloads/。
MySQL 5.6 数据库社区版：从 http://dev.mysql.com/downloads/mysql/。安装 MySQL 时，还要安装 Connector/J。
面向 Java EE 开发人员的 Eclipse IDE：从 https://www.eclipse.org/downloads/packages/release/Luna/SR1。
JBoss Tools (Luna) 4.2.0.Final（或最新版本）：将此作为插件从 Eclipse Marketplace 安装到 Eclipse（http://tools.jboss.org/downloads/installation.html) .
Apache Maven：从 http://maven.apache.org/download.cgi。
Java 7：从 http://www.oracle.com/technetwork/java/javase/downloads/index.html?ssSourceSiteId=ocomcn。

设置与 Chapter 1 中相同的环境变量， EJB 3.x 入门：JAVA_HOME、JBOSS_HOME 、MAVEN_HOME 和 MYSQL_HOME。添加 %JAVA_HOME%/bin, %MAVEN_HOME%/bin, %JBOSS_HOME%/bin 和 %MYSQL_HOME%/bin 到 PATH 环境变量。

创建一个 WildFly 8.1.0 运行时，如第 1 章，EJB 3.x 入门。

Creating a Java EE web project

在本节中，我们将在 Eclipse IDE 中创建 Java EE Web 项目 .执行以下步骤来完成此任务：

选择文件 | 新 | 其他。在 New 窗口中，选择 JBoss Central | Java EE Web Project并点击Next，如图以下屏幕截图：

Java EE Web 项目向导启动。针对需求运行测试，其中包括 JBoss 服务器运行时、JBoss 工具运行时以及 m2e 和 m2eclipes-wtp 插件。
选中创建空白项目复选框和Target Runtime WildFly 8.x Runtime 并点击Next，如下图所示.尽管 Java EE Web 项目将 Java EE 版本指示为 Java EE 6，但实际上创建了一个 Java EE 7 Web 项目。
指定项目名称 (jboss- hibernate) 和 Package (org.jboss.hibernate)，然后点击下一步，如下截图所示：
指定组 ID (org. jboss.hibernate), Artifact Id (jboss-hibernate), 版本（1.0.0）和包< /strong> (org.jboss.hibernate)，如下图所示。点击完成按钮。
jboss-hibernate 项目在 Eclipse 中创建并添加到 Project Explorer，如下图所示：

Creating a Hibernate XML Mapping file

Hibernate 使用 XML 映射文件在持久性类和关系数据库之间提供透明映射。持久类对象的实际存储和加载是基于映射元数据的。执行以下步骤来完成此操作：

要创建 Hibernate XML 映射文件，请选择 File | 新 | 其他。
在 New 窗口中，选择 Hibernate | Hibernate XML Mapping File (hbm.xml) 并点击下一步，如下截图所示：

新建 Hibernate XML 映射文件向导启动。由于我们还没有定义任何要映射的持久性类，我们将首先创建一个空的 XML 映射文件。
在 Create Hibernate XML Mapping file(s) 中，点击下一步，如下图所示：

src/main/resources 目录中的资源位于 Hibernate 应用程序的类路径中。
选择jboss-hibernate | src | main | resources 文件夹并将文件名指定为 catalog.hbm。 xml，如下图所示。点击完成。

catalog.hbm.xml 映射文件被添加到 resources 目录。映射文件的根元素是hibernate-mapping。使用 <class/> 元素配置持久性类。将 <class/> 元素添加到 org.jboss.hibernate.model.Catalog 类中指定的 <class/> 元素中的 class="literal">name 属性。我们还没有创建持久性类，如果我们只是将模式导出到关系数据库，则不需要它，但需要存储或加载任何 POJO 对象。使用 <class/> 元素的 table 属性指定将类映射到的表。通过指定的映射，Catalog 类的实例被映射到 CATALOG 数据库表中的一行。需要映射的持久性类来指定它映射到的表的主键列。主键列映射到持久性类中的标识符属性。使用 <id/> 元素指定主键列和标识符属性。 column 属性指定主键列； name 属性指定被映射的持久性类中的标识符属性； type 属性指定 Hibernate 类型。 <id/> 元素的 <generator/> 子元素指定主键生成策略。一些内置的生成策略可用，不同的关系数据库支持不同的 ID 生成策略。

由于我们使用 MySQL 数据库，它支持使用 AUTO_INCREMENT 的标识列，我们可以使用生成策略为 identity 或 本机。标识列是 INTEGER 类型的表列，具有 AUTO_INCREMENT 和 PRIMARY KEY< /code> 或 UNIQUE KEY 指定，例如 id INTEGER AUTO_INCREMENT PRIMARY KEY 或 id INTEGER AUTO_INCREMENT 唯一键。

使用 <property/> 元素添加 JavaBean 属性。持久性类中的 JavaBean 属性映射到数据库表的列。 <property/> 元素的 name 属性指定属性名称，并且是唯一必需的属性。 column 属性指定数据库表列名；默认列名是属性名。 type 属性指定 Hibernate 类型。如果未指定 type 属性，Hibernate 会查找类型，该类型可能与 JavaBean 类中指定的实际类型不完全相同。为了区分相似的 Hibernate 类型，建议您在 property 元素中指定类型。添加 <property/> 元素 journal, publisher, < edition、title 和 author 类型为 string 并映射到 JOURNAL、PUBLISHER、EDITION< /code>、TITLE 和 AUTHOR。 catalog.hbm.xml 映射文件在以下代码中列出：

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
  <class name="org.jboss.hibernate.model.Catalog" table="CATALOG">
    <id name="id" type="int" column="ID">
      <generator class="native" />
    </id>
    <property name="journal" column="JOURNAL" type="string" />
    <property name="publisher" column="PUBLISHER" type="string" />
    <property name="edition" column="EDITION" type="string" />
    <property name="title" column="TITLE" type="string" />
    <property name="author" column="AUTHOR" type="string" />
  </class>
</hibernate-mapping>

映射文件为jboss-hibernate项目中的，如下截图所示：

读书笔记《advanced-java-ee-development-with-wildfly》Hibernate4中的关系映射

Creating a properties file

Hibernate XML Mapping 文件定义了持久性或类与关系数据库的映射。用于连接到数据库的连接参数可以在属性文件或 XML 配置文件中配置，或两者兼而有之。要创建属性文件，请选择 File | 新 | 其他。在 New 向导中，选择 JBoss Tools Web | Properties File点击Next，如下图截屏：

新建文件属性向导开始。
在 Browser 上单击以获取 < strong>文件夹字段以选择文件夹。在文件夹选择中，选择jboss-hibernate | src | main | resources 文件夹并点击OK，如下图所示：
将 Name*指定为休眠。 properties 并点击Finish，如下图所示：

hibernate.properties 文件被添加到 resources 文件夹中。
在 hibernate.properties 表中，点击添加按钮添加属性，如下截图所示：
添加 hibernate.connection.driver_class 属性和值作为 com.mysql.jdbc.Driver 并点击 Finish，如下图所示：
同样，添加其他属性，如 hibernate.properties 表中所示。 hibernate.connection.url 属性指定连接 URL，hibernate.dialect 属性指定要用作的数据库方言MySQL5InnoDBDialect，如下图所示：

hibernate.properties 文件在以下代码中列出。 username 和 password 属性可以不同于列出的属性：

hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost:3306/test 
hibernate.connection.username=root 
hibernate.connection.password=mysql16 
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

Creating a Hibernate configuration file

Hibernate配置可以在Hibernate配置文件（cfg.xml）中指定span>，它的配置参数比属性文件多。

Note

可以使用属性文件或配置文件来指定配置，或者两者都可以使用。如果两者都提供，则配置文件会覆盖两者中指定的配置参数的属性文件。

Hibernate XML 配置文件比属性文件有以下优点：

Hibernate 配置文件在调整 Hibernate 缓存时更方便。 Hibernate 配置文件可以配置 Hibernate XML 映射文件。
要使用 SchemaExport 工具将模式导出到数据库，只需属性文件即可，但对于持久性类的对象/关系映射，Hibernate XML 配置文件是一个更好的选择。

以下是创建Hibernate 配置文件的步骤：

选择文件 | 新 | 其他。在 New 中，选择 Hibernate | Hibernate 配置文件 (cfg.xml) 并点击下一步，如以下屏幕截图所示：

创建休眠配置文件向导开始。
选择jboss-hibernate | src | main | resources 文件夹，指定文件名为 hibernate.cfg。 xml，点击Next，如下图所示：
在 Hibernate Configuration File 向导中，指定会话工厂名称（ HibernateSessionFactory）。会话工厂是用于生成 Hibernate 的客户端会话的工厂。会话工厂存储对象/关系映射的元数据。
选择 Database dialect as MySQL 5 （InnoDB）。选择 Driver class 作为 com.mysql.jdbc.Driver。
将 Connection URL 指定为 jdbc:mysql://localhost:3306/test。
指定用户名和密码并点击完成，如下图所示：

Hibernate 默认为会话中的持久性数据提供事务级缓存。 Hibernate 提供了一个默认关闭的查询级缓存来频繁运行查询。 Hibernate 还提供了 SessionFactory 级别或集群级别的二级缓存。二级缓存在 hibernate.cfg.xml 文件中使用 hibernate.cache.provider_class 属性进行配置。指定 <cache/> 映射的类默认启用二级缓存。可以通过将 cache.provider_class 属性设置为 org.hibernate.cache.NoCacheProvider 来关闭二级缓存。使用 <mapping/> 元素和 resource 属性设置为 catalog.hbm.xml。

hibernate.cfg.xml 文件在以下代码中列出：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
  <session-factory name="HibernateSessionFactory">
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">mysql16</property>
    <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
    <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
    <mapping resource="catalog.hbm.xml" />
  </session-factory>
</hibernate-configuration>

hibernate.cfg.xml 文件显示在 jboss-hibernate 项目文件夹中，如下：

Creating JSPs for CRUD

我们已经为 Hibernate 创建了所需的配置文件。接下来，我们将创建 JSP 来持久化、加载、更新和删除 POJO 域对象，也称为创建、读取、更新、删除（CRUD）。执行以下步骤来完成此操作：

选择文件 | 新 | Other，并在 New 中选择网络 | JSP 文件并点击下一步。
在 New JSP File 中，选择 webapp 文件夹并指定文件名为schemaExport.jsp。点击Next，如下图所示：
选择新建 JSP 文件(html) 模板，也是默认的，点击Finish。 schemaExport.jsp 文件被添加到 webapp 文件夹中。
同理，使用add.jsp（添加表格数据）、find.jsp（查找表格数据）、update.jsp（更新表格行）和 delete.jsp（删除表格行）。

jboss-hibernate 项目的目录结构显示在以下截图。 JSP 文件可能指示错误，随着应用程序的开发和 Maven 依赖项的添加，该错误将得到修复。

Creating the JavaBean class

在这个部分中，我们创建要持久化到数据库的JavaBean 类。为此，请执行以下步骤：

选择文件 | 新 | Other，然后在 New 向导中，选择类并点击下一步。
在 New Java Class 向导中，将 Source folder 指定为 < code class="literal">jboss-hibernate/src/main/java 并指定 Package 为 org.jboss.hibernate.model。将 Name 指定为 Catalog 并在 Interfaces< /strong>，添加java.io.Serializable。点击Finish，如下图所示：

org.jboss.hibernate.model.Catalog 类被添加到 jboss-hibernate 项目中。在 Catalog 类中，声明 Integer 类型的 id 属性。 id 属性是映射到 ID 列在 catalog.hbm.xml 文件中指定的 CATALOG 表中。添加 journal、publisher、edition、title 和 author 属性 字符串 类型。添加无参数构造函数和具有所有属性作为参数的构造函数。为属性添加 getter/setter 方法。

Catalog 持久性类在以下代码中列出：

package org.jboss.hibernate.model;
import java.io.Serializable;

public class Catalog implements Serializable {
  /** identifier field */
  private Integer id;
  /** nullable persistent field */
  private String journal;
  /** nullable persistent field */
  private String publisher;
  /** nullable persistent field */
  private String edition;
  /** nullable persistent field */
  private String title;
  /** nullable persistent field */
  private String author;
  
  /** full constructor */
  public Catalog(String journal, String publisher, String edition,
  String title, String author) {
    this.journal = journal;
    this.publisher = publisher;
    this.edition = edition;
    this.title = title;
    this.author = author;
  }
  
  /** default constructor */
  public Catalog() {
  }
  
  public Integer getId() {
    return this.id;
  }
  
  public void setId(Integer id) {
    this.id = id;
  }
  
  public String getJournal() {
    return this.journal;
  }
  
  public void setJournal(String journal) {
    this.journal = journal;
  }
  
  public String getPublisher() {
    return this.publisher;
  }
  
  public void setPublisher(String publisher) {
    this.publisher = publisher;
  }
  
  public String getEdition() {
    return this.edition;
  }
  
  public void setEdition(String edition) {
    this.edition = edition;
  }
  
  public String getTitle() {
    return this.title;
  }
  
  public void setTitle(String title) {
    this.title = title;
  }
  
  public String getAuthor() {
    return this.author;
  }
  
  public void setAuthor(String author) {
    this.author = author;
  }
}

org.jboss.hibernate.model.Catalog 类显示在 jboss-hibernate 项目中，如下图所示：

Exporting schema

在这个部分中，我们在 schemaExport.jsp JSP 中导出模式。我们将在后面的部分运行 schemaExport.jsp。导入 org.hibernate.cfg.Configuration 和 org.hibernate.tool.hbm2ddl.SchemaExport Hibernate 类。 org.hibernate.cfg.Configuration 对象是一个仅初始化时间的对象，用于配置属性和映射文件。使用无参数构造函数创建 Configuration 类的实例，并使用配置 hibernate.cfg.xml Hibernate XML 配置文件configure 方法如下代码所示：

Configuration cfg=new Configuration();
cfg.configure("hibernate.cfg.xml");

org.hibernate.tool.hbm2ddl.SchemaExport 类是一个将表模式导出到数据库的命令行工具，也可以从应用程序中调用。使用将 Configuration 对象作为参数的构造函数创建 SchemaExport 的实例。指定我们使用 hibernate.cfg.xml 文件创建的 Configuration 对象。以下是完成此操作的代码行：

SchemaExport schemaExport =new  SchemaExport(cfg);

设置用于创建数据库表的 DDL 脚本的输出文件.使用以下代码行来完成此操作：

schemaExport.setOutputFile("hbd2ddl.sql");

输出文件在 WildFly 安装的 bin 目录中生成。使用 create(boolean script,boolean export) 方法将架构导出到数据库。 script 参数指定是否将用于创建数据库表的 DDL 脚本输出到控制台。 export 参数指定是否要导出架构。 create 方法可以在 export 设置为 false 的情况下运行，以测试 DDL 脚本。这是封装本段讨论的代码：

schemaExport.create(true, true);

（可选）添加 out 语句以输出模式已导出的消息。 schemaExport.jsp 文件在以下代码中列出：

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ page import="org.hibernate.*,org.hibernate.cfg.Configuration,org.hibernate.tool.hbm2ddl.SchemaExport"%>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/xml; charset=windows-1252" />
    <title>Export Schema</title>
  </head>
  <body>
    <%
      Configuration cfg=new Configuration();
      cfg.configure("hibernate.cfg.xml"); 
      SchemaExport schemaExport =new  SchemaExport(cfg);
      schemaExport.setOutputFile("hbd2ddl.sql");
      schemaExport.create(true, true);
      out.println("Schema Exported");
  %>
    </body>
</html>

Creating table data

在将模式导出到数据库后，在 add.jsp 中，持久化 目录 POJO 域模型到数据库。在讨论 JSP 之后，我们将在后面的部分运行 schemaExport.jsp 和其他 JSP：

导入 org.jboss.hibernate.model 和 org.hibernate 包和 org.hibernate.cfg.Configuration 类。创建 Configuration 对象的实例并像在 hibernate.cfg.xml 文件>schemaExport.jsp。

创建 Catalog 类的实例，使用具有属性的 setter 方法的无参数构造函数或采用以下代码所示方式获取所有属性的参数构造函数：

Catalog catalog = new Catalog();
catalog.setId(1);
catalog.setJournal("Oracle Magazine");
catalog.setPublisher("Oracle Publishing");
catalog.setEdition("Jan-Feb 2004");
catalog.setTitle("Understanding Optimization");
catalog.setAuthor("Kimberly Floss");

使用 buildSessionFactory() 方法从 Configuration 对象创建 SessionFactory。 SessionFactory 包含 Configuration 中映射和属性文件的所有元数据。 Configuration 对象在 SessionFactory 创建后不使用。使用 openSession() 方法从 SessionFactory 对象创建一个 Session 对象. openSession 方法透明地实现了 JDBC。 JDBC 连接是由 Hibernate 在内部从 ConnectionProvider 获得的。我们使 Catalog 持久类可序列化，因为 Session 对象只有在持久类可序列化时才可序列化。 Session 对象是 Hibernate 的客户端接口。数据库的实际持久性是使用 Transaction 对象实现的。请参阅以下代码行，它将本段中的讨论付诸实践：
```
Session sess = sessionFactory.openSession();
```
使用返回 Transaction 对象的 beginTransaction() 方法开始客户端会话。 Transaction 对象代表一个全局事务。请参阅以下代码行，该代码行总结了此步骤中的讨论：
```
Transaction tx = sess.beginTransaction();
```
beginTransaction() 方法仅在需要时启动新的底层事务；否则它使用现有的事务。使用 save() 使 Catalog 实例与 Session 对象相关联方法，如下：
```
sess.save(catalog);
sess.save(catalog2);
```
save() 方法不会将 Catalog 实例存储到数据库中，而只会将 POJO 添加到 会话。要存储 Catalog 实例，请调用 Transactioncommit() 方法> 对象的方式如下代码所示：
```
tx.commit();
```

可选地输出一条消息以指示数据已添加到数据库中。 add.jsp 文件在以下代码中列出：

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ page import="org.jboss.hibernate.model.*,org.hibernate.*,java.util.List,org.hibernate.cfg.Configuration"%>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/xml; charset=windows-1252" />
    <title>Export Schema</title>
  </head>
  <body>
    <%
      Configuration cfg = new Configuration();
      cfg.configure("hibernate.cfg.xml"); 
      Catalog catalog = new Catalog();
      catalog.setId(1);
      catalog.setJournal("Oracle Magazine");
      catalog.setPublisher("Oracle Publishing");
      catalog.setEdition("Jan-Feb 2004");
      catalog.setTitle("Understanding Optimization");
      catalog.setAuthor("Kimberly Floss");

      Catalog catalog2 = new Catalog();
      catalog2.setId(2);
      catalog2.setJournal("Oracle Magazine");
      catalog2.setPublisher("Oracle Publishing");
      catalog2.setEdition("March-April 2005");
      catalog2.setTitle("Starting with Oracle ADF");
      catalog2.setAuthor("Steve Muench");
      SessionFactory sessionFactory = cfg.buildSessionFactory();
      Session sess = sessionFactory.openSession();
      Transaction tx = sess.beginTransaction();
      sess.save(catalog);
      sess.save(catalog2);
      tx.commit();
      out.println("Added");
    %>
  </body>
</html>

Retrieving table data

在本节中，我们查询数据库以查找持久对象的所有实例。 Hibernate 提供了 HQL，一种查询语言，它的语法类似于 SQL，但它是面向对象的。所有 HQL 命令的参考可在 https://docs.jboss.org/hibernate/orm/3.3/reference/en/html/queryhql.html。查询是在持久对象上进行的，即 Catalog 类实例，而不是在 CATALOG 数据库表上。要查询数据库以查找持久对象的所有实例，请执行以下步骤：

创建 String HQL 查询以获取 Catalog 类的所有实例：
```
String hqlQuery = "from Catalog";
```
创建并配置Configuration对象，创建SessionFactory对象，获取Session add.jsp 中讨论的 code> 对象
使用 的 createQuery(String) 方法从字符串 HQL 查询创建 Query 对象Session 对象，如下：
```
Query query = sess.createQuery(hqlQuery);
```
Query 对象是 Hibernate 查询的面向对象表示。使用 list() 方法获取 Hibernate 查询的结果，该方法返回 List。用于查询数据库的 SQL 由 Hibernate 内部实现。 Hibernate 查询不需要 Transaction 对象。 Transaction 对象只需要添加、更新或删除表行。

遍历 List 以输出查询结果。 find.jsp 文件在以下代码中列出：

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ page import="org.jboss.hibernate.model.*,org.hibernate.*,java.util.List,org.hibernate.cfg.Configuration"%>
<html>
  <head>
    <meta name="generator" content="HTML Tidy for Linux/x86 (vers 25 March 2009), see www.w3.org" />
    <meta http-equiv="Content-Type" content="text/xml; charset=us-ascii" />
    <title>
      Export Schema
    </title>
  </head>
  <body>
    <%
      String hqlQuery = "from Catalog";
      Configuration cfg = new Configuration();
      cfg.configure("hibernate.cfg.xml");
      SessionFactory sessionFactory = cfg.buildSessionFactory();
      Session sess = sessionFactory.openSession();
      Query query = sess.createQuery(hqlQuery);
      List list = query.list();
      for (int i = 0; i < list.size(); i++) {
        Catalog catalog = (Catalog) list.get(i);
        out.println("<br>");
        out.println("CatalogId " + catalog.getId() + " Journal: "+ catalog.getJournal());
        out.println("<br>");
        out.println("CatalogId " + catalog.getId() + " Publisher: " + catalog.getPublisher());
        out.println("<br>");
        out.println("CatalogId " + catalog.getId() + " Edition: "+ catalog.getEdition());
        out.println("<br>");
        out.println("CatalogId " + catalog.getId() + " Title "+ catalog.getTitle());
        out.println("<br>");
         out.println("CatalogId " + catalog.getId() + " Author: "+ catalog.getAuthor());
      }
      sess.close();
    %>
  </body>
</html>

Updating a table row

在本节中，我们将更新表格行。执行以下步骤来完成此操作：

创建一个 HQL 查询 String 并创建一个 Query 对象以生成 List 为讨论了 find.jsp。
获取List中的第一项，并用setPublisher()修改publisher的值代码>方法，如下：
```
Catalog catalog = (Catalog) list.get(0);
catalog.setPublisher("Oracle Magazine");
```
使用 beginTransaction() 方法创建一个 Transaction 对象，该对象表示与数据库的事务。使用 saveOrUpdateSession 中 Catalog 对象的持久状态> 方法。调用Transaction对象的commit()方法保存目录数据库中的实例。

（可选）输出一条消息以指示更新已完成：

Transaction tx = sess.beginTransaction();
sess.saveOrUpdate(catalog);
tx.commit();

update.jsp 列在以下代码中：

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" 	pageEncoding="ISO-8859-1"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ page import="org.jboss.hibernate.model.*,org.hibernate.*,java.util.List,org.hibernate.cfg.Configuration"%>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/xml; charset=windows-1252" />
    <title>Export Schema</title>
  </head>
  <body>
    <%
      String hqlQuery = "from Catalog";
      Configuration cfg = new Configuration();
      cfg.configure("hibernate.cfg.xml");
      SessionFactory sessionFactory = cfg.buildSessionFactory();
      Session sess = sessionFactory.openSession();
      Query query = sess.createQuery(hqlQuery);
      List list = query.list();
      Catalog catalog = (Catalog) list.get(0);
      catalog.setPublisher("Oracle Magazine");
      Transaction tx = sess.beginTransaction();
      sess.saveOrUpdate(catalog);
      tx.commit();
      out.println("Updated");
    %>
  </body>
</html>

Deleting a table row

在这个部分中，我们将从 CATALOG 表中删除一个表行。执行以下步骤来完成此操作：

使用以下代码行为 Catalog 实例创建 HQL 查询 String 以删除表行：

String hqlQuery = "from Catalog as catalog WHERE catalog.edition='March-April 2005'";

如在 find.jsp 和 update.jsp 中，为 List code class="literal">目录实例。由于只有一个 Catalog 实例的 edition 设置为 March-April 2005，我们只需要从 List 中获取第一个 Catalog 实例。为此，请使用以下代码：
```
Catalog catalog = (Catalog) list.get(0);
```
使用 beginTransaction() 创建一个 Transaction 对象。
使用 delete 方法从 Session 中删除 Catalog 实例，该方法不会'不要从数据库中删除 Catalog 实例。调用Transaction对象的commit()方法保存Session数据库中的状态，这会从 CATALOG 表中删除相应的表行。

或者，使用以下代码，输出一条消息以指示删除：

sess.delete(catalog);
tx.commit();

delete.jsp 文件在以下代码中列出：

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ page import="org.jboss.hibernate.model.*,org.hibernate.*,java.util.List,org.hibernate.cfg.Configuration"%>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/xml; charset=windows-1252" />
    <title>Export Schema</title>
  </head>
  <body>
    <%
     String hqlQuery = "from Catalog as catalog WHERE catalog.edition='March-April 2005'";
      Configuration cfg = new Configuration();
     cfg.configure("hibernate.cfg.xml");
     SessionFactory sessionFactory = cfg.buildSessionFactory();
     Session sess = sessionFactory.openSession();
     Query query = sess.createQuery(hqlQuery);
     List list = query.list();
     Catalog catalog = (Catalog) list.get(0);
     Transaction tx = sess.beginTransaction();
     sess.delete(catalog);
     tx.commit();
      out.println("Deleted");
    %>
    </body>
</html>

Maven项目的目录结构如下图所示：

Installing the Maven project

在本节中，我们将使用 Maven 构建工具编译和打包 Hibernate Web 应用程序。 WildFly 8提供了一些API，例如Common Annotations API、Hibernate验证器API和CDI API。我们需要将MySQL JDBC连接器依赖添加到pom.xml里面<dependencies/> 元素。要完成此操作，请使用以下代码：

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.28</version>
</dependency>

Hibernate 在组 ID org.hibernate 中提供与 Hibernate 相关的工件。包括下表中列出的 Hibernate 工件：

人工制品	描述
`休眠核心`	这是 Hibernate API 的主要工件。
`休眠注释`	这是用于注释元数据。
`hibernate-commons-annotations`	这与 Hibernate 的 EJB 3 样式注释有关。
`hibernate-ehcache`	这为二级缓存提供了缓存。
`hibernate-c3p0`	这是 C3P0 连接池库。
`antlr`	这是解析器生成器。
`hibernate-cglib-repack`	这是 CGLIB 代码生成库，也表示 ASM 依赖项。
`休眠工具`	这提供了生成各种 Hibernate 源构件的工具，例如映射文件和 Java 实体。
`休眠环境`	这用于对持久类进行审计和版本控制。
`hibernate-jpamodelgen`	这是一个用于生成 JPA 2 静态元模型类的注释处理器。第 1 章中的 Catalog 实体，EJB 3.x 入门是 JPA 2 元模型类的一个示例。

Maven 编译器插件用于编译项目源代码，Maven WAR 插件收集所有依赖项、类和资源并生成 WAR 存档。在maven-war-plugin的配置中，指定WAR文件的输出目录，outputDirectory 元素为 C:\JBossAS8\wildfly-8.0.0.CR1\standalone\deployments。 EAR、WAR 和 JAR 文件在 deployments 目录被部署到 WildFly 应用服务器。 jboss-hibernate 项目的 pom.xml 文件可在本章的代码下载中找到。

接下来，我们安装 Maven 项目。右键单击 pom.xml 并选择 Run As | Maven 安装，如下图所示：

Maven 项目被编译，jboss-hibernate.war 归档被生成并输出到 deployments 目录，如下图所示：

启动 WildFly 8 服务器。 jboss-hibernate.war 文件被部署到服务器，MySQL 数据源也被部署。持久性单元启动。 jboss-hibernate.war 显示在 WildFly Administration Console 中，如下图所示：

Running a schema export

在本节中，我们将在 WildFly 应用服务器上运行 schemaExport.jsp 以将架构导出到MySQL 数据库。为此，请执行以下步骤：

在浏览器中调用 URL http://localhost:8080/jboss-hibernate/schemaExport.jsp，如以下屏幕截图所示。架构被导出到 MySQL 数据库。

服务器上 schemaExport.jsp 的输出如以下代码所示：

10:57:23,589 INFO  [org.hibernate.cfg.Configuration] (default task-8) HHH000041:
 Configured SessionFactory: HibernateSessionFactory
10:57:23,590 INFO  [org.hibernate.dialect.Dialect] (default task-8) HHH000400: U
sing dialect: org.hibernate.dialect.MySQL5InnoDBDialect
10:57:23,592 INFO  [org.hibernate.tool.hbm2ddl.SchemaExport] (default task-8) HH
H000227: Running hbm2ddl schema export
10:57:23,761 WARN  [org.hibernate.engine.jdbc.connections.internal.DriverManager
ConnectionProviderImpl] (default task-8) HHH000402: Using Hibernate built-in con
nection pool (not for production use!)
10:57:23,841 INFO  [org.hibernate.engine.jdbc.connections.internal.DriverManager
ConnectionProviderImpl] (default task-8) HHH000401: using driver [com.mysql.jdbc
.Driver] at URL [jdbc:mysql://localhost:3306/test]
10:57:23,842 INFO  [org.hibernate.engine.jdbc.connections.internal.DriverManager
ConnectionProviderImpl] (default task-8) HHH000046: Connection properties: {user
=root, password=****}
10:57:23,843 INFO  [org.hibernate.engine.jdbc.connections.internal.DriverManager
ConnectionProviderImpl] (default task-8) HHH000006: Autocommit mode: false
10:57:23,843 INFO  [org.hibernate.engine.jdbc.connections.internal.DriverManager
ConnectionProviderImpl] (default task-8) HHH000115: Hibernate connection pool si
ze: 20 (min=1)
10:57:24,035 INFO  [stdout] (default task-8)
10:57:24,036 INFO  [stdout] (default task-8)     drop table if exists CATALOG
10:57:24,038 INFO  [stdout] (default task-8)
10:57:24,038 INFO  [stdout] (default task-8)     create table CATALOG (
10:57:24,038 INFO  [stdout] (default task-8)         ID integer not null auto_in
crement,
10:57:24,039 INFO  [stdout] (default task-8)         JOURNAL varchar(255),
10:57:24,039 INFO  [stdout] (default task-8)         PUBLISHER varchar(255),
10:57:24,039 INFO  [stdout] (default task-8)         EDITION varchar(255),
10:57:24,039 INFO  [stdout] (default task-8)         TITLE varchar(255),
10:57:24,039 INFO  [stdout] (default task-8)         AUTHOR varchar(255),
10:57:24,040 INFO  [stdout] (default task-8)         primary key (ID)
10:57:24,040 INFO  [stdout] (default task-8)     ) ENGINE=InnoDB
10:57:27,224 INFO  [org.hibernate.engine.jdbc.connections.internal.DriverManager
ConnectionProviderImpl] (default task-8) HHH000030: Cleaning up connection pool
[jdbc:mysql://localhost:3306/test]
10:57:27,225 INFO  [org.hibernate.tool.hbm2ddl.SchemaExport] (default task-8) HHH000230: Schema export complete

在 MySQL 命令行中运行 DESC CATALOG 命令获取 CATALOG 表，如下图所示：

Creating table rows

在这个部分中，我们会将表数据添加到 CATALOG 表中。调用 URL http://localhost:8080/jboss-hibernate/add.jsp，如以下屏幕截图所示。表数据被添加。

数据被添加到 CATALOG 表中。 MySQL 命令行中的 SELECT 查询以以下屏幕截图所示的方式列出 CATALOG 表：

Retrieving table data

在这个部分，我们将运行 find.jsp 来获取并显示 CATALOG 表数据。调用 URL http://localhost:8080/jboss-hibernate/find.jsp，如以下屏幕截图所示。 CATALOG 表数据在浏览器中输出。

Updating the table

在本节中，我们将更新CATALOG表。调用 URL http://localhost:8080/jboss-hibernate/update.jsp，如以下屏幕截图所示。 CATALOG 表得到更新。

运行find.jsp得到并显示更新后的CATALOG 表数据。调用 URL http://localhost:8080/jboss-hibernate/find.jsp，如下图所示：

Deleting the table row

在本节中，我们将使用 delete.jsp 文件删除表格行。为此，请执行以下步骤：

调用 URL http://localhost:8080/jboss-hibernate/delete.jsp，如以下屏幕截图所示。 CATALOG 中删除了一个表行。
再次运行 find.jsp 以列出更新后的 CATALOG 表并删除了一行。浏览器中的输出显示在以下屏幕截图中：

Summary

在本章中，我们使用 Hibernate API 创建了一个 CRUD 应用程序。我们使用 hibernate.cfg.xml 配置了 Hibernate。我们将持久性类 Catalog 映射到 MySQL 数据库表，映射在 catalog.hbm.xml 中指定。我们使用 Maven 构建工具编译并打包了 Hibernate Web 应用程序。我们在 WildFly 8 服务器上运行 Web 应用程序以将模式导出到 MySQL 数据库并创建、检索、更新和删除表数据。我们使用硬编码的 set、get、update 和 delete 操作，但可以使用用户界面创建更动态的 CRUD 应用程序。在下一章中，我们将讨论如何在 WildFly 8 中开发 Java Server Faces (JSF)。

vlambda博客
学习文章列表