4. JPA 简要介绍

我们将通过几个示例来介绍 JPA（Java 持久化 API）。JPA 在以下课程中进行了讲解：

《Java 5 持久化实践：[http://tahe.developpez.com/java/jpa]》——该课程提供了使用 JPA 构建数据访问层的工具

4.1. JPA在分层架构中的定位

建议读者重读本文开头（第 2 段），其中阐述了 JPA 层在分层架构中的作用。JPA 层位于数据访问层之中：

[DAO]层与JPA规范进行交互。无论由何种产品实现该规范，JPA 层向 [DAO] 层展示的接口均保持一致。接下来，我们将介绍一些来自 [ref1] 的示例，这些示例将帮助我们构建自己的 JPA 层。

4.2. JPA - 示例

4.2.1. 示例 1 - 单张表的对象表示

4.2.1.1. 表 [personne]

假设有一个数据库，其中包含一个名为 [personne] 的表，其作用是存储一些关于个人的信息：

`ID`	表的主键
`VERSION`	表中该行的版本号。每当该人的信息发生修改时，其版本号就会递增。
`NOM`	人员姓名
`PRENOM`	其名字
`DATENAISSANCE`	出生日期
`MARIE`	整数 0（未婚）或 1（已婚）
`NBENFANTS`	该人的子女数

4.2.1.2. 实体 [Personne]

我们处于以下运行环境中：

JPA [5] 层必须在 [7] 数据库的关系世界与由 Java 程序 [4] 操作的对象世界之间建立桥梁369ZQX所处理的对象世界之间建立桥梁。这种连接是通过配置实现的，主要有两种方式：

使用 XML 文件。在 JDK 1.5 版本推出之前，这几乎是唯一的方法
自 JDK 1.5 起，通过 Java 注解

本文将仅使用第二种方法。

前文所述的 [personne] 表的 [Personne] 映像对象可能如下所示：


...

@SuppressWarnings("unused")
@Entity
@Table(name="Personne")
public class Personne implements Serializable{

    @Id
    @Column(name = "ID", nullable = false)
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;

    @Column(name = "VERSION", nullable = false)
    @Version
    private int version;

    @Column(name = "NOM", length = 30, nullable = false, unique = true)
    private String nom;

    @Column(name = "PRENOM", length = 30, nullable = false)
    private String prenom;

    @Column(name = "DATENAISSANCE", nullable = false)
    @Temporal(TemporalType.DATE)
    private Date datenaissance;

    @Column(name = "MARIE", nullable = false)
    private boolean marie;

    @Column(name = "NBENFANTS", nullable = false)
    private int nbenfants;

    // 制造商
    public Personne() {
    }

    public Personne(String nom, String prenom, Date datenaissance, boolean marie,
            int nbenfants) {
        setNom(nom);
        setPrenom(prenom);
        setDatenaissance(datenaissance);
        setMarie(marie);
        setNbenfants(nbenfants);
    }

    // toString
    public String toString() {
...
    }

    // 获取器和设置器
...
}

配置通过 Java @Annotation 注解实现。 Java注解可在编译时由编译器处理，也可在运行时由专用工具处理。除第3行面向编译器的注解外，此处所有注解均面向所使用的JPA实现（即Hibernate或Toplink）。因此，这些注解将在运行时被利用。若缺乏能够解析这些注解的工具，这些注解将被忽略。因此，上文中的 [Personne] 类可在非 JPA 环境中被调用。

在关联表 T 的 C 类中使用 JPA 注解时，需区分以下两种情况：

表 T 已存在：此时 JPA 注释必须复现现有内容（列名与定义、完整性约束、外键、主键等）
表 T 不存在，并将根据类 C 中找到的注解进行创建。

情况 2 最容易处理。借助 JPA 注解，我们可以指定所需的表 T 结构。情况 1 通常更为复杂。表 T 可能是在很久以前、脱离任何 JPA 上下文的情况下构建的。因此，其结构可能与JPA的关系型/面向对象桥梁不匹配。为简化起见，我们假设处于情况2，即与类C关联的表T将根据类C的注解JPA创建。

下面对类 [Personne] 的注解进行说明：

第 4 行：@Entity 注解是第一个必不可少的注解。它位于声明类的行之前，表明该类应由持久层 JPA 管理。如果没有此注解，所有其他注解 JPA 都将被忽略。
第5行：@Table注解用于指定该类所表示的数据库表。其主要参数是name，用于指定表名。如果省略该参数，表将采用类名，即[Personne]。因此，在本例中，@Table注解是多余的。
第 8 行：@Id 注解用于指定类中作为表主键映射的字段。该注解是必填的。此处表明第 11 行中的 id 字段是表主键的映射。
第 9 行：@Column 注解用于建立类中字段与该字段所映射的表列之间的关联。name 属性指定表中列的名称。若未指定该属性，则列名与字段名相同。因此，在本例中，name 参数并非必需。 nullable=false 参数表示与该字段关联的列不能为空（即不能取值为 NULL），因此该字段必须有值。
第 10 行：注释 @GeneratedValue 说明了当主键由 SGBD 自动生成时，其生成方式。在所有示例中均采用此方式。这并非强制要求。因此，我们的“person”实体可能拥有一个用作主键的学生编号，该编号并非由 SGBD 生成，而是由应用程序设定。在这种情况下，注解 @GeneratedValue 将不存在。 strategy参数指定了当主键由SGBD生成时，其生成方式。并非所有SGBD都采用相同的主键值生成技术。例如：

`Firebird`	在每次插入前都会调用一个值生成器
`SQL server`	主键字段被定义为类型 Identity。其效果与 Firebird 的值生成器类似，只是主键值需在行插入完成后才确定。
`Oracle`	使用名为 SEQUENCE 的对象，该对象同样充当值生成器

JPA层必须根据不同的SGBD生成不同的SQL命令，以创建值生成器。通过配置，向其指定了需要管理的 SGBD 类型。因此，它能够识别该 SGBD 的主键值生成常规策略。参数 strategy = GenerationType.AUTO 指示 JPA 层必须使用该常规策略。在本文档的所有示例中，该技术对所使用的七个 SGBD 均有效。

第 14 行：@Version 注解指定了用于管理对表中同一行并发访问的字段。

为理解[personne]表中同一行数据并发访问的问题，假设某个Web应用程序允许更新某人的信息，并分析以下情况：

在时间点 T1，用户 U1 进入某人 P 的修改界面。此时，子女数量为 0。他将该数字改为1，但在提交修改之前，用户U2进入同一人员P的编辑界面。由于U1尚未提交修改， U2 在屏幕上看到子女数为 0。U2 将人员 P 的姓名改为大写。随后，U1 和 U2 按此顺序提交了修改。最终生效的是 U2 的修改：在数据库中，姓名将变为大写，而子女数量仍保持为零，尽管 U1 认为自己已将其改为 1。

“人员版本”的概念有助于解决此问题。我们继续使用相同的用例：

在时间点 T1，用户 U1 进入对人员 P 的修改界面。此时，子女数量为 0，版本号为 V1。他将子女数改为1，但在提交修改前，用户U2进入同一人员P的编辑界面。由于U1尚未提交修改， U2 看到的子女数为 0，版本号为 V1。U2 将人员 P 的姓名改为大写。随后，U1 和 U2 按此顺序提交了修改。在提交修改前，系统会验证修改人员 U1 是否持有与当前已记录人员 P 相同的版本。该用户确实持有相同版本。因此其修改被接受，随后将该人员的版本号从 V1 更改为 V2，以标记该人员已发生变更。在验证 U2 的修改时，将发现 U2 持有人员 P 的版本 V1，而当前该人员的版本为 V2。此时，我们可以告知用户U2，有人在他之前进行了操作，他必须基于人员P的新版本重新开始。他将照做，获取版本为V2的人员P（该人员现在已有一个孩子），将姓名改为大写，并提交。如果已保存的P仍处于版本V2，则其修改将被接受。最终，U1和U2所做的修改都将被保留，而在没有版本控制的用例中，其中一项修改会丢失。

客户端应用程序的 [DAO] 层可以自行管理 [Personne] 类的版本。每当对象 P 发生修改时，该对象在表中的版本号将递增 1。通过 @Version 注解，可以将此管理职责转移至 JPA 层。相关字段完全不必像示例中那样命名为 version，可以是任意名称。

与注解 @Id 和 @Version 对应的字段是因持久化需求而存在的。如果类 [Personne] 无需持久化，则无需这些字段。由此可见，根据对象是否需要持久化，其表示形式会有所不同。

第 17 行：再次使用 @Column 注解，用于提供与类 Personne 的字段 nom 关联的表 [personne] 的列信息。此处出现了两个新参数：
- unique=true 表示人员姓名必须唯一。这将在数据库中体现为：在表 [personne] 的 NOM 列上添加唯一性约束。
- length=30 将列 NOM 的字符数设置为 30。这意味着该列的类型将为 VARCHAR(30)。
第 24 行：注解 @Temporal 用于指定日期/时间类型的列/字段应采用哪种 SQL 类型。类型 TemporalType.DATE 表示仅包含日期且不包含时间。其他可能的类型包括用于编码时间的 TemporalType.TIME，以及用于编码带时间日期的 TemporalType.TIMESTAMP。

现在我们来分析 [Personne] 类的其余代码：

第 6 行：该类实现了 Serializable 接口。对象的 sérialisation 操作是指将其转换为一串二进制位。désérialisation 则是该操作的逆向操作。序列化/反序列化主要应用于客户端/服务器应用程序，其中对象通过网络进行交换。客户端或服务器端应用程序无需了解此操作，该操作由 JVM 透明地完成。但要实现这一功能，交换对象的类必须使用关键字 Serializable 进行“标记”。
第 37 行：该类的构造函数。请注意，id 和 version 字段不属于参数。实际上，这两个字段由 JPA 层管理，而非由应用程序管理。
第 51 行及之后：类中各个字段的 get 和 set 方法。需要注意的是，JPA 注解可以放置在字段的 get 方法上，而不是直接放置在字段本身。注解的位置决定了 JPA 访问字段时应采用的模式：
- 如果注解位于字段级别，JPA 将直接访问字段进行读写
- 如果注解位于 get 方法级别，JPA 将通过 get/set 方法访问字段以进行读写

正是 @Id 注解的位置决定了类中 JPA 注解的位置。若置于字段级别，则表示直接访问字段；若置于类级别，则表示通过 set 和 get 方法访问字段。其他注解应与 @Id 注解采用相同的放置方式。

4.2.2. JPA层的配置

JPA 层的测试可采用以下架构：

在 [7] 中：该数据库将基于实体 [Personne] 的注解以及在名为 [persistence.xml] 的文件中进行的补充配置生成
[5, 6]：由Hibernate实现的JPA层
生成 [4]：实体 [Personne]
[3]：一个控制台类型的测试程序

JPA 层的配置由文件 [META-INF/persistence.xml] 负责：

运行时，系统会在应用程序的 Classpath 中查找 [META-INF/persistence.xml] 文件。

让我们查看项目中 [persistence.xml] 文件中配置的 JPA 层：


<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence">
    <persistence-unit name="jpa" transaction-type="RESOURCE_LOCAL">
        <!--  提供者 -->
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
        <properties>
            <!-- 持久化类 -->
            <property name="hibernate.archive.autodetection" value="class, hbm" />
            <!-- 日志SQL
                <property name="hibernate.show_sql" value="true"/>
                <property name="hibernate.format_sql" value="true"/>
                <property name="use_sql_comments" value="true"/>
            -->
            <!-- 连接JDBC -->
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/jpa" />
            <property name="hibernate.connection.username" value="jpa" />
            <property name="hibernate.connection.password" value="jpa" />
            <!--  自动创建模式 -->
            <property name="hibernate.hbm2ddl.auto" value="create" />
            <!-- 方言 -->
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
            <!-- 属性 DataSource c3p0 -->
            <property name="hibernate.c3p0.min_size" value="5" />
            <property name="hibernate.c3p0.max_size" value="20" />
            <property name="hibernate.c3p0.timeout" value="300" />
            <property name="hibernate.c3p0.max_statements" value="50" />
            <property name="hibernate.c3p0.idle_test_period" value="3000" />
        </properties>
    </persistence-unit>
</persistence>

要理解这一配置，我们需要回顾应用程序的数据访问架构：

文件 [persistence.xml] 将配置以下层：[4, 5, 6]
[4]：JPA的Hibernate实现
[5]：Hibernate 通过连接池访问数据库。连接池是一组已与 SGBD 建立连接的连接。一个 SGBD 实例可能被多个用户访问，但出于性能考虑，其同时打开的连接数不能超过上限 N。编写良好的代码会在最短时间内与 SGBD 建立连接：它发送 SQL 命令，然后关闭连接。每当需要操作数据库时，它都会重复这一过程。建立和关闭连接的开销不容忽视，而连接池的作用正体现在此。在应用程序启动时，连接池会与 SGBD 建立 N1 个连接。当应用程序需要连接时，将向该池请求一个已建立的连接。一旦应用程序不再需要该连接，便会将其归还给连接池，且应尽可能快地归还。该连接不会被关闭，而是保持可用状态，供下一位用户使用。因此，连接池是一种已建立连接的共享系统。
[6]：SGBD所使用的驱动程序JDBC

现在让我们看看文件 [persistence.xml] 是如何配置上述 [4, 5, 6] 层的：

第 2 行：文件 XML 的根标签是 <persistence>。
第 3 行：<persistence-unit> 用于定义持久化单元。可以存在多个持久化单元。每个单元都有一个名称（name 属性）和一个事务类型（transaction-type 属性）。应用程序将通过其名称（此处为 jpa）访问该持久化单元。事务类型 RESOURCE_LOCAL 表示应用程序将自行管理与 SGBD 相关的事务。本例中即采用此方式。当应用程序在 EJB3 容器中运行时，可使用该容器的事务服务。在此情况下，应设置 transaction-type=JTA（Java事务 API）。当 transaction-type 属性缺失时，默认值为 JTA。
第5行：<provider>标签用于定义一个实现[javax.persistence.spi.PersistenceProvider]接口的类，该接口允许应用程序初始化持久层。由于我们使用的是 JPA / Hibernate 实现，因此此处使用的类是 Hibernate 类。
第 6 行：<properties> 标签引入了针对所选特定 provider 的专属属性。因此，根据所选的 Hibernate、Toplink、Kodo 等，属性会有所不同。以下属性专属于 Hibernate。
第 8 行：要求 Hibernate 扫描项目中的 classpath，查找带有 @Entity 注解的类以便进行管理。 @Entity类也可以通过<class>nom_de_la_classe</class>标签进行声明，该标签直接位于<persistence-unit>标签之下。这就是我们在provider / Toplink中将要采用的做法。
第 10-12 行（此处已注释）用于配置 Hibernate 的控制台日志：
- 第 10 行：用于控制是否显示 Hibernate 在 SGBD 上发出的 SQL 命令。这在学习阶段非常有用。由于关系型/对象型的桥梁作用，应用程序在持久化对象上运行，并对这些对象执行 [persist, merge, remove] 类型的操作。了解这些操作实际生成的 SQL 命令非常有意义。通过研究这些命令，我们逐渐能够推测出当对持久化对象执行特定操作时，Hibernate将生成的SQL命令，从而在脑海中逐渐形成对关系/对象桥接机制的清晰认知。
- 第 11 行：控制台上显示的 SQL 命令可以进行美观的格式化，以便于阅读
- 第 12 行：显示的 SQL 命令还将添加注释
第15-19行定义了JDBC层（在架构中为[6]层）：
- 第 15 行：SGBD 的驱动程序类 JDBC，此处为 MySQL5
- 第 16 行：所用数据库的 URL
- 第 17、18 行：连接用户及其密码
第22行：Hibernate需要知道它面前的SGBD。事实上，所有SGBD都带有专有的SQL扩展名，这是一种管理主键值自动生成的独特方式， ……这导致 Hibernate 必须知道当前正在处理的 SGBD，以便向其发送该对象能够理解的 SQL 指令。 [MySQL5InnoDBDialect] 指代 SGBD MySQL5，其包含支持事务的 InnoDB 类型表。
第 24-28 行配置连接池 c3p0（架构中的 [5] 层）：
- 第24、25行：连接池中的最小（默认3）和最大连接数（默认15）。默认初始连接数为3。
- 第26行：等待客户端连接请求的最大时长（以毫秒为单位）。超过此时间，c3p0将向客户端抛出异常。
- 第27行：为了访问BD，Hibernate使用预编译的SQL命令（PreparedStatement），c3p0可以将其缓存。这意味着，如果应用程序再次请求一个已缓存的预编译 SQL 语句，则无需重新预编译（预编译一个 SQL 语句是有成本的），而是直接使用缓存中的语句。此处指定了缓存中可容纳的已准备 SQL 命令的最大数量，涵盖所有连接（一个已准备的 SQL 命令属于一个连接）。
- 第28行：以毫秒为单位，检查连接有效性的频率。连接池中的连接可能因各种原因失效（例如驱动程序JDBC因连接超时而使其失效，或驱动程序JDBC存在“错误”等）。
第20行：此处要求在持久化单元初始化时，生成@Entity对象的数据库映射。Hibernate现已具备所有工具，可发出生成数据库表的命令：
- @Entity 对象的配置使其能够确定需要生成的表
- 第 15-18 行和第 24-28 行使其能够建立与 SGBD 的连接
- 第 22 行使其能够确定生成表时应使用的 SQL 方言

因此，此处使用的 [persistence.xml] 文件会在每次应用程序重新运行时重建一个全新的数据库。如果表已存在，则先将其删除（drop table），然后重新创建（create table）。需要注意的是，这显然不适用于生产环境中的数据库……

4.2.3. 示例 2：一对多关系

4.2.3.1. 数据库模式

1

2


    alter table jpa06_article 
        drop 
        foreign key FKFFBDD9D8ECCE8750;

    drop table if exists jpa06_article;

    drop table if exists jpa06_categorie;

    create table jpa06_article (
        id bigint not null auto_increment,
        version integer not null,
        nom varchar(30),
        categorie_id bigint not null,
        primary key (id)
    ) ENGINE=InnoDB;

    create table jpa06_categorie (
        id bigint not null auto_increment,
        version integer not null,
        nom varchar(30),
        primary key (id)
    ) ENGINE=InnoDB;

    alter table jpa06_article 
        add index FKFFBDD9D8ECCE8750 (categorie_id), 
        add constraint FKFFBDD9D8ECCE8750 
        foreign key (categorie_id) 
references jpa06_categorie (id);

在 [1] 数据库中，以及在 [2] 中，其 DDL (MySQL5)

一个商品 A(id, version, name) 仅属于一个类别 C(id, version, name)。一个类别 C 可以包含 0、1 或多个商品。这里存在一对多关系（类别 -> 商品）及其逆向的多对一关系（商品 -> 类别）。该关系通过表 [article] 对表 [categorie] 的外键实现（参见 DDL 的第 24-28 行）。

4.2.3.2. 代表数据库的 @Entity 对象

一个商品由以下 @Entity [Article] 表示：


package entites;

...
@Entity
@Table(name="jpa05_hb_article")
public class Article implements Serializable {

    // 字段
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @SuppressWarnings("unused")
    @Version
    private int version;

    @Column(length = 30)
    private String nom;

    // 主关系 产品 (多) -> 类别 (一)
    // 通过 Article 中的外键 (categorie_id) 实现
    // 1 个商品必须有 1 个分类（可为空=false）
    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name = "categorie_id", nullable = false)
    private Categorie categorie;

    // 构造函数
    public Article() {
    }

    // 获取器和设置器
    ...
    // toString
    public String toString() {
        return String.format("Article[%d,%d,%s,%d]", id, version, nom, categorie.getId());
    }

}

第 9-11 行：@Entity 的主键
第13-15行：其版本号
第 17-18 行：文章名称
第20-25行：将@Entity Article与@Entity Categorie关联的多对一关系：
- 第 23 行：注解 ManyToOne。 “Many”指当前所在的@Entity Article，“One”指@Entity Categorie（第25行）。一个类别（One）可以包含多个商品（Many）。
- 第 24 行：注解 ManyToOne 定义了表 [article] 中的外键列。该列名为 categorie_id，且每行都必须在此列中包含一个值。
- 第 25 行：商品所属的类别。当商品被放入持久化上下文时，要求其类别不要立即被放入（fetch=FetchType.LAZY，第 23 行）。尚不清楚此要求是否有意义。我们拭目以待。

一个类别由以下 @Entity [Categorie] 表示：


package entites;
...
@Entity
@Table(name="jpa05_hb_categorie")
public class Categorie implements Serializable {

    // 字段
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @SuppressWarnings("unused")
    @Version
    private int version;

    @Column(length = 30)
    private String nom;

    // 关系“文章（多）→ 分类（一）”的反向关系“分类（一）→ 文章（多）”
    // 级联插入：分类 -> 插入文章
    // 级联更新 分类 -> 更新文章
    // 类别 -> 文章的删除级联
    @OneToMany(mappedBy = "categorie", cascade = { CascadeType.ALL })
    private Set<Article> articles = new HashSet<Article>();

    // 构造函数
    public Categorie() {
    }

    // 获取器和设置器
...
    // toString
    public String toString() {
        return String.format("Categorie[%d,%d,%s]", id, version, nom);
    }

    // 类别 <--> 文章的双向关联
    public void addArticle(Article article) {
        // 将商品添加到该类别的商品集合中
        articles.add(article);
        // 文章更改分类
        article.setCategorie(this);
    }
}

第 8-11 行：@Entity 的主键
第12-14行：其版本号
第16-17行：类别名称
第 19-24 行：该类别的文章集合（set）
- 第 23 行：注解 @OneToMany 表示一对多关系。 “One”指代当前所在的@Entity [Categorie]，“Many”指代第24行的类型[Article]：一个（One）类别包含多个（Many）文章。
- 第23行：该注解是注解ManyToOne的反向关系（mappedBy），该注解位于@Entity Article的字段categorie上： mappedBy=categorie。位于@Entity Article的categorie字段上的关系ManyToOne是主关系。它是必不可少的。它实现了将 @Entity Article 与 @Entity Categorie 关联的外键关系。定义在 @Entity Categorie 的 articles 字段上的 OneToMany 关系是反向关系。该关系并非必需。这是为了方便获取某类别的文章。如果没有这一便利，这些文章将通过查询 JPQL 来获取。
- 第 23 行：cascadeType.ALL 要求对 @Entity Categorie 执行的操作（persist、merge、remove）应级联到其文章上。
- 第 24 行：某类别的商品将被放入一个 Set<Article> 类型的对象中。Set 类型不接受重复项。因此，不能将同一件商品放入 Set<Article> 对象中两次。什么是“同一件商品”？为了表示商品 a 与商品 b 相同，Java 使用表达式 a.equals(b)。在所有类的父类 Object 中，如果 a==b，则 a.equals(b) 为真，即 c.a.d。如果对象 a 和 b 具有相同的内存位置。我们可能希望表示，如果对象 a 和 b 具有相同的名称，则它们是相同的。在这种情况下，开发人员必须在 [Article] 类中重定义两个方法：
equals：当两个对象名称相同时，该方法应返回true
hashCode：当两个对象 [Article] 被 equals 方法视为相同时，该方法应返回相同的整数值。在此情况下，该值将根据文章名称生成。 hashCode 返回的值可以是任意整数。该值用于各种对象容器中，特别是哈希表（Hashtable）。

关系 OneToMany 可以使用除 Set 以外的其他类型来存储“多”方，例如 List 对象。本文档中将不讨论这些情况。读者可在 [ref1] 中找到相关内容。

第 38 行：方法 [addArticle] 允许我们将一篇文章添加到某个类别中。该方法会自动更新连接 [Categorie] 与 [Article] 的 OneToMany 关系的两端。

4.3. JPA 层中的 API

让我们详细说明客户端 JPA 的运行环境：

我们知道，JPA 层通过 [2] 创建了一个 [3] 对象与 [4] 关系之间的桥梁。在该对象/关系桥接框架下，由 JPA 层管理的所有对象统称为“持久化上下文”。要访问持久化上下文中的数据，JPA [1] 客户端必须通过 JPA [2] 层：

它可创建一个对象，并请求 JPA 层将其持久化。此时，该对象即成为持久化上下文的一部分。
它可向 [JPA] 层请求现有持久化对象的引用。
他可以修改从 JPA 层获取的持久化对象。
它可以请求 JPA 层从持久化上下文中删除一个对象。

JPA 层向客户端提供了一个名为 [EntityManager] 的接口，顾名思义，该接口用于管理持久化上下文中的 @Entity 对象。下面介绍该接口的主要方法：

`void persist(Object entity)`	将 entity 放入持久化上下文
`void remove(Object entity)`	将 entity 从持久化上下文中移除
`<T> T merge(T entity)`	将持久化上下文未管理的客户端对象 entity 与持久化上下文中具有相同主键的对象 entity 合并。生成的结果是持久化上下文中的对象 entity。
`<T> T find(Class<T> entityClass, Object primaryKey)`	将通过主键在数据库中检索到的对象。该对象的类型 T 使 JPA 层确定应查询哪个表。由此创建的持久化对象将返回给客户端。
`Query createQuery(String queryText)`	根据 JPQL 查询（Java Persistence 查询语言)。如果，只是它查询的是对象而非表。
`Query createNativeQuery(String queryText)`	与前一个方法类似，只是 queryText 是 SQL 而非 JPQL。
`Query createNamedQuery(String name)`	与 createQuery 相同的方法，只是 JPQL queryText 命令已外包至配置文件并关联了一个名称。该名称即为该方法的参数。

一个 EntityManager 对象的生命周期未必与应用程序的生命周期一致。它有开始和结束。因此，一个 JPA 客户端可以依次与不同的 EntityManager 对象进行交互。与 EntityManager 关联的持久化上下文与其具有相同的生命周期。二者密不可分。当 EntityManager 对象关闭时，其持久化上下文会在必要时与数据库同步，随后便不复存在。若要重新获得持久化上下文，必须创建一个新的 EntityManager。

客户端 JPA 可以通过以下语句创建一个 EntityManager，从而建立一个持久化上下文：


EntityManagerFactory emf = Persistence.createEntityManagerFactory("nom d'une unité de persistance");

javax.persistence.Persistence 是一个静态类，用于获取 EntityManager 对象的工厂。该工厂与特定的持久化单元相关联。需要提醒的是，配置文件 [META-INF/persistence.xml] 用于定义持久化单元，且这些单元都有一个名称：


    <persistence-unit name="elections-dao-jpa-mysql-01PU" transaction-type="RESOURCE_LOCAL">

上文中的持久化单元名为 elections-dao-jpa-mysql-01PU。该单元附带其专属的完整配置，特别是与其协同工作的 SGBD。指令 [Persistence.createEntityManagerFactory("elections-dao-jpa-mysql-01PU")] 创建了一个 EntityManagerFactory 类型的对象工厂，该工厂能够提供 EntityManager 对象，用于管理与名为 elections-dao-jpa-mysql-01PU 的持久化上下文。获取 EntityManager 对象（即持久化上下文）需通过 EntityManagerFactory 对象，具体操作如下：

        EntityManager em = emf.createEntityManager();

[EntityManager] 接口中的以下方法可用于管理持久化上下文的生命周期：

`void close()`	关闭持久化上下文。强制持久化上下文与数据库同步：如果上下文中的某个对象不在数据库中，则通过操作 SQL INSERT 将其插入数据库如果上下文中的某个对象已存在于数据库中，且自读取以来已被修改，则执行操作 SQL UPDATE 以保存该修改如果上下文中的某个对象在执行 remove 操作后被标记为“已删除”，则执行 SQL DELETE 操作将其从数据库中删除。
`void clear()`	持久化上下文中的所有对象已被清空，但尚未关闭。
`void flush()`	持久化上下文将按照 close() 中描述的方式与数据库同步

客户端 JPA 可通过方法 [EntityManager] 强制将持久化上下文与数据库进行同步（如前文 flush 所述）。同步可以是显式的，也可以是隐式的。在第一种情况下，由客户端在需要同步时执行 flush 操作；否则，同步将在我们后续说明的特定时刻自动进行。同步模式由 [EntityManager] 接口的以下方法管理：

`void setFlushMode(FlushModeType flushMode)`	flushmode 有两种可能的值： FlushModeType.AUTO（默认）：在 SELECT： FlushModeType.COMMIT：仅在数据库事务结束时才进行。
`FlushModeType getFlushMode()`	返回当前的同步模式

总结一下。在默认模式 FlushModeType.AUTO 下，持久化上下文将在以下时刻与数据库同步：

每次数据库操作之前
数据库事务结束时
在持久化上下文中执行 flush 或 close 操作之后

在 FlushModeType.COMMIT 模式下，情况相同，但操作 1 不会发生。与 JPA 层交互的标准模式是事务模式。客户端在事务内部对持久化上下文执行各种操作。在此情况下，持久化上下文与数据库的同步时机在 AUTO 模式下对应上述情况 1 和 2，而在 COMMIT 模式下仅对应情况 2。

最后介绍查询接口（Query）中的API，该接口可用于向持久化上下文发出JPQL命令，或直接向数据库发出SQL命令以检索数据。 Query 接口如下：

1 - 方法 getResultList 执行一个 SELECT，该方法返回多个对象。这些对象将存储在一个 List 对象中。该对象是一个接口。该接口提供了一个 Iterator 对象，可用于以以下形式遍历列表 L 中的元素：


        Iterator iterator = L.iterator();
        while (iterator.hasNext()) {
             // 调用表示列表中当前元素的对象 iterator.next()
...
}

列表 L 也可通过 for 进行操作：


        for (Object o : L) {
             // 调用对象 o
}

2 - 方法 getSingleResult 执行命令 JPQL / SQL / SELECT，该命令返回一个单一对象。
3 - 方法 executeUpdate 执行 SQL 命令（更新或删除），并返回该操作所涉及的行数。
4 - 方法 setParameter(String, Object) 用于为已配置的 JPQL 命令中的命名参数赋值
5 - 方法 setParameter(int, Object) 中的参数并非通过名称指定，而是通过其在 JPQL 命令中的位置来指定。

4.4. 查询 JPQL

JPQL（Java持久化查询语言）是JPA层的查询语言。JPQL语言与数据库的SQL语言相关。 SQL 处理的是表，而 JPQL 处理的是这些表中的图像对象。我们将通过以下架构中的一个示例进行探讨：

我们将该数据库命名为 [dbrdvmedecins2] ，它是一个包含四个表的 MySQL5 数据库：

该数据库汇集了用于管理某医生团队预约的信息。

4.4.1. 表 [MEDECINS]

该表包含关于医生的信息。

ID：医生标识号——该表的主键
VERSION：表中该行的版本标识号。每次对该行进行修改时，该数字都会增加 1。
NOM：医生姓名
PRENOM：其名字
TITRE：其称谓（小姐、女士、先生）

4.4.2. 表 [CLIENTS]

各医生的患者信息存储在表 [CLIENTS] 中：

ID：客户标识号——该表的主键
VERSION：标识表中该行版本的编号。每次对该行进行修改时，该数字会递增1。
NOM：客户姓名
PRENOM：客户名字
TITRE：其称谓（小姐、女士、先生）

4.4.3. 表 [CRENEAUX]

该表列出了可进行 RV 操作的时间段：

ID：时间段标识号——该表的主键（第8行）
VERSION：表中该行的版本标识号。每次对该行进行修改时，该数字会递增1。
ID_MEDECIN：标识该时段所属医生的编号——MEDECINS(ID)列的外键。
HDEBUT：时段开始时间
MDEBUT：时段开始分钟
HFIN：时段结束时间
MFIN：时段结束分钟

例如，表 [CRENEAUX]（参见上文 [1]）的第二行显示，第 2 号时段于 8 点 20 分开始，8 点 40 分结束，并归属于第 1 号医生（玛丽女士 PELISSIER）。

4.4.4. 表 [RV]

该表列出了每位医生所分配的 RV：

ID：唯一标识RV的编号——主键
JOUR：RV的日期
ID_CRENEAU：RV的时间段——作为外键关联至[ID]字段（该字段位于[CRENEAUX]表中）——同时确定了时间段和相关医生。
ID_CLIENT：预订对象的客户编号——作为表[CLIENTS]中字段[ID]的外键

该表的对关联列（JOUR、ID_CRENEAU）的值施加了唯一性约束：

ALTER TABLE RV ADD CONSTRAINT UNQ1_RV UNIQUE (JOUR, ID_CRENEAU);

如果表[RV]中某行具有值 (JOUR1, ID_CRENEAU1) 作为列 (JOUR, ID_CRENEAU) 的值，则该值在其他任何地方都不能出现。否则，这意味着同一时间针对同一位医生生成了两个 RV。从 Java 编程的角度来看，当这种情况发生时，数据库中的 JDBC 驱动程序会触发一个 SQLException。

id 行值为 3（参见上文的 [1]），表示在 2006 年 8 月 23 日，第 20 个时段和第 4 号客户被分配了一个 RV。 [CRENEAUX]表显示，第20号时段对应16:20-16:40的时间段，由第1号医生（Marie女士，PELISSIER）负责。表[CLIENTS]显示，第4号客户是布里吉特·BISTROU女士。

4.4.5. 数据库生成

要创建并填充这些表，可以使用脚本 [dbrdvmedecins2.sql]。使用 [WampServer] 时，操作步骤如下：

在 [1] 中，点击 [WampServer] 图标，然后选择 [PhpMyAdmin] [2] 选项，
在 [3] 中，在弹出的窗口中，选择链接 [Bases de données]，

转为 [2]，创建一个数据库，将其命名为 [4]，编码设为 [5]，
在 [7] 中，数据库已创建。点击其链接，

在 [8] 中，导入一个文件 SQL，
通过按钮在文件系统中指定该文件 [9]，

在 [11] 中，选择脚本 SQL，并在 [12] 中执行它，
在 [13] 中，数据库的四个表已创建完成。点击其中一个链接，

在 [14] 中，显示了表的内容。

此后，我们将不再提及该数据库。但建议读者通过程序的执行过程关注其演变，尤其是在程序无法正常运行时。

4.4.6. [JPA]层

让我们回到示例的架构：

现在我们开始构建 [JPA] 层的 Maven 项目。

4.4.7. NetBeans 项目

如下所示：

在 [1] 中，构建一个类型为 [Java Application] [2] 的 Maven 项目，
在 [3] 中，为项目命名，

在 [4] 中，生成的项目。

4.4.8. 生成 [JPA] 层

让我们回到需要构建的架构：

借助 NetBeans，可以自动生成 [JPA] 层。了解这些自动生成方法很有意义，因为生成的代码为编写 JPA 实体提供了宝贵的参考。

4.4.9. 创建 NetBeans 与数据库的连接

运行 SGBD MySQL 5 以使 BD 可用，
在 [dbrdvmedecins2] 数据库上创建 NetBeans 连接，

在 [Services] [1] 选项卡中，在分支 [Databases] [2] 中，选择驱动程序 JDBC MySQL [3]，
然后选择选项 [4] “Connect Using”，用于建立与数据库 MySQL 的连接，
在 [5] 处，输入所需的信息。在 [6] 处输入数据库名称，在 [7] 处输入数据库用户名及其密码，
在 [8] 中，可验证所提供的信息，
在 [9] 中，若信息正确，将显示预期提示信息，

在 [10] 中，连接已建立。可以看到所连接数据库中的四个表。

4.4.10. 创建持久化单元

让我们回到正在构建的架构：

我们正在构建 [JPA] 层。该层的配置在 [persistence.xml] 文件中完成，其中定义了持久化单元。每个单元都需要以下信息：

数据库访问参数（JDBC，包括URL、用户名、密码），
将作为数据库表映射的类，
所使用的实现（JPA）。实际上，JPA 是一项由多种产品实现的规范。在此，我们将使用 Hibernate。

NetBeans可以通过向导生成此持久化文件。

右键单击项目并选择创建持久化单元 [1]，
在 [2] 中，创建一个持久化单元，

在 [3] 中，为创建的持久化单元命名，
在 [4] 中，选择 JPA Hibernate 实现（JPA 2.0），
在 [5] 中，指定 BD 中的表已创建，因此不再创建。确认向导，
在 [6] 中，新项目
在 [7] 中，文件 [persistence.xml] 已生成在文件夹 [META-INF] 中，
在 [8] 中，Maven 项目已添加了新的依赖项。

生成的 [META-INF/persistence.xml] 文件如下：


<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  <persistence-unit name="mv-rdvmedecins-jpql-hibernatePU" transaction-type="RESOURCE_LOCAL">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <properties>
      <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/dbrdvmedecins2"/>
      <property name="javax.persistence.jdbc.password" value=""/>
      <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
      <property name="javax.persistence.jdbc.user" value="root"/>
      <property name="hibernate.cache.provider_class" value="org.hibernate.cache.NoCacheProvider"/>
    </properties>
  </persistence-unit>
</persistence>

该文件包含向导中提供的信息：

第 3 行：持久化单元的名称，
第 3 行：数据库事务类型。此处 RESOURCE_LOCAL 表示应用程序将自行管理事务，
第 6-9 行：数据源的 JDBC 属性。

在“[Design]”选项卡中，可以全面查看 [persistence.xml] 文件：

为了获取 Hibernate 日志，我们按以下方式补充 [persistence.xml] 文件：


<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  <persistence-unit name="mv-rdvmedecins-jpql-hibernatePU" transaction-type="RESOURCE_LOCAL">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <properties>
      <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/dbrdvmedecins2"/>
      <property name="javax.persistence.jdbc.password" value=""/>
      <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
      <property name="javax.persistence.jdbc.user" value="root"/>
      <property name="hibernate.cache.provider_class" value="org.hibernate.cache.NoCacheProvider"/>
      <property name="hibernate.show_sql" value="true"/>
      <property name="hibernate.format_sql" value="true"/>      
    </properties>
  </persistence-unit>
</persistence>

第11行：请求查看Hibernate生成的SQL命令，
第12行：此属性可实现对这些命令的格式化显示。

项目中已添加了依赖项。文件 [pom.xml] 内容如下：


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>istia.st</groupId>
  <artifactId>mv-rdvmedecins-jpql-hibernate</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>mv-rdvmedecins-jpql-hibernate</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>4.1.2</version>
    </dependency>
    <dependency>
      <groupId>org.jboss.logging</groupId>
      <artifactId>jboss-logging</artifactId>
      <version>3.1.0.GA</version>
    </dependency>
    <dependency>
      <groupId>org.jboss.spec.javax.transaction</groupId>
      <artifactId>jboss-transaction-api_1.1_spec</artifactId>
      <version>1.0.0.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>4.1.2</version>
    </dependency>
    <dependency>
      <groupId>antlr</groupId>
      <artifactId>antlr</artifactId>
      <version>2.7.7</version>
    </dependency>
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate.javax.persistence</groupId>
      <artifactId>hibernate-jpa-2.0-api</artifactId>
      <version>1.0.1.Final</version>
    </dependency>
    <dependency>
      <groupId>org.javassist</groupId>
      <artifactId>javassist</artifactId>
      <version>3.15.0-GA</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate.common</groupId>
      <artifactId>hibernate-commons-annotations</artifactId>
      <version>4.0.1.Final</version>
    </dependency>
  </dependencies>
</project>

新增的依赖项均与 Hibernate 相关。我们将为 MySQL 添加 JDBC 驱动程序的依赖项：


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

4.4.11. 生成 JPA 实体

JPA 实体可通过 NetBeans 向导生成：

在 [1] 中，从数据库创建 JPA 实体，

生成 [2]，选择之前创建的连接 [dbrdvmedecins2]，
在 [3] 中，选择关联数据库中的所有表，

在 [4] 中，为与这四个表关联的 Java 类命名，
以及包名 [5]，
在 [6] 中，JPA 将 BD 中的表行聚合到集合中。我们选择列表作为集合，

在 [7] 中，由向导生成的 Java 类。

4.4.12. 生成的 JPA 实体

实体 [Medecin] 是表 [medecins] 的映射。Java 类中充斥着大量注解，导致代码乍看之下难以理解。若仅保留理解该实体作用所必需的内容，则得到以下代码：


package rdvmedecins.jpa;

...
@Entity
@Table(name = "medecins")
public class Medecin implements Serializable {
  
@Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "ID")
  private Long id;
  
  @Column(name = "TITRE")
  private String titre;

  @Column(name = "NOM")
  private String nom;

  @Column(name = "VERSION")
  private int version;

  @Column(name = "PRENOM")
  private String prenom;

  @OneToMany(cascade = CascadeType.ALL, mappedBy = "idMedecin")
  private List<Creneau> creneauList;

// 构造函数
....

   // 获取器和设置器
....

  @Override
  public int hashCode() {
  ...
  }

  @Override
  public boolean equals(Object object) {
  ...
  }

  @Override
  public String toString() {
    ...
  }
  
}

第 4 行，@Entity 注解将类 [Medecin] 定义为实体 JPA、c.a.d。一个通过 API 和 JPA 与 BD 表关联的类，
第 5 行，BD 表的名称，该表与实体 JPA 相关联。表中的每个字段都对应 Java 类中的一个字段，
第 6 行，该类实现了 Serializable 接口。这在客户端/服务器应用程序中是必要的，因为实体会在客户端和服务器之间进行序列化。
第 10-11 行：类 [Medecin] 的 id 字段对应于表 [medecins] 中的字段 [ID]（第 10 行），
第 13-14 行：类 [Medecin] 的 titre 字段对应于表 [medecins] 中的 [TITRE] 字段（第 13 行），
第16-17行：类[Medecin]的“名称”字段对应于表[medecins]中的字段[NOM]（第16行），
第 19-20 行：类 [Medecin] 的 version 字段对应于表 [medecins] 中的 [VERSION] 字段（第 19 行）。在此，向导未能识别该列实际上是一个版本列，该列应在所属行每次修改时递增。为赋予其此功能，需添加 @Version 注释。我们将在后续步骤中进行此操作，
第22-23行：类[Medecin]中的prenom字段对应于表[medecins]中的[PRENOM]字段，
第 10-11 行：id 字段对应于该表的主键 [ID]。第 8-9 行的注解对此进行了说明，
第 8 行：注解 @Id 表示被注解的字段与表的主键相关联，
第 9 行：[JPA] 层将生成其插入到 [Medecins] 表中的行所对应的primary key。有多种策略可供选择。此处策略 GenerationType.IDENTITY 表示，层 JPA 将使用表 MySQL 的模式 auto_increment，
第25-26行：表[creneaux]对表[medecins]设置了外键。一个时段属于一位医生。反之，一位医生则关联有多个时段。因此，这是一种“一对多”关系（即一位医生对应多个时段），该关系由注释 @OneToMany 通过 JPA 进行限定（第25行）。第26行的字段将包含该医生的所有时段。这无需编程即可实现。为了完全理解第25行，我们需要介绍类[Creneau]。

该类定义如下：


package rdvmedecins.jpa;

import java.io.Serializable;
import java.util.List;
import javax.persistence.*;
import javax.validation.constraints.NotNull;

@Entity
@Table(name = "creneaux")
public class Creneau implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "ID")
  private Long id;

  @Column(name = "MDEBUT")
  private int mdebut;

  @Column(name = "HFIN")
  private int hfin;

  @Column(name = "HDEBUT")
  private int hdebut;

  @Column(name = "MFIN")
  private int mfin;

  @Column(name = "VERSION")
  private int version;

  @JoinColumn(name = "ID_MEDECIN", referencedColumnName = "ID")
  @ManyToOne(optional = false)
  private Medecin idMedecin;

  @OneToMany(cascade = CascadeType.ALL, mappedBy = "idCreneau")
  private List<Rv> rvList;

// 构造函数
...
// getter 和 setter
...

  @Override
  public int hashCode() {
    ...
  }

  @Override
  public boolean equals(Object object) {
    ...
  }

  @Override
  public String toString() {
    ...
  }
  
}

我们仅对新注释进行说明：

我们曾提到，表 [creneaux] 拥有指向表 [medecins] 的外键：一个时段与一位医生相关联。多位医生可以关联多个时段。表 [creneaux] 与表 [medecins] 之间存在一种关系，该关系被定义为多对一（多个时段对应一名医生）。第32行中的注释 @ManyToOne 用于限定外键，
第31行带有注释@JoinColumn，明确了外键关系：表 [creneaux] 的列 [ID_MEDECIN] 是表 [medecins] 的列 [ID] 的外键，
第 33 行：指向该时段所属医生的引用。此处同样无需编程即可获取。

因此，实体 [Creneau] 与实体 [Medecin] 之间的外键关系通过以下两条注释体现：

在实体 [Creneau] 中：


@JoinColumn(name = "ID_MEDECIN", referencedColumnName = "ID")
  @ManyToOne(optional = false)
private Medecin idMedecin;

在实体 [Medecin] 中：


@OneToMany(cascade = CascadeType.ALL, mappedBy = "idMedecin")
private List<Creneau> creneauList;

这两个注释反映了相同的关系：即表 [creneaux] 到表 [medecins] 的外键关系。我们说它们是彼此的逆关系。只有关系 @ManyToOne 是必不可少的。它明确地定义了外键关系。关系 @OneToMany 是可选的。如果存在，它仅引用与其关联的关系 @ManyToOne。这就是实体 [Medecin] 第 1 行中 mappedBy 属性的含义。该属性的值是实体 [Creneau] 中那个带有 @ManyToOne 注释的字段名称，该注释指定了外键。同样在实体 [Medecin] 的第 1 行中，属性 cascade=CascadeType.ALL 确定了实体 [Medecin] 相对于实体 [Creneau] 的行为：

如果向数据库中插入新的实体 [Medecin]，则第 2 行字段中的实体 [Creneau] 也必须被插入，
如果修改数据库中的实体 [Medecin]，则第 2 行字段中的实体 [Creneau] 也必须被修改，
如果从数据库中删除实体 [Medecin]，则第 2 行字段中的实体 [Creneau] 也必须被删除。

由于另外两个实体的代码未引入新的标记，因此在此不作特别说明。

实体 [Client]


package rdvmedecins.jpa;

...
@Entity
@Table(name = "clients")
public class Client implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "ID")
  private Long id;

  @Column(name = "TITRE")
  private String titre;

  @Column(name = "NOM")
  private String nom;

  @Column(name = "VERSION")
  private int version;

  @Column(name = "PRENOM")
  private String prenom;

  @OneToMany(cascade = CascadeType.ALL, mappedBy = "idClient")
  private List<Rv> rvList;

// 构造函数
...
// getter 和 setter
...

  @Override
  public int hashCode() {
    ...
  }

  @Override
  public boolean equals(Object object) {
    ...
  }

  @Override
  public String toString() {
    ...
  }
  
}

第24-25行反映了表[rv]与表[clients]之间的外键关系。

实体 [Rv]：


package rdvmedecins.jpa;

...
@Entity
@Table(name = "rv")
public class Rv implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "ID")
  private Long id;

  @Column(name = "JOUR")
  @Temporal(TemporalType.DATE)
  private Date jour;

  @JoinColumn(name = "ID_CRENEAU", referencedColumnName = "ID")
  @ManyToOne(optional = false)
  private Creneau idCreneau;

  @JoinColumn(name = "ID_CLIENT", referencedColumnName = "ID")
  @ManyToOne(optional = false)
  private Client idClient;

   // 构造函数
...

   // getter 和 setter
...

  @Override
  public int hashCode() {
    ...
  }

  @Override
  public boolean equals(Object object) {
    ...
  }

  @Override
  public String toString() {
    ...
  }
  
}

第13行定义了Java类型字段“日”的Date。说明在表[rv]中，列[JOUR]（第12行）的类型为日期（不含时间），
第16-18行：定义了表[rv]与表[creneaux]之间的外键关系，
第20-22行：定义了表[rv]与表[clients]之间的外键关系。

通过自动生成实体 JPA，我们可以获得一个工作基础。有时这已足够，有时则不然。本例即属后者：

需要为各实体的版本字段添加 @Version 注解，
需要编写比生成的方法更明确的 toString 方法，
实体 [Medecin] 和 [Client] 性质相似。我们将让它们继承自类 [Personne]，
我们将删除 @OneToMany 关系（作为 @ManyToOne 关系的反向关系）。这些关系并非必需，且会增加编程复杂度，
我们将移除 @NotNull 对主键的验证。当将实体 JPA 与 MySQL 进行持久化时，原始实体的主键为 null。只有在数据写入数据库后，被持久化的元素的主键才会获得具体值。

根据这些规范，各类定义如下：

Personne 类用于表示医生和客户：


package rdvmedecins.jpa;

import java.io.Serializable;
import javax.persistence.*;

@MappedSuperclass
public class Personne implements Serializable {
  private static final long serialVersionUID = 1L;
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "ID")
  private Long id;

  @Basic(optional = false)
  @Column(name = "TITRE")
  private String titre;

  @Basic(optional = false)
  @Column(name = "NOM")
  private String nom;

  @Basic(optional = false)
  @Column(name = "VERSION")
  @Version
  private int version;
  
  @Basic(optional = false)
  @Column(name = "PRENOM")
  private String prenom;
// 构造函数
...

// getter 和 setter
  ...

  @Override
  public String toString() {
    return String.format("[%s,%s,%s,%s,%s]", id, version, titre, prenom, nom);
  }
  
}

第 6 行：请注意，类 [Personne] 本身并非实体 (@Entity)。它将作为实体的父类。注解 @MappedSuperClass 指明了这种情况。

实体 [Client] 封装了表 [clients] 的行。它继承自前面的类 [Personne]：


package rdvmedecins.jpa;

import java.io.Serializable;
import javax.persistence.*;

@Entity
@Table(name = "clients")
public class Client extends Personne implements Serializable {
  private static final long serialVersionUID = 1L;

// 构造函数
...

  @Override
  public int hashCode() {
...
  }

  @Override
  public boolean equals(Object object) {
  ...
  }

  @Override
  public String toString() {
    return String.format("Client[%s,%s,%s,%s]", getId(), getTitre(), getPrenom(), getNom());
  }
  
}

第 6 行：类 [Client] 是一个 JPA 实体，
第 7 行：它与表 [clients] 相关联，
第 8 行：它继承自类 [Personne]。

封装表 [medecins] 行数据的实体 [Medecin] 遵循相同的模式：


package rdvmedecins.jpa;

import java.io.Serializable;
import javax.persistence.*;

@Entity
@Table(name = "medecins")
public class Medecin extends Personne implements Serializable {
  private static final long serialVersionUID = 1L;

  // 构造函数
...

  @Override
  public int hashCode() {
    ...
  }

  @Override
  public boolean equals(Object object) {
    ...
  }

  @Override
  public String toString() {
    return String.format("Médecin[%s,%s,%s,%s]", getId(), getTitre(), getPrenom(), getNom());
  }
  
}

实体 [Creneau] 封装了表 [creneaux] 的行：


package rdvmedecins.jpa;

import java.io.Serializable;
import java.util.List;
import javax.persistence.*;

@Entity
@Table(name = "creneaux")
public class Creneau implements Serializable {

  private static final long serialVersionUID = 1L;
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Basic(optional = false)
  @Column(name = "ID")
  private Long id;
  
  @Basic(optional = false)
  @Column(name = "MDEBUT")
  private int mdebut;
  
  @Basic(optional = false)
  @Column(name = "HFIN")
  private int hfin;
  
  @Basic(optional = false)
  @NotNull
  @Column(name = "HDEBUT")
  private int hdebut;
  
  @Basic(optional = false)
  @Column(name = "MFIN")
  private int mfin;
  
  @Basic(optional = false)
  @Column(name = "VERSION")
  @Version
  private int version;
  
  @JoinColumn(name = "ID_MEDECIN", referencedColumnName = "ID")
  @ManyToOne(optional = false)
  private Medecin medecin;

  // 构造函数
  ...

  // getter 和 setter
  ...
 
  @Override
  public int hashCode() {
    ...
  }

  @Override
  public boolean equals(Object object) {
    // TODO：警告——如果 id 字段未设置，此方法将无法工作
    ...
  }

  @Override
  public String toString() {
    return String.format("Creneau [%s, %s, %s:%s, %s:%s,%s]", id, version, hdebut, mdebut, hfin, mfin, medecin);
  }
}

第 40-42 行建模了数据库中表 [creneaux] 与表 [medecins] 之间存在的“多对一”关系：一名医生拥有多个时段，而一个时段仅属于一名医生。

实体 [Rv] 封装了表 [rv] 的行：


package rdvmedecins.jpa;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.*;

@Entity
@Table(name = "rv")
public class Rv implements Serializable {

  private static final long serialVersionUID = 1L;
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Basic(optional = false)
  @Column(name = "ID")
  private Long id;
  
  @Basic(optional = false)
  @Column(name = "JOUR")
  @Temporal(TemporalType.DATE)
  private Date jour;
  
  @JoinColumn(name = "ID_CRENEAU", referencedColumnName = "ID")
  @ManyToOne(optional = false)
  private Creneau creneau;
  
  @JoinColumn(name = "ID_CLIENT", referencedColumnName = "ID")
  @ManyToOne(optional = false)
  private Client client;

   // 构造函数
...

   // 获取器和设置器
...

  @Override
  public int hashCode() {
    ...
  }

  @Override
  public boolean equals(Object object) {
    ...
  }

  @Override
  public String toString() {
    return String.format("Rv[%s, %s, %s]", id, creneau, client);
  }
}

第27-29行建模了[rv]表与[clients]表之间存在的“多对一”关系（一个客户可能出现在多个 Rv 中），而第 23-25 行则描述了表 [rv] 与表 [creneaux] 之间存在的“多对一”关系（一个时段可能出现在多个 Rv 中）。

4.4.13. 数据访问代码

现在，我们将通过 JPA 层向项目中添加数据访问代码：

[MainJpql] 类如下：


package rdvmedecins.console;

import java.util.Scanner;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class MainJpql {

  public static void main(String[] args) {
    // EntityManagerFactory
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("mv-rdvmedecins-jpql-hibernatePU");
    // entityManager
    EntityManager em = emf.createEntityManager();
    // 键盘扫描器
    Scanner clavier = new Scanner(System.in);
    // 查询输入循环JPQL
    System.out.println("Requete JPQL sur la base dbrdvmedecins2 (* pour arrêter) :");
    String requete = clavier.nextLine();
    while (!requete.trim().equals("*")) {
      try {
        // 查询结果显示
        for (Object o : em.createQuery(requete).getResultList()) {
          System.out.println(o);
        }
      } catch (Exception e) {
        System.out.println("L'exception suivante s'est produite : " + e);
      }
      // 清空持久化上下文
      em.clear();
      // 新查询
      System.out.println("---------------------------------------------");
      System.out.println("Requete JPQL sur la base dbrdvmedecins2 (* pour arrêter) :");
      requete = clavier.nextLine();
    }
    // 关闭资源
    em.close();
    emf.close();
  }
}

第 12 行：创建与之前创建的持久化单元关联的 EntityManagerFactory。方法 createEntityManagerFactory 的参数即为该持久化单元的名称：


  <persistence-unit name="mv-rdvmedecins-jpql-hibernatePU" transaction-type="RESOURCE_LOCAL">
    ...
</persistence-unit>

第 14 行：创建管理持久层的方法 EntityManager，
第 19 行：输入查询 JPQL select，
第23-28行：显示查询结果，
第20行：当用户输入*时，输入操作停止。

问题：请给出能够获取以下信息的 JPQL 查询：

按姓名降序排列的医生列表
标题为“Mr”的医生列表
佩利西耶女士的预约时段列表
已预约的就诊时间列表（按日期升序排列）
2006年8月24日预约了RV的客户（姓名）列表
2006年8月24日PELISSIER女士的客户数量
未预约的客户
未预约的医生

我们将参考[ref1]第2.7段的示例。以下是一个执行示例：

Requete JPQL sur la base dbrdvmedecins2 (* pour arrêter) :
select c from Client c
Hibernate: 
    select
        client0_.ID as ID2_,
        client0_.NOM as NOM2_,
        client0_.PRENOM as PRENOM2_,
        client0_.TITRE as TITRE2_,
        client0_.version as version2_ 
    from
        clients client0_
Client[1,Mr,Jules,MARTIN]
Client[2,Mme,Christine,GERMAN]
Client[3,Mr,Jules,JACQUARD]
Client[4,Melle,Brigitte,BISTROU]

第2行：查询JPQL，
第3-11行：对应的查询SQL，
第12-15行：查询JPQL的结果。

4.5. 持久化上下文与 SGBD 之间的关联

4.5.1. Personne 类

package entites;

...

@Entity
@Table(name = "jpa01_personne")
public class Personne {

  @Id
  @Column(name = "ID", nullable = false)
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Integer id;

  @Column(name = "VERSION", nullable = false)
  @Version
  private int version;

  @Column(name = "NOM", length = 30, nullable = false, unique = true)
  private String nom;

  @Column(name = "PRENOM", length = 30, nullable = false)
  private String prenom;

  @Column(name = "DATENAISSANCE", nullable = false)
  @Temporal(TemporalType.DATE)
  private Date datenaissance;

  @Column(name = "MARIE", nullable = false)
  private boolean marie;

  @Column(name = "NBENFANTS", nullable = false)
  private int nbenfants;

   // 构造函数

  public Personne() {
  }

  public Personne(String nom, String prenom, Date datenaissance, boolean marie, int nbenfants) {
    setNom(nom);
    setPrenom(prenom);
    setDatenaissance(datenaissance);
    setMarie(marie);
    setNbenfants(nbenfants);
  }

   // toString

  public String toString() {
    return String.format("[%d,%d,%s,%s,%s,%s,%d]", getId(), getVersion(), getNom(), getPrenom(), 
                         new SimpleDateFormat("dd/MM/yyyy").format(getDatenaissance()), isMarie(), getNbenfants());
  }

   // 获取器和设置器
...
}

4.5.2. 测试程序

package tests;

....
import entites.Personne;

@SuppressWarnings("unchecked")
public class Test1 {

   // 常量
  private final static String TABLE_NAME = "jpa01_personne";  // 持久化上下文
  private static EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa");
  private static Personne p1;

  public static void main(String[] args) throws Exception {
     // 数据库清理
    log("clean");
    clean();

     // 转储
    log("dump");
    dump();

     // 测试1
    log("test1");
    test1();

     // 测试2
    log("test2");
    test2();

     // 关闭EntityManagerFactory
    emf.close();
  }

   // 显示表内容
  private static void dump() {
     // 持久化上下文
    EntityManager em = emf.createEntityManager();
     // 开始事务
    EntityTransaction tx = em.getTransaction();
    tx.begin();
     // 显示人员
    for (Object p : em.createQuery("select p from Personne p order by p.nom asc").getResultList()) {
      System.out.println(p);
    }
     // 事务结束
    tx.commit();
     // 上下文结束
    em.close();
  }

   // 清空 BD
  private static void clean() {
     // 持久化上下文
    EntityManager em = emf.createEntityManager();
     // 事务开始
    EntityTransaction tx = em.getTransaction();
    tx.begin();
     // 删除表中的元素 PERSONNES
    em.createNativeQuery("delete from " + TABLE_NAME).executeUpdate();
     // 事务结束
    tx.commit();
     // 上下文结束
    em.close();
  }

   // 日志
  private static void log(String message) {
    System.out.println("main : ----------- " + message);
  }

   // 持久化对象管理
  public static void test1() throws ParseException {
     // 持久化上下文
    EntityManager em = emf.createEntityManager();
     // 人员创建
    p1 = new Personne("Martin", "Paul", new SimpleDateFormat("dd/MM/yy").parse("31/01/2000"), true, 2);
    Personne p2 = new Personne("Durant", "Sylvie", new SimpleDateFormat("dd/MM/yy").parse("05/07/2001"), false, 0);
     // 事务开始
    EntityTransaction tx = em.getTransaction();
    System.out.println("début transaction");
    tx.begin();
     // 人员持久化
     // 日志显示，在持久化操作之后，立即生成了操作 SQL INSERT
     // 可能是为了获取主密钥
    System.out.println(String.format("Personne p1 %s non persistée", p1));
    System.out.println("em.persist(p1)");
    em.persist(p1);
    System.out.println(String.format("Personne p1 %s persistée", p1));
     // 人员 p2
     // INSERT 在持久化操作时生成
    System.out.println(String.format("Personne p2 %s non persistée", p2));
    System.out.println("em.persist(p2)");
    em.persist(p2);
    System.out.println(String.format("Personne p2 %s persistée", p2));
    p2.setMarie(true);
    System.out.println(String.format("Personne p2 %s modifiée", p2));
     // 与删除操作相关的 DELETE 操作仅在事务结束时执行
    System.out.println("em.remove(p2)");
    em.remove(p2);
    System.out.println(String.format("Personne p2 %s supprimée", p2));
     // 修改 p1
    p1.setNom("P1");
     // 事务结束
    System.out.println("fin transaction");
    tx.commit();
     // 上下文结束
    em.close();
     // 显示表
    dump();
  }

   // 持久化对象管理
  public static void test2() throws ParseException {
     // 持久化上下文
    EntityManager em = emf.createEntityManager();
     // 事务开始
    EntityTransaction tx = em.getTransaction();
    System.out.println("début transaction");
    tx.begin();
     // 修改当前已分离的联系人 p1
    System.out.println(String.format("Personne p1 %s actuelle non persistée", p1));
    p1.setMarie(false);
    System.out.println(String.format("Personne p1 %s nouvelle non persistée", p1));
     // 重新关联该人员 P1
    System.out.println("em.merge(p1)");
    Personne p1b = em.merge(p1);
    System.out.println(String.format("Personne p1b %s attachée", p1b));
     // 事务结束
    System.out.println("fin transaction");
    tx.commit();
       // 上下文结束
    em.close();
   // 显示表
    dump();
  }
}

4.5.3. Hibernate配置

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence">
  <persistence-unit name="jpa" transaction-type="RESOURCE_LOCAL">
         <!- - 提供程序 -->
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <properties>
             <!-- 持久化类 -->
      <property name="hibernate.archive.autodetection" value="class, hbm" />
      <property name="hibernate.show_sql" value="true"/>
....
             <! -- 自动创建模式 -->
      <property name="hibernate.hbm2ddl.auto" value="create" />
....
    </properties>
  </persistence-unit>
</persistence>

4.5.4. log4j.properties的配置

# 将日志消息直接输出到标准输出
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

# 根日志器选项
log4j.rootLogger=ERROR, stdout

# Hibernate 日志记录选项（INFO 仅显示启动消息）
#log4j.logger.org.hibernate=DEBUG

# 记录 JDBC 绑定参数的运行时参数
log4j.logger.org.hibernate.type=DEBUG

4.5.5. 结果

init:
deps-jar:
Compiling 1 source file to C:\data\travail\2008-2009\netbeans\jpa\hibernate-personnes-entites\build\classes
compile-single:
run-single:
main : ----------- 清理
Hibernate: delete from jpa01_personne
main : ----------- 转储
Hibernate: select personne0_.ID as ID0_, personne0_.DATENAISSANCE as DATENAIS2_0_, personne0_.MARIE as MARIE0_, personne0_.NBENFANTS as NBENFANTS0_, personne0_.NOM as NOM0_, personne0_.PRENOM as PRENOM0_, personne0_.VERSION as VERSION0_ from jpa01_personne personne0_ order by personne0_.NOM asc
main : ----------- test1
début transaction
Personne p1 [null,0,Martin,Paul,31/01/2000,true,2] non persistée
em.persist(p1)
Hibernate: insert into jpa01_personne (DATENAISSANCE, MARIE, NBENFANTS, NOM, PRENOM, VERSION) values (?, ?, ?, ?, ?, ?)
17:57:26,312 DEBUG DateType:133 - binding '31 janvier 2000' to parameter: 1
17:57:26,312 DEBUG BooleanType:133 - binding 'true' to parameter: 2
17:57:26,312 DEBUG IntegerType:133 - binding '2' to parameter: 3
17:57:26,312 DEBUG StringType:133 - binding 'Martin' to parameter: 4
17:57:26,312 DEBUG StringType:133 - binding 'Paul' to parameter: 5
17:57:26,312 DEBUG IntegerType:133 - binding '0' to parameter: 6
Personne p1 [1,0,Martin,Paul,31/01/2000,true,2] persistée
Personne p2 [null,0,Durant,Sylvie,05/07/2001,false,0] non persistée
em.persist(p2)
Hibernate: insert into jpa01_personne (DATENAISSANCE, MARIE, NBENFANTS, NOM, PRENOM, VERSION) values (?, ?, ?, ?, ?, ?)
17:57:26,328 DEBUG DateType:133 - binding '05 juillet 2001' to parameter: 1
17:57:26,328 DEBUG BooleanType:133 - binding 'false' to parameter: 2
17:57:26,328 DEBUG IntegerType:133 - binding '0' to parameter: 3
17:57:26,328 DEBUG StringType:133 - binding 'Durant' to parameter: 4
17:57:26,328 DEBUG StringType:133 - binding 'Sylvie' to parameter: 5
17:57:26,328 DEBUG IntegerType:133 - binding '0' to parameter: 6
Personne p2 [2,0,Durant,Sylvie,05/07/2001,false,0] persistée
Personne p2 [2,0,Durant,Sylvie,05/07/2001,true,0] modifiée
em.remove(p2)
Personne p2 [2,0,Durant,Sylvie,05/07/2001,true,0] supprimée
fin transaction
Hibernate: update jpa01_personne set DATENAISSANCE=?, MARIE=?, NBENFANTS=?, NOM=?, PRENOM=?, VERSION=? where ID=? and VERSION=?
17:57:26,343 DEBUG DateType:133 - binding '31 janvier 2000' to parameter: 1
17:57:26,343 DEBUG BooleanType:133 - binding 'true' to parameter: 2
17:57:26,343 DEBUG IntegerType:133 - binding '2' to parameter: 3
17:57:26,343 DEBUG StringType:133 - binding 'P1' to parameter: 4
17:57:26,359 DEBUG StringType:133 - binding 'Paul' to parameter: 5
17:57:26,359 DEBUG IntegerType:133 - binding '1' to parameter: 6
17:57:26,359 DEBUG IntegerType:133 - binding '1' to parameter: 7
17:57:26,359 DEBUG IntegerType:133 - binding '0' to parameter: 8
Hibernate: delete from jpa01_personne where ID=? and VERSION=?
17:57:26,359 DEBUG IntegerType:133 - binding '2' to parameter: 1
17:57:26,359 DEBUG IntegerType:133 - binding '0' to parameter: 2
Hibernate: select personne0_.ID as ID0_, personne0_.DATENAISSANCE as DATENAIS2_0_, personne0_.MARIE as MARIE0_, personne0_.NBENFANTS as NBENFANTS0_, personne0_.NOM as NOM0_, personne0_.PRENOM as PRENOM0_, personne0_.VERSION as VERSION0_ from jpa01_personne personne0_ order by personne0_.NOM asc
17:57:26,375 DEBUG IntegerType:172 - returning '1' as column: ID0_
17:57:26,390 DEBUG DateType:172 - returning '31 janvier 2000' as column: DATENAIS2_0_
17:57:26,390 DEBUG BooleanType:172 - returning 'true' as column: MARIE0_
17:57:26,390 DEBUG IntegerType:172 - returning '2' as column: NBENFANTS0_
17:57:26,390 DEBUG StringType:172 - returning 'P1' as column: NOM0_
17:57:26,390 DEBUG StringType:172 - returning 'Paul' as column: PRENOM0_
17:57:26,390 DEBUG IntegerType:172 - returning '1' as column: VERSION0_
[1,1,P1,Paul,31/01/2000,true,2]
main : ----------- test2
début transaction
Personne p1 [1,1,P1,Paul,31/01/2000,true,2] actuelle non persistée
Personne p1 [1,1,P1,Paul,31/01/2000,false,2] nouvelle non persistée
em.merge(p1)
Hibernate: select personne0_.ID as ID0_0_, personne0_.DATENAISSANCE as DATENAIS2_0_0_, personne0_.MARIE as MARIE0_0_, personne0_.NBENFANTS as NBENFANTS0_0_, personne0_.NOM as NOM0_0_, personne0_.PRENOM as PRENOM0_0_, personne0_.VERSION as VERSION0_0_ from jpa01_personne personne0_ where personne0_.ID=?
17:57:26,406 DEBUG IntegerType:133 - binding '1' to parameter: 1
17:57:26,406 DEBUG DateType:172 - returning '31 janvier 2000' as column: DATENAIS2_0_0_
17:57:26,406 DEBUG BooleanType:172 - returning 'true' as column: MARIE0_0_
17:57:26,406 DEBUG IntegerType:172 - returning '2' as column: NBENFANTS0_0_
17:57:26,406 DEBUG StringType:172 - returning 'P1' as column: NOM0_0_
17:57:26,406 DEBUG StringType:172 - returning 'Paul' as column: PRENOM0_0_
17:57:26,406 DEBUG IntegerType:172 - returning '1' as column: VERSION0_0_
Personne p1b [1,1,P1,Paul,31/01/2000,false,2] attachée
fin transaction
Hibernate: update jpa01_personne set DATENAISSANCE=?, MARIE=?, NBENFANTS=?, NOM=?, PRENOM=?, VERSION=? where ID=? and VERSION=?
17:57:26,406 DEBUG DateType:133 - binding '31 janvier 2000' to parameter: 1
17:57:26,406 DEBUG BooleanType:133 - binding 'false' to parameter: 2
17:57:26,406 DEBUG IntegerType:133 - binding '2' to parameter: 3
17:57:26,421 DEBUG StringType:133 - binding 'P1' to parameter: 4
17:57:26,421 DEBUG StringType:133 - binding 'Paul' to parameter: 5
17:57:26,421 DEBUG IntegerType:133 - binding '2' to parameter: 6
17:57:26,421 DEBUG IntegerType:133 - binding '1' to parameter: 7
17:57:26,421 DEBUG IntegerType:133 - binding '1' to parameter: 8
Hibernate: select personne0_.ID as ID0_, personne0_.DATENAISSANCE as DATENAIS2_0_, personne0_.MARIE as MARIE0_, personne0_.NBENFANTS as NBENFANTS0_, personne0_.NOM as NOM0_, personne0_.PRENOM as PRENOM0_, personne0_.VERSION as VERSION0_ from jpa01_personne personne0_ order by personne0_.NOM asc
17:57:26,453 DEBUG IntegerType:172 - returning '1' as column: ID0_
17:57:26,453 DEBUG DateType:172 - returning '31 janvier 2000' as column: DATENAIS2_0_
17:57:26,453 DEBUG BooleanType:172 - returning 'false' as column: MARIE0_
17:57:26,453 DEBUG IntegerType:172 - returning '2' as column: NBENFANTS0_
17:57:26,453 DEBUG StringType:172 - returning 'P1' as column: NOM0_
17:57:26,453 DEBUG StringType:172 - returning 'Paul' as column: PRENOM0_
17:57:26,453 DEBUG IntegerType:172 - returning '2' as column: VERSION0_
[1,2,P1,Paul,31/01/2000,false,2]
BUILD SUCCESSFUL (total time: 3 seconds)

问题：请说明Java代码与显示结果之间的关联。