Hibernate EntityManager

JPA 2 是 Java EE 6.0 平台的一部分。JPA 中的持久性可用于容器中，例如 EJB 3 或更现代的 CDI（Java 上下文和依赖项注入），以及在特定容器外部执行的独立 Java SE 应用程序中使用。以下编程界面和工件可在两种环境中使用。

在 Java SE 环境中，仅提供扩展上下文应用程序管理的实体管理器。您可以使用 EntityManagerFactory API 检索实体管理器。仅提供资源本地实体管理器。换句话说，Java SE 中不支持 JTA 事务和持久性上下文传播（您必须自己传播持久性上下文，例如，使用 Hibernate 社区流行的线程本地会话模式）。

扩展上下文表示在检索实体管理器时创建一个持久性上下文（使用 EntityManagerFactory.createEntityManager(...)），并在关闭实体管理器时关闭该持久性上下文。在这种情况下，许多资源本地事务共享相同的持久性上下文。

JPA 2.0 兼容的 Hibernate EntityManager 是建立在 Hibernate 和 Hibernate Annotations 核心之上的。从 3.5 版本开始，我们已在一个 Hibernate 发行版中捆绑了所有必要的模块

下载 Hibernate Core 发行版。设置类路径（在你最喜欢的 IDE 中创建新项目后）

或者，如果你使用 Maven，则添加以下依赖关系

<project ...>

  ...

  <dependencies>

    <dependency>

      <groupId>org.hibernate</groupId>

      <artifactId>hibernate-entitymanager</artifactId>

      <version>${hibernate-core-version}</version>

    </dependency>

  </dependencies>

</project>

所有必需的依赖项，例如 hibernate-core 和 hibernate-annotations，都会按传递方式拖动。

我们建议你使用 Hibernate Validator 和 Bean Validation 规范能力，因为其与 Java Persistence 2 的集成已标准化。从 Hibernate 网站下载 Hibernate Validator 4 或更高版本，并在你的类路径中添加 hibernate-validator.jar 和 validation-api.jar。或者，在你的 pom.xml 中添加以下依赖项。

<project>

  ...

  <dependencies>

    <dependency>

      <groupId>org.hibernate</groupId>

      <artifactId>hibernate-validator</artifactId>

      <version>${hibernate-validator-version}</version>

    </dependency>

    ...

  </dependencies>

  ...

</project>

如果你希望使用 Hibernate Search（面向 Hibernate 应用程序的全文搜索），请从 Hibernate 网站下载它，并在你的类路径中添加 hibernate-search.jar 及其依赖项。或者，在你的 pom.xml 中添加以下依赖项。

<project>

  ...

  <dependencies>

    <dependency>

      <groupId>org.hibernate</groupId>

      <artifactId>hibernate-search</artifactId>

      <version>${hibernate-search-version}</version>

    </dependency>

    ...

  </dependencies>

  ...

</project>

Hibernate Entity Manager 需要增强 Hibernate 核心以实现所有 JPA 语义。它通过 Hibernate 的事件侦听器系统来实现这一点。在您自己使用事件系统时请小心，您可能会覆盖一些 JPA 语义。一种安全的方法是将您的事件侦听器添加到以下列表中。

您可以通过属性（请参阅 配置和引导）或 ejb3configuration.getEventListeners() API 配置事件监听器。

实体管理器工厂应被视为不可变配置持有者，它被定义为指向一个数据源和映射一组已定义实体。这是创建和管理 EntityManager 的入口点。 Persistence 类是创建实体管理器工厂的引导类。

// Use persistence.xml configuration

EntityManagerFactory emf = Persistence.createEntityManagerFactory("manager1")

EntityManager em = emf.createEntityManager(); // Retrieve an application managed entity manager

// Work with the EM

em.close();

...

emf.close(); //close at application end

实体管理器工厂通常在应用程序初始化时创建，并在应用程序结束时关闭。创建实体管理器工厂是一个昂贵的过程。对于熟悉 Hibernate 的人来说，实体管理器工厂非常像会话工厂。实际上，实体管理器工厂是一个包装在会话工厂之上的类。对 entityManagerFactory 的调用是线程安全的。

借助 EntityManagerFactory，您可以检索扩展实体管理器。扩展实体管理器在实体管理器的生命周期内保持相同的持久性上下文：换句话说，实体在两个事务之间仍然受到管理（除非您在此期间调用 entityManager.clear()）。您可以将实体管理器视为 Hibernate 会话之上的一个小包装。

TODO 说明 emf.createEntityManager(Map)

Hibernate 实体管理器配置了 Hibernate Validator，开箱即用。您不必自己覆盖任何事件。如果您不在您的领域模型中使用 Hibernate Validator 注释，则不会产生性能开销。有关 Hibernate Validator 的更多信息，请参阅 Hibernate 注释参考指南。

就像在 Hibernate 中一样（比较术语括号中），一个实体实例处于以下状态之一

EntityManager API 可以更改实体的状态，或者换句话说，可以加载和存储对象。如果你考虑对象状态管理，而不是管理 SQL 语句，你会发现使用 JPA 进行持久化更容易理解。

一旦创建了一个新的实体实例（使用常见的 new 运算符），它将处于 new 状态。可以通过将其与实体管理器相关联来使其持久

DomesticCat fritz = new DomesticCat();

fritz.setColor(Color.GINGER);

fritz.setSex('M');

fritz.setName("Fritz");

em.persist(fritz);

如果 DomesticCat 实体类型具有生成的标识符，则在调用 persist() 时将值与实例相关联。如果标识符不是自动生成的，则必须在调用 persist() 之前在实例上设置应用分配的（通常是自然）键值。

使用实体管理器的 find() 方法，按其标识符值加载实体实例

cat = em.find(Cat.class, catId);


// You may need to wrap the primitive identifiers

long catId = 1234;

em.find( Cat.class, new Long(catId) );

在某些情况下，你并不真正希望加载对象状态，而仅仅拥有对其的引用（即代理）。你可以使用 getReference() 方法获取此引用。这在不必加载父对象的情况下将子对象链接到其父对象时特别有用。

child = new Child();

child.SetName("Henry");

Parent parent = em.getReference(Parent.class, parentId); //no query to the DB

child.setParent(parent);

em.persist(child);

你可以随时使用 em.refresh() 操作重新加载实体实例及其集合。当使用数据库触发器来初始化实体的某些属性时，这很有用。请注意，除非你将 REFRESH 指定为任何关联的级联样式，否则只有实体实例及其集合会被刷新

em.persist(cat);

em.flush(); // force the SQL insert and triggers to run

em.refresh(cat); //re-read the state (after the trigger executes)

如果你不知道所查找对象的标识符值，则需要一个查询。Hibernate EntityManager 实现支持易于使用且功能强大的面向对象查询语言（JP-QL），它受到 HQL（反之亦然）的启发。严格来说，HQL 是 JP-QL 的超集。这两种查询语言在数据库之间是可移植的，使用实体和属性名称作为标识符（而不是表和列名称）。你还可以使用数据库的本机 SQL 来表达查询，同时 JPA 可选择支持将结果集转换为 Java 业务对象。

List<?> cats = em.createQuery(

    "select cat from Cat as cat where cat.birthdate < ?1")

    .setParameter(1, date, TemporalType.DATE)

    .getResultList();


List<?> mothers = em.createQuery(

    "select mother from Cat as cat join cat.mother as mother where cat.name = ?1")

    .setParameter(1, name)

    .getResultList();


List<?> kittens = em.createQuery(

    "from Cat as cat where cat.mother = ?1")

    .setEntity(1, pk)

    .getResultList();


Cat mother = (Cat) em.createQuery(

    "select cat.mother from Cat as cat where cat = ?1")

    .setParameter(1, izi)

    .getSingleResult();

CriteriaQuery<Cat> criteria = builder.createQuery( Cat.class );

Root<Cat> cat = criteria.from( Cat.class );

criteria.select( cat );

criteria.where( builder.lt( cat.get( Cat_.birthdate ), catDate ) );

List<Cat> cats = em.createQuery( criteria ).getResultList(); //notice no downcasting is necessary

//No downcasting since we pass the return type

List<Cat> cats = em.createQuery(

    "select cat from Cat as cat where cat.birthdate < ?1", Cat.class)

    .setParameter(1, date, TemporalType.DATE)

    .getResultList();

Iterator kittensAndMothers = sess.createQuery(

            "select kitten, mother from Cat kitten join kitten.mother mother")

            .getResultList()

            .iterator();


while ( kittensAndMothers.hasNext() ) {

    Object[] tuple = (Object[]) kittensAndMothers.next();

    Cat kitten = (Cat) tuple[0];

    Cat mother = (Cat) tuple[1];

    ....

}

Iterator results = em.createQuery(

        "select cat.color, min(cat.birthdate), count(cat) from Cat cat " +

        "group by cat.color")

        .getResultList()

        .iterator();


while ( results.hasNext() ) {

    Object[] row = results.next();

    Color type = (Color) row[0];

    Date oldest = (Date) row[1];

    Integer count = (Integer) row[2];

    .....

}

// Named parameter (preferred)

Query q = em.createQuery("select cat from DomesticCat cat where cat.name = :name");

q.setParameter("name", "Fritz");

List cats = q.getResultList();


// Positional parameter

Query q = em.createQuery("select cat from DomesticCat cat where cat.name = ?1");

q.setParameter(1, "Izi");

List cats = q.getResultList();


// Named parameter list

List names = new ArrayList();

names.add("Izi");

names.add("Fritz");

Query q = em.createQuery("select cat from DomesticCat cat where cat.name in (:namesList)");

q.setParameter("namesList", names);

List cats = q.list();

Query q = em.createQuery("select cat from DomesticCat cat");

q.setFirstResult(20);

q.setMaxResults(10);

List cats = q.getResultList(); //return cats from the 20th position to 29th

@javax.persistence.NamedQuery(name="eg.DomesticCat.by.name.and.minimum.weight",

  query="select cat from eg.DomesticCat as cat  where cat.name = ?1 and cat.weight > ?2")

Query q = em.createNamedQuery("eg.DomesticCat.by.name.and.minimum.weight");

q.setString(1, name);

q.setInt(2, minWeight);

List<?> cats = q.getResultList();

Query q = em.createNamedQuery("eg.DomesticCat.by.name.and.minimum.weight", Cat.class);

q.setString(1, name);

q.setInt(2, minWeight);

List<Cat> cats = q.getResultList();

@SqlResultSetMapping(name="getItem", entities =

        @EntityResult(entityClass=org.hibernate.ejb.test.Item.class, fields= {

            @FieldResult(name="name", column="itemname"),

            @FieldResult(name="descr", column="itemdescription")

        })

)


Query q = em.createNativeQuery("select name as itemname, descr as itemdescription from Item", "getItem");

item = (Item) q.getSingleResult(); //from a resultset


Query q = em.createNativeQuery("select * from Item", Item.class);

item = (Item) q.getSingleResult(); //from a class columns names match the mapping

query.setFlushMode(FlushModeType.COMMIT)

     .setLockMode(LockModeType.PESSIMISTIC_READ);

事务受管实例（即由实体管理器加载、保存、创建或查询的对象）可由应用程序进行操作，并且当实体管理器刷新（在本章后面讨论）时，对持久化状态的任何更改都将被保存。无需调用特定方法即可使修改持久化。更新实体实例状态的简便方法是 find() 它，然后直接操作它，同时保持持久化上下文处于打开状态

Cat cat = em.find( Cat.class, new Long(69) );

cat.setName("PK");

em.flush();  // changes to cat are automatically detected and persisted

有时此编程模型效率低下，因为它需要在同一会话中执行 SQL SELECT（加载对象）和 SQL UPDATE（保存其更新状态）。因此，Hibernate 提供了一种使用分离实例的备用方法。

当对象在持久化上下文中加载时，它将由 Hibernate 进行管理。您可以通过关闭 EntityManager 或通过调用 detach() 方法来强制分离对象（即不再由 Hibernate 管理）。

Cat cat = em.find( Cat.class, new Long(69) );

...

em.detach(cat);

cat.setName("New name"); //not propatated to the database

许多应用程序需要在一种事务中检索对象，将其发送到表示层进行操作，然后在新的事务中保存更改。两个事务之间可能存在明显的用户思考和等待时间。在高并发环境中使用这种方法的应用程序通常使用版本化数据来确保“长时间”工作单元的隔离性。

JPA 规范通过使用 EntityManager.merge() 方法提供对分离实例进行修改的持久化来支持此开发模型

// in the first entity manager

Cat cat = firstEntityManager.find(Cat.class, catId);

Cat potentialMate = new Cat();

firstEntityManager.persist(potentialMate);


// in a higher layer of the application

cat.setMate(potentialMate);


// later, in a new entity manager

secondEntityManager.merge(cat);  // update cat

secondEntityManager.merge(mate); // update mate

merge() 方法将对分离实例进行的修改合并到相应的受管实例（如果有）中，而不考虑持久化上下文的态。换句话说，如果已经存在，则合并的对象状态将覆盖持久化上下文中持久化实体的状态。如果应用程序仅希望它们的态也持久化，则应分别 merge() 可从给定分离实例访问的分离实例。这可以使用传递持久化，级联到关联的实体和集合，请参见传递持久化。

合并操作非常智能，可以自动检测是否必须以插入或更新为结果来合并分离实例。换句话说，您不必担心将新实例（而不是分离实例）传递给 merge()，实体管理器会为您弄清楚这一点

// In the first entity manager

Cat cat = firstEntityManager.find(Cat.class, catID);


// In a higher layer of the application, detached

Cat mate = new Cat();

cat.setMate(mate);


// Later, in a new entity manager

secondEntityManager.merge(cat);   // update existing state

secondEntityManager.merge(mate);  // save the new instance

对于新用户而言，merge() 的用法和语义似乎令人困惑。首先，只要您不尝试在另一个新实体管理器中使用在一个实体管理器中加载的对象状态，就根本不需要使用 merge()。一些整个应用程序永远不会使用此方法。

通常在以下场景中使用 merge()

以下是 merge() 的确切语言

EntityManager.remove() 会从数据库中删除一个状态对象。当然，您的应用程序可能仍持有对已删除对象的引用。您可以将 remove() 视为使一个持久性实例再次变为新的（也称为瞬态）。它不会被分离，并且合并将导致插入。

实体管理器会不时执行所需的 SQL DML 语句，以同步数据存储与内存中保存的对象状态。该过程称为刷新。

em = emf.createEntityManager();

Transaction tx = em.getTransaction().begin();

em.setFlushMode(FlushModeType.COMMIT); // allow queries to return stale state


Cat izi = em.find(Cat.class, id);

izi.setName(iznizi);


// might return stale data

em.createQuery("from Cat as cat left outer join cat.kittens kitten").getResultList();


// change to izi is not flushed!

...

em.getTransaction().commit(); // flush occurs

保存、删除或重新附加各个对象非常繁琐，尤其是当您处理相关对象的图形时。亲子关系是一种常见情况。考虑以下示例

如果父子关系中的子级为值类型（例如，地址或字符串的集合），那么它们的生存期将取决于父级，并且不再需要采取进一步的措施来方便地“级联”状态更改。当保存父级时，值类型子级对象也将被保存，当删除父级时，子级将被删除，依此类推。这甚至适用于某些操作，例如从集合中删除子级；Hibernate 将检测到这一点，并且由于值类型对象不能具有共享引用，因此会从数据库中删除子级。

现在考虑父对象和子对象为实体（例如类别和项目，或父猫和子猫）而值类型的情况。实体有自己的生命周期，支持共享引用（因此从集合中删除实体并不意味着它可以被删除），并且默认情况下，不会级联将状态从一个实体传给任何其他关联实体。EJB3 规范不要求通过可达性进行持久化。它支持一个更灵活的瞬态持久化模型，就像最早出现在 Hibernate 中的那样。

对于实体管理器的每个基本操作 - 包括 persist()、merge()、remove()、refresh() - 都有一个相应的级联样式。级联样式分别命名为 PERSIST、MERGE、REMOVE、REFRESH、DETACH。如果您希望级联操作到关联实体（或实体集合），则必须在关联注释中注明这一点

@OneToOne(cascade=CascadeType.PERSIST)

级联选项可以组合

@OneToOne(cascade= { CascadeType.PERSIST, CascadeType.REMOVE, CascadeType.REFRESH } )

您甚至可以使用 CascadeType.ALL 指定应为特定关联级联所有操作。请记住，默认情况下，不级联任何操作。

还有一个附加的级联模式用于描述孤儿删除（即不再链接到拥有对象的，对象应由 Hibernate 自动删除。在 @OneToOne 或 @OneToMany 中使用 orphanRemoval=true。有关更多信息，请查看 Hibernate Annotations 文档。

Hibernate 提供更多原生级联选项，请查阅 Hibernate Annotations 手册和 Hibernate 参考指南以获取更多信息。

建议

您可以定义各个级别的锁定策略。锁定可以通过多种方式应用

您可以使用各种锁定方法

所有这些锁定都能防止在给定实体上进行脏读和不可重复读。乐观锁定会尽可能晚地实施锁定，希望在此期间没有人更改基础数据，而悲观锁定会立即强制进行锁定，并一直保持锁定直到提交事务为止。

当二级缓存被激活时（请参见 第 2.2.1 节“打包”和 Hibernate Annotations 参考文档），Hibernate 也会确保使用并正确更新二级缓存。但是，可以通过传递两个属性来调整这些设置

CacheRetrieveMode 控制 Hibernate 如何从二级缓存访问信息： USE（这是默认值）或 BYPASS（这意味着忽略缓存）。 CacheStoreMode 控制 Hibernate 如何将信息推送到二级缓存： USE（这是默认值），在从数据库中读取和写入数据库时将数据推送到缓存中，BYPASS（不插入新的数据到缓存中，但可以使过时数据无效）和 REFRESH（与默认值类似，但也强制将数据推送到缓存，在数据库读取时执行此操作，即使数据已缓存在缓存中也是如此）。

可以在以下位置设置这些属性

JPA 还引入了一个用于查询二级缓存并手动清除数据的信息。

Cache cache = entityManagerFactory.getCache();


if ( cache.contains(User.class, userId) ) {

   //load it as we don't hit the DB

}


cache.evict(User.class, userId); //manually evict user form the second-level cache

cache.evict(User.class); //evict all users from the second-level cache

cache.evictAll(); //purge the second-level cache entirely

可以检查一个对象是否由持久性上下文管理

entityManager.get(Cat.class, catId);

...

boolean isIn = entityManager.contains(cat);

assert isIn;

您还可以检查对象、关联或属性是否为延迟加载。可以独立于底层持久性提供程序执行此操作

PersistenceUtil jpaUtil = Persistence.getPersistenceUtil();

if ( jpaUtil.isLoaded( customer.getAddress() ) {

   //display address if loaded

}

if ( jpaUtil.isLoaded( customer.getOrders ) ) {

   //display orders if loaded

}

if (jpaUtil.isLoaded(customer, "detailedBio") ) {

   //display property detailedBio if loaded

}

但是，如果您有权访问 entityManagerFactory，我们建议您使用

PersistenceUnitUtil jpaUtil = entityManager.getEntityManagerFactory().getPersistenceUnitUtil();


Customer customer = entityManager.get( Customer.class, customerId );


if ( jpaUtil.isLoaded( customer.getAddress() ) {

   //display address if loaded

}

if ( jpaUtil.isLoaded( customer.getOrders ) ) {

   //display orders if loaded

}

if (jpaUtil.isLoaded(customer, "detailedBio") ) {

   //display property detailedBio if loaded

}


log.debug( "Customer id {}", jpaUtil.getIdentifier(customer) );

性能可能略好，您可以从对象中获取标识符的值（使用 getIdentifier()）。

您可以始终回退到给定 EntityManager 的底层 Session API

Session session = entityManager.unwrap(Session.class);

静态元模型是一系列类，它们“镜像”领域模型中的实体和嵌入对象，并且提供对镜像类属性的元数据的静态访问。我们只讨论 [JPA 2 规范] 称之为 规范元模型 的内容

package org.hibernate.jpa2.metamodel.example;

import java.util.Set;
import javax.persistence.Entity;

@Entity
public class Person {
    @Id private Long id;
    private String name;
    private int age;
    private Address address;
    @OneToMany  private Set<Order> orders;
}

package org.hibernate.jpa2.metamodel.example;

import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.SetAttribute;
import javax.persistence.metamodel.StaticMetamodel;

@StaticMetamodel( Person.class )
public class Person_ {
    public static volatile SingularAttribute<Person, Long> id;
    public static volatile SingularAttribute<Person, String> name;
    public static volatile SingularAttribute<Person, Integer> age;
    public static volatile SingularAttribute<Person, Address> address;
    public static volatile SetAttribute<Person, Order> orders;
}

构建 Hibernate EntityManagerFactory 时，它将为所知道的每个受管理类型查找规范化元模型类，如果找到任何规范化元模型类，它将向其中注入适当的元模型信息，如 [JPA 2 规范，第 6.2.2 节，第 200 页] 所述

应用程序通常需要针对持久性机制中发生的特定事件作出反应。这允许实现特定类型的通用功能，并扩展内置功能。JPA 规范为此提供了两种相关机制。

可以将实体的方法指定为回调方法，以接收特定实体生命周期事件的通知。回调方法由回调注解注释。您还可以定义实体侦听器类，以代替直接在实体类内定义的回调方法。实体侦听器是一个无状态类，带有无参数构造函数。通过使用 @EntityListeners 注解对实体类进行注释来定义实体侦听器

@Entity

@EntityListeners(class=Audit.class)

public class Cat {

    @Id private Integer id;

    private String name;

    private Calendar dateOfBirth;

    @Transient private int age;

    private Date lastUpdate;

    //getters and setters


    /**

     * Set my transient property at load time based on a calculation,

     * note that a native Hibernate formula mapping is better for this purpose.

     */

    @PostLoad

    public void calculateAge() {

        Calendar birth = new GregorianCalendar();

        birth.setTime(dateOfBirth);

        Calendar now = new GregorianCalendar();

        now.setTime( new Date() );

        int adjust = 0;

        if ( now.get(Calendar.DAY_OF_YEAR) - birth.get(Calendar.DAY_OF_YEAR) < 0) {

            adjust = -1;

        }

        age = now.get(Calendar.YEAR) - birth.get(Calendar.YEAR) + adjust;

    }

}


public class LastUpdateListener {

    /**

     * automatic property set before any database persistence

     */

    @PreUpdate

    @PrePersist

    public void setLastUpdate(Cat o) {

        o.setLastUpdate( new Date() );

    }

}

同一个回调方法或实体侦听器方法可以用多个回调注解注释。对于给定的实体，您不能有两个方法由同一个回调注解注释，无论它是回调方法还是实体侦听器方法。回调方法是一个无参数方法，没有返回类型，任何任意名称都可以。实体侦听器的签名是 void <METHOD>(Object)，其中 Object 是实际的实体类型（请注意，Hibernate 实体管理器放宽了此约束，允许 Object of java.lang.Object 类型（允许共享跨多个实体的侦听器。）

回调方法可以引发 RuntimeException。如果存在当前事务，则必须回滚。定义了以下回调

您可以在不同级别层次结构的每个实体上定义多个实体侦听器。您还可以在不同级别的层次结构上定义多个回调。但您不能在同一个实体或同一个实体侦听器中为同一个事件定义两个侦听器。

事件触发后，以以下顺序执行侦听器

可以使用 @ExcludeSuperclassListeners 停止实体侦听器的继承，然后所有超类的 @EntityListeners 都将被忽略。

JPA 规范允许通过 JPA 部署描述符覆盖注释。还有一个额外的功能可能是有效的：默认事件侦听器。

<?xml version="1.0" encoding="UTF-8"?>



<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"

                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

                 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm orm_2_0.xsd"

                 version="2.0"

        >

    <persistence-unit-metadata>

        <persistence-unit-defaults>

            <entity-listeners>

                <entity-listener class="org.hibernate.ejb.test.pack.defaultpar.IncrementListener">

                    <pre-persist method-name="increment"/>

                </entity-listener>

            </entity-listeners>

        </persistence-unit-defaults>

    </persistence-unit-metadata>

    <package>org.hibernate.ejb.test.pack.defaultpar</package>

    <entity class="ApplicationServer">

        <entity-listeners>

            <entity-listener class="OtherIncrementListener">

                <pre-persist method-name="increment"/>

            </entity-listener>

        </entity-listeners>





        <pre-persist method-name="calculate"/>

    </entity>

</entity-mappings>

可以在给定实体上覆盖实体侦听器。一个实体侦听器对应于一个给定的类，一个或多个事件触发一个给定的方法调用。你还可以定义实体本身的事件，来描述回调函数。

最后但并非最不重要的是你可以定义一些默认实体侦听器，这些侦听器将首先应用于给定持久化单元的所有已映射实体的实体侦听器堆栈中。如果你不希望实体继承默认侦听器，可以使用 @ExcludeDefaultListeners（或

如前所述，自动且透明的对象/关系映射涉及对象状态的管理。这意味着对象状态可用于内存，因此直接在数据库中更新或删除（使用 SQL UPDATE 和 DELETE）数据不会影响内存中的状态。然而，Hibernate 为批量 SQL 样式 UPDATE 和 DELETE 语句执行提供了方法，这些方法通过 JP-QL（第 8 章，JP-QL：对象查询语言）执行。

UPDATE 和 DELETE 语句的伪语法为：( UPDATE | DELETE ) FROM? ClassName (WHERE WHERE_CONDITIONS)?。请注意

例如，要执行 JP-QL UPDATE，请使用 Query.executeUpdate() 方法

EntityManager entityManager = entityManagerFactory.createEntityManager();

entityManager.getTransaction().begin();


String jpqlUpdate = "update Customer set name = :newName where name = :oldName"

int updatedEntities = entityManager.createQuery( jpqlUpdate )

                            .setParameter( "newName", newName )

                            .setParameter( "oldName", oldName )

                            .executeUpdate();

entityManager.getTransaction().commit();

entityManager.close();

要执行 JP-QL DELETE，请使用相同的 Query.executeUpdate() 方法 （该方法命名是为那些熟悉 JDBC 的 PreparedStatement.executeUpdate() 的人而命名的）

EntityManager entityManager = entityManagerFactory.createEntityManager();

entityManager.getTransaction().begin();


String hqlDelete = "delete Customer where name = :oldName";

int deletedEntities = entityManager.createQuery( hqlDelete )

                            .setParameter( "oldName", oldName )

                            .executeUpdate();

entityManager.getTransaction().commit();

entityManager.close();

Query.executeUpdate() 方法返回的 int 值表明受该操作影响的实体数量。这可能与数据库中受影响的行号相关联，也可能不相关联。例如，对于联结子类，一个 JP-QL 批量操作可能导致执行多个实际 SQL 语句。返回的数字表明受该语句影响的实际实体数量。回到联结子类的示例，针对其中一个子类的删除实际上可能导致不仅删除映射到该子类的表，而且还会删除“根”表以及继承层次结构中的联结子类表。

CriteriaQuery<T> createQuery(Class<T>)

criteria 查询的类型（又名 <T>）指示查询结果中的预期类型。这可以是实体、Integer 或任何其他对象。

CriteriaQuery<Person> criteria = builder.createQuery( Person.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.select( personRoot );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Person> people = em.createQuery( criteria ).getResultList();
for ( Person person : people ) { ... }

CriteriaQuery<Integer> criteria = builder.createQuery( Integer.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.select( personRoot.get( Person_.age ) );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Integer> ages = em.createQuery( criteria ).getResultList();
for ( Integer age : ages ) { ... } 

CriteriaQuery<Integer> criteria = builder.createQuery( Integer.class ); Root<Person> personRoot = criteria.from( Person.class ); criteria.select( builder.max( personRoot.get( Person_.age ) ) ); criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) ); Integer maxAge = em.createQuery( criteria ).getSingleResult();

CriteriaQuery<Object[]> criteria = builder.createQuery( Object[].class );
Root<Person> personRoot = criteria.from( Person.class );
Path<Long> idPath = personRoot.get( Person_.id );
Path<Integer> agePath = personRoot.get( Person_.age );
criteria.select( builder.array( idPath, agePath ) );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Object[]> valueArray = em.createQuery( criteria ).getResultList();
for ( Object[] values : valueArray ) {
    final Long id = (Long) values[0];
    final Integer age = (Integer) values[1];
    ...
}

CriteriaQuery<Object[]> criteria = builder.createQuery( Object[].class ); Root<Person> personRoot = criteria.from( Person.class ); Path<Long> idPath = personRoot.get( Person_.id ); Path<Integer> agePath = personRoot.get( Person_.age ); criteria.multiselect( idPath, agePath ); criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) ); List<Object[]> valueArray = em.createQuery( criteria ).getResultList(); for ( Object[] values : valueArray ) { final Long id = (Long) values[0]; final Integer age = (Integer) values[1]; ... } 

public class PersonWrapper {
    private final Long id;
    private final Integer age;
    public PersonWrapper(Long id, Integer age) {
        this.id = id;
        this.age = age;
    }
    ...
}
...
CriteriaQuery<PersonWrapper> criteria = builder.createQuery( PersonWrapper.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.select(
    builder.construct(
        PersonWrapper.class,
        personRoot.get( Person_.id ),
        personRoot.get( Person_.age )
    )
);
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<PersonWrapper> people = em.createQuery( criteria ).getResultList();
for ( PersonWrapper person : people ) { ... }

对于第 9.1.3 节“选择多个值”，更好的方法要么是使用包装器（我们刚刚在 第 9.1.4 节“选择一个包装器” 中看到了），要么使用 javax.persistence.Tuple 合约。

CriteriaQuery<Tuple> criteria = builder.createTupleQuery();
Root<Person> personRoot = criteria.from( Person.class );
Path<Long> idPath = personRoot.get( Person_.id );
Path<Integer> agePath = personRoot.get( Person_.age );
criteria.multiselect( idPath, agePath );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Tuple> tuples = em.createQuery( criteria ).getResultList();
for ( Tuple tuple : valueArray ) {
    assert tuple.get( 0 ) == tuple.get( idPath );
    assert tuple.get( 1 ) == tuple.get( agePath );
    ...
}