Hibernate EntityManager 指南

一时失言乱红尘 2023-09-25 13:51 109阅读 0赞

### **1. 简介** ###

***EntityManager*是 Java Persistence API 的一部分。它主要实现 JPA 2.0 规范定义的编程接口和生命周期规则。**

此外，我们可以通过使用*EntityManager* 中的 API 来访问持久性上下文。

在本教程中，我们将了解*实体管理器*的配置、类型和各种 API。

### **2. Maven 依赖项** ###

首先，我们需要包含 Hibernate 的依赖项：

<dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.4.0.Final</version>
    </dependency>

根据我们使用的数据库，我们还必须包含驱动程序依赖项：

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

[hibernate-core][]和[mysql-connector-java][]依赖项在Maven Central上可用。

### **3. 配置** ###

现在，让我们通过使用与数据库中的 MOVIE 表对应的*电影*实体来演示*实体管理器*。

在本文中，我们将使用*EntityManager*API 来处理数据库中的*Movie*对象。

#### **3.1. 定义实体** ####

让我们首先使用*@Entity*注释创建与 MOVIE 表对应的实体：

@Entity
    @Table(name = "MOVIE")
    public class Movie {
        
        @Id
        private Long id;
    
        private String movieName;
    
        private Integer releaseYear;
    
        private String language;
    
        // standard constructor, getters, setters
    }

#### **3.2.*持久化.xml*文件** ####

创建*EntityManagerFactory*时，**持久性实现会在类路径中搜索*META-INF/persistence.xml*文件**。

**This file contains the configuration for the *EntityManager*:**

<persistence-unit name="com.baeldung.movie_catalog">
        <description>Hibernate EntityManager Demo</description>
        <class>com.baeldung.hibernate.pojo.Movie</class> 
        <exclude-unlisted-classes>true</exclude-unlisted-classes>
        <properties>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://127.0.0.1:3306/moviecatalog"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
        </properties>
    </persistence-unit>

如我们所见，我们定义了持久性单元，该单元指定由*EntityManager* 管理的基础数据存储。

此外，我们还定义了基础数据存储的方言和其他 JDBC 属性。Hibernate与数据库无关。**基于这些属性，Hibernate与基础数据库连接。**

### **4. 容器和应用程序托管*实体管理器*** ###

基本上，**有两种类型的*实体管理器*：容器托管和应用程序管理。**

让我们仔细看看每种类型。

#### **4.1. 容器管理的*实体管理器*** ####

在这里，容器在我们的企业组件中注入*了实体管理器*。

换句话说，容器从*EntityManagerFactory*为我们创建了*EntityManager*：

@PersistenceContext
    EntityManager entityManager;

这也意味着**容器负责开始事务，以及提交或回滚事务。**

同样，容器负责关闭*实体管理器，*因此无需手动清理即可安全使用。即使我们尝试*关闭*容器管理的*EntityManager*，它也应该抛出*IllegalStateException。*

#### **4.2. 应用程序管理的*实体管理器*** ####

相反，*实体管理器*的生命周期由应用程序管理。

事实上，我们将手动创建*实体管理器*，并管理它的生命周期。

首先，让我们创建*EntityManagerFactory：*

EntityManagerFactory emf = Persistence.createEntityManagerFactory("com.baeldung.movie_catalog");

为了创建一个 EntityManager，我们必须在*EntityManagerFactory* 中显式调用*createEntityManager（）：*

public static EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

由于我们负责创建*EntityManager*实例，因此我们也有责任关闭它们*。*因此，我们应该在使用完每个*实体管理器*后*关闭*它们。

#### **4.3. 线程安全** ####

***EntityManagerFactory*实例以及因此 Hibernate 的*[SessionFactory][]*实例是线程安全的**。因此，在并发上下文中编写以下内容是完全安全的：

EntityManagerFactory emf = // fetched from somewhere
    EntityManager em = emf.createEntityManager();

另一方面，***EntityManager*实例不是线程安全的，旨在用于线程受限的环境**。这意味着每个线程都应该获取它的实例，使用它，并在最后关闭它。

使用应用程序管理的*实体管理器*时，可以轻松创建线程受限的实例：

EntityManagerFactory emf = // fetched from somewhere 
    EntityManager em = emf.createEntityManager();
    // use it in the current thread

但是，当使用容器管理的*实体管理器*时，事情变得违反直觉：

@Service
    public class MovieService {
    
        @PersistenceContext // or even @Autowired
        private EntityManager entityManager;
        
        // omitted
    }

似乎应该为所有操作共享一个*实体管理器*实例。**但是，容器（JakartaEE 或 Spring）在这里注入了一个特殊的代理，而不是一个简单的*EntityManager***。例如，Spring 注入了一个类型*[为 SharedEntityManagerCreator][SharedEntityManagerCreator]* 的代理。

每次我们使用注入的实体管理器*时*，这个代理要么重用现有的实体管理器，要么创建一个新的*实体管理器*。重用通常发生在我们在*[视图中启用类似 Open Session/EntityManager][Open Session_EntityManager] 之类的东西时。*

无论哪种方式，**容器都确保每个*实体管理器*都限制在一个线程中**。

### **5. 休眠实体操作** ###

*EntityManager*API 提供了一组方法。我们可以通过使用这些方法与数据库进行交互。

#### **5.1. 持久化实体** ####

为了使对象与 EntityManager 相关联，我们可以使用*persist（）* 方法：

public void saveMovie() {
        EntityManager em = getEntityManager();
        
        em.getTransaction().begin();
        
        Movie movie = new Movie();
        movie.setId(1L);
        movie.setMovieName("The Godfather");
        movie.setReleaseYear(1972);
        movie.setLanguage("English");
    
        em.persist(movie);
        em.getTransaction().commit();
    }

**将对象保存到数据库中后，它将处于*持久*状态。**

#### **5.2. 加载实体** ####

**为了从数据库中检索对象，我们可以使用*find（）* 方法。**

在这里，该方法按主键搜索。实际上，该方法需要实体类类型和主键：

public Movie getMovie(Long movieId) {
        EntityManager em = getEntityManager();
        Movie movie = em.find(Movie.class, new Long(movieId));
        em.detach(movie);
        return movie;
    }

**但是，如果我们只需要对实体的引用，我们可以改用*getReference（）*** 方法。实际上，它将代理返回给实体：

Movie movieRef = em.getReference(Movie.class, new Long(movieId));

#### **5.3. 分离实体** ####

如果我们需要从持久性上下文中分离一个实体，**我们可以使用*detach（）* 方法**。我们将要分离的对象作为参数传递给方法：

em.detach(movie);

实体从持久性上下文中分离后，它将处于分离状态。

#### **5.4. 合并实体** ####

实际上，许多应用程序需要跨多个事务进行实体修改。例如，我们可能希望检索一个事务中的实体以呈现到 UI。然后，另一个事务将引入UI中所做的更改。

对于这种情况，我们可以使用*merge（）* 方法。**合并方法有助于将对分离实体所做的任何修改引入托管实体：**

public void mergeMovie() {
        EntityManager em = getEntityManager();
        Movie movie = getMovie(1L);
        em.detach(movie);
        movie.setLanguage("Italian");
        em.getTransaction().begin();
        em.merge(movie);
        em.getTransaction().commit();
    }

#### **5.5. 查询实体** ####

此外，我们可以利用 JPQL 来查询实体。我们将调用*getResultList（）* 来执行它们。

当然，如果查询只返回一个对象，我们可以使用*getSingleResult（）：*

public List<?> queryForMovies() {
        EntityManager em = getEntityManager();
        List<?> movies = em.createQuery("SELECT movie from Movie movie where movie.language = ?1")
          .setParameter(1, "English")
          .getResultList();
        return movies;
    }

#### **5.6. 删除实体** ####

此外，**我们可以使用*remove（）* 方法从数据库中删除实体**。请务必注意，对象不是分离的，而是删除的。

在这里，实体的状态从持久更改为新：

public void removeMovie() {
        EntityManager em = HibernateOperations.getEntityManager();
        em.getTransaction().begin();
        Movie movie = em.find(Movie.class, new Long(1L));
        em.remove(movie);
        em.getTransaction().commit();
    }

### **6. 结论** ###

在本文中，我们探讨了 Hibernate 中的*EntityManager*。我们查看了类型和配置，并了解了 API 中可用于处理持久性上下文的各种方法。

与往常一样，本文中使用的代码可在[Github 上][Github]找到。

[hibernate-core]: https://search.maven.org/search?q=a:hibernate-core%20AND%20g:org.hibernate
[mysql-connector-java]: https://search.maven.org/search?q=a:mysql-connector-java%20AND%20g:mysql
[SessionFactory]: https://github.com/hibernate/hibernate-orm/blob/716a8bac2080fdcce349550e1817b14a100f3b74/hibernate-core/src/main/java/org/hibernate/SessionFactory.java#L32
[SharedEntityManagerCreator]: https://github.com/spring-projects/spring-framework/blob/master/spring-orm/src/main/java/org/springframework/orm/jpa/SharedEntityManagerCreator.java#L71
[Open Session_EntityManager]: https://www.baeldung.com/spring-open-session-in-view
[Github]: https://github.com/eugenp/tutorials/tree/master/persistence-modules/hibernate5