SpringData专题(四)-JPA的API介绍

最新推荐文章于 2025-05-07 16:20:01 发布

转载最新推荐文章于 2025-05-07 16:20:01 发布 · 190 阅读

CC 4.0 BY-SA版权

原文链接：https://blog.youkuaiyun.com/BruceLiu_code/article/details/94724913

本文深入解析了Java Persistence API(JPA)的核心组件，包括Persistence、EntityManagerFactory、EntityManager及EntityTransaction的使用方法，详细阐述了实体状态管理、实体查询、持久化、更新和删除操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.Persistence对象

Persistence 类是用于获取 EntityManagerFactory 实例。该类包含一个名为 createEntityManagerFactory 的静态方法。

createEntityManagerFactory 方法有如下两个重载版本。
带有一个参数的方法以 JPA 配置文件 persistence.xml 中的持久化单元名为参数

 /**
  * 创建实体管理类工厂，借助Persistence的静态方法获取
  * 其中传递的参数为持久化单元名称，需要jpa配置文件中指定
 */
EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");

带有两个参数的方法：前一个参数含义相同，后一个参数 Map类型，用于设置 JPA 的相关属性，这时将忽略其它地方设置的属性。Map 对象的属性名必须是 JPA 实现库提供商的名字空间约定的属性名。
```
Map<String,Object> properties=new HashMap<String,Object>();
properties.put("hibernate.show_sql",false);
EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa",properties);
```

2.EntityManagerFactory对象

EntityManagerFactory 接口主要用来创建 EntityManager 实例。该接口约定了如下4个方法：
createEntityManager()：用于创建实体管理器对象实例().

//通过工厂获取实体类管理器
EntityManager entityManager = factory.createEntityManager();

createEntityManager(Map map)：用于创建实体管理器对象实例的重载方法，Map 参数用于提供EntityManager 的属性。

Map<String,Object> map=new HashMap<>();
map.put("org.hibernate.flushMode","COMMIT");

em = factory.createEntityManager(map);

Map<String, Object> properties = em.getProperties();//获取所有属性
System.out.println(properties);

  
  **isOpen**()：检查 EntityManagerFactory 是否处于打开状态。实体管理器工厂创建后一直处于打开状态，除非调用close()方法将其关闭.
  
  ```java
  Map<String,Object> properties=new HashMap<String,Object>();
  properties.put("hibernate.show_sql",false);
  //通过工厂获取实体类管理器
EntityManager entityManager = factory.createEntityManager(properties);
  System.out.println("EntityManagerFactory是否打开:"+entityManager.isOpen());

close()：关闭 EntityManagerFactory 。 EntityManagerFactory 关闭后将释放所有资源，isOpen()方法测试将返回 false，其它方法将不能调用，否则将导致IllegalStateException异常。

  factory.close();

EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个EntityManagerFactory 即可。

3.EntityManager基础方法

在 JPA 规范中, EntityManager 是完成持久化操作的核心对象。实体作为普通 Java 对象，只有在调用EntityManager 将其持久化后才会变成持久化对象。

EntityManager 对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

实体的状态:

新建状态(NEW): 新创建的对象，尚未拥有持久性主键(并未持久化到数据库的状态)。
持久化状态(Managed)：已经拥有持久性主键并和持久化建立了上下文环境
游离状态(Detached)：拥有持久化主键，但是没有与持久化建立上下文环境
删除状态(Removed): 拥有持久化主键，已经和持久化建立上下文环境，但是从数据库中删除。

Entity生命周期中的New、Managed，Detached，Removed三种状态变化过程，如下图所示：

3.1 find方法

find (Class entityClass,Object primaryKey)：返回指定的 OID 对应的实体类对象，如果这个实体存在于当前的持久化环境，则返回一个被缓存的对象；否则会创建一个新的 Entity, 并加载数据库中相关信息；若 OID 不存在于数据库中，则返回一个 null。第一个参数为被查询的实体类类型，第二个参数为待查找实体的主键值。

public class JPA_TEST {

	private EntityManagerFactory entityManagerFactory;
	private EntityManager entityManager;
	private EntityTransaction transaction;

	@Before
	public void init() {
		entityManagerFactory = Persistence.createEntityManagerFactory("JPA-DEMO");
		entityManager = entityManagerFactory.createEntityManager();
		transaction = entityManager.getTransaction();
		transaction.begin();
	}

	@After
	public void destroy() {
		transaction.commit();
		entityManager.close();
		entityManagerFactory.close();
	}

	//类似于 hibernate 中 Session 的 get 方法.
	@Test
	public void testFind() {
		Customer customer = entityManager.find(Customer.class, 1);
        System.out.println(customer);
		System.out.println("-------------------------------------");
	}
}

3.2. getReference方法

getReference (Class entityClass,Object primaryKey)：与find()方法类似，不同的是：如果缓存中不存在指定的 Entity, EntityManager 会创建一个Entity类的代理，但是不会立即加载数据库中的信息，只有第一次真正使用此 Entity 的属性才加载，所以如果此 OID 在数据库不存在，getReference() 不会返回 null 值, 而是抛出EntityNotFoundException.

//类似于hibernate中Session的load方法
@Test
public void testGetReference() {
	Customer customer = entityManager.getReference(Customer.class, 1);
	System.out.println(customer.getClass().getName()); //代理对象
	System.out.println("-------------------------------------");
	//transaction.commit();
	//entityManager.close();
	System.out.println(customer);
}

3.3. persist方法

persist (Object entity)：用于将新创建的 Entity 纳入到 EntityManager 的管理。该方法执行后，传入 persist() 方法的 Entity 对象转换成持久化状态。
如果传入 persist() 方法的 Entity 对象已经处于持久化状态，则 persist() 方法什么都不做。
如果对删除状态的 Entity 进行 persist() 操作，会转换为持久化状态。
如果对游离状态的实体执行 persist() 操作，可能会在 persist() 方法抛出 EntityExistException(也有可能是在flush或事务提交后抛出)。

// 类似于 hibernate 的 save 方法. 使对象由临时状态变为持久化状态.
// 和 hibernate 的 save 方法的不同之处: 若对象有id, 则不能执行insert操作, 而会抛出异常.
@Test
public void testPersistence() {
	
	Customer customer = new Customer();
	customer.setAge(15);
	customer.setBirthday(new Date());
	customer.setCreateTime(new Date());
	customer.setEmail("bruce@163.com");
	customer.setLastName("bruceliu");
	//customer.setId(100);

	entityManager.persist(customer);
	System.out.println(customer.getId());
}

3.4. remove方法

remove (Object entity)：删除实例。如果实例是被管理的，即与数据库实体记录关联，则同时会删除关联的数据库记录。

// 类似于 hibernate 中 Session 的 delete 方法. 把对象对应的记录从数据库中移除
// 但注意: 该方法只能移除 持久化 对象. 而 hibernate 的 delete 方法实际上还可以移除 游离对象.
@Test
public void testRemove() {
	// Customer customer = new Customer();
	// customer.setId(2);
	Customer customer = entityManager.find(Customer.class, 2);
	entityManager.remove(customer);
}

3.5. merge方法

如果一个对象有ID，并且这个ID在数据库存在，那么就根据ID更新这个对象

如果一个对象有ID, 但是数据库中没有这个对象，执行的还是新增操作！

如果一个对象没有ID，执行新增操作！

merge (T entity)：merge() 用于处理 Entity 的同步。即数据库的插入和更新操作
在这里插入图片描述

场景1

/**
 * 总的来说: 类似于 hibernate Session 的 saveOrUpdate 方法.
 */
// 1. 若传入的是一个临时对象
// 会创建一个新的对象, 把临时对象的属性复制到新的对象中, 然后对新的对象执行持久化操作. 所以
// 新的对象中有 id, 但以前的临时对象中没有 id.
@Test
public void testMerge1() {
	Customer customer = new Customer();
	customer.setAge(18);
	customer.setBirthday(new Date());
	customer.setCreateTime(new Date());
	customer.setEmail("mary@163.com");
	customer.setLastName("Mary");
	
	Customer customer2 = entityManager.merge(customer);
	System.out.println("customer#id:" + customer.getId());
	System.out.println("customer2#id:" + customer2.getId());
}

场景2

// 若传入的是一个游离对象, 即传入的对象有 OID.
// 1. 若在 EntityManager 缓存中没有该对象
// 2. 若在数据库中也没有对应的记录
// 3. JPA 会创建一个新的对象, 然后把当前游离对象的属性复制到新创建的对象中
// 4. 对新创建的对象执行 insert 操作.
@Test
public void testMerge2() {
	Customer customer = new Customer();
	customer.setAge(18);
	customer.setBirthday(new Date());
	customer.setCreateTime(new Date());
	customer.setEmail("Kite@163.com");
	customer.setLastName("Kite");

	customer.setId(100);

	Customer customer2 = entityManager.merge(customer);

	System.out.println("customer#id:" + customer.getId());
	System.out.println("customer2#id:" + customer2.getId());
}

场景3

// 若传入的是一个游离对象, 即传入的对象有 OID.
// 1. 若在 EntityManager 缓存中没有该对象
// 2. 若在数据库中也有对应的记录
// 3. JPA 会查询对应的记录, 然后返回该记录对一个的对象, 再然后会把游离对象的属性复制到查询到的对象中.
// 4. 对查询到的对象执行 update 操作.
@Test
public void testMerge3() {
	Customer customer = new Customer();
	customer.setAge(18);
	customer.setBirthday(new Date());
	customer.setCreateTime(new Date());
	customer.setEmail("Lucy@163.com");
	customer.setLastName("Lucy");
	customer.setId(4);
	Customer customer2 = entityManager.merge(customer);
	System.out.println(customer == customer2); // false
}

场景4

// 若传入的是一个游离对象, 即传入的对象有 OID.
// 1. 若在 EntityManager 缓存中有对应的对象
// 2. JPA 会把游离对象的属性复制到查询到EntityManager 缓存中的对象中.
// 3. EntityManager 缓存中的对象执行 UPDATE.
@Test
public void testMerge4() {
	Customer customer = new Customer();
	customer.setAge(18);
	customer.setBirthday(new Date());
	customer.setCreateTime(new Date());
	customer.setEmail("dd@163.com");
	customer.setLastName("DD");
	customer.setId(4);
	
	Customer customer2 = entityManager.find(Customer.class, 4);
	entityManager.merge(customer);
	System.out.println(customer == customer2); // false
}

3.6 flush方法

flush ()：同步持久上下文环境，即将持久上下文环境的所有未保存实体的状态信息保存到数据库中。
setFlushMode (FlushModeType flushMode)：设置持久上下文环境的Flush模式。参数可以取2个枚举
FlushModeType.AUTO 为自动更新数据库实体，
FlushModeType.COMMIT 为直到提交事务时才更新数据库记录。
getFlushMode ()：获取持久上下文环境的Flush模式。返回FlushModeType类的枚举值。

/**
 * 同 hibernate 中 Session 的 flush 方法.
 */
@Test
public void testFlush() {
	Customer customer = entityManager.find(Customer.class, 1);
	System.out.println(customer);
	customer.setLastName("AA");
	entityManager.flush();
}

3.7 refresh 方法

refresh (Object entity)：用数据库实体记录的值更新实体对象的状态，即更新实例的属性值。

/**
 * 同 hibernate 中 Session 的 refresh 方法.
 */
@Test
public void testRefresh() {
	Customer customer = entityManager.find(Customer.class, 1);
	customer = entityManager.find(Customer.class, 1);
	entityManager.refresh(customer);
}

3.8 其他的方法

clear ()：清除持久上下文环境，断开所有关联的实体。如果这时还有未提交的更新则会被撤消。
contains (Object entity)：判断一个实例是否属于当前持久上下文环境管理的实体。
isOpen ()：判断当前的实体管理器是否是打开状态。
getTransaction ()：返回资源层的事务对象。EntityTransaction实例可以用于开始和提交多个事务。
close ()：关闭实体管理器。之后若调用实体管理器实例的方法或其派生的查询对象的方法都将抛出 IllegalstateException 异常，除了getTransaction 和 isOpen方法(返回 false)。不过，当与实体管理器关联的事务处于活动状态时，调用 close 方法后持久上下文将仍处于被管理状态，直到事务完成。

4.EntityTransaction事务相关

EntityTransaction 接口用来管理资源层实体管理器的事务操作。通过调用实体管理器的getTransaction方法获得其实例。

begin ()
用于启动一个事务，此后的多个数据库操作将作为整体被提交或撤消。若这时事务已启动则会抛出 IllegalStateException 异常。
commit ()
用于提交当前事务。即将事务启动以后的所有数据库更新操作持久化至数据库中。
rollback ()
撤消(回滚)当前事务。即撤消事务启动后的所有数据库更新操作，从而不对数据库产生影响。
setRollbackOnly ()
使当前事务只能被撤消。
getRollbackOnly ()
查看当前事务是否设置了只能撤消标志。
isActive ()
查看当前事务是否是活动的。如果返回true则不能调用begin方法，否则将抛出 IllegalStateException 异常；如果返回 false 则不能调用 commit、rollback、setRollbackOnly 及 getRollbackOnly 方法，否则将抛出 IllegalStateException 异常。

@Before
public void init() {
	entityManagerFactory = Persistence.createEntityManagerFactory("JPA-DEMO");
	entityManager = entityManagerFactory.createEntityManager();
	transaction = entityManager.getTransaction();
	transaction.begin();
}

@After
public void destroy() {
	transaction.commit();
	entityManager.close();
	entityManagerFactory.close();
}