JPA的EntityManager操作

JPA的EntityManager操作

1.简介

持久化单元（persist unit）就是关于一组Entity的命名配置。持久化单元是一个静态概念。
持久化上下文（Persist Context）就是一个受管的Entity实例的集合。每一个持久化上下文都关联一个持久化单元，持久化上下文不可能脱离持久化单元独立存在。持久化上下文是一个动态概念。
尽管持久化上下文非常重要，但是开发者不直接与之打交道，持久化上下文在程序中是透明的，我们通过EntityManager间接管理它。
三个类：Persistence，EntityManagerFactory和EntityManager

独立运行环境下：

EntityManagerFactory emf = Persistence.createEntityManagerFactory("JPADemoPU");

EntityManager entityManger = emf.createEntityManager();

使用容器的环境下，不需要通过Persistence创建EntityManagerFactory和EntityManger，而是通过注解实现，以后再讲。

用到Persistence来创建EntityManagerFactory实例：

		// 1. 创建 EntitymanagerFactory
		String persistenceUnitName = "JpaDemo1";

		EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);

		// 2. 创建 EntityManager. 类似于 Hibernate 的 SessionFactory
		EntityManager entityManager = entityManagerFactory.createEntityManager();

其实它还有一个重载方法可用：

Map<String, Object> properties = new HashMap<String, Object>();
properties.put("hibernate.format_sql", false);
EntityManagerFactory factory= Persistence.createEntityManagerFactory(persistenceUnitName,properties);

这里的properties，和配置文件persistence.xml中的属性是一样的。

		<properties>
			<!-- 连接数据库的基本信息 -->
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa" />
			<property name="javax.persistence.jdbc.user" value="ppl" />
			<property name="javax.persistence.jdbc.password" value="1qazxsw2" />
			
			
			<!-- 配置 JPA 实现产品的基本属性. 配置 hibernate 的基本属性 -->
			<property name="hibernate.format_sql" value="true"/>
			<property name="hibernate.show_sql" value="true"/>
			<property name="hibernate.hbm2ddl.auto" value="update"/>
			
			<!-- 二级缓存相关 -->
			<property name="hibernate.cache.use_second_level_cache" value="true"/>
			<property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
			<property name="hibernate.cache.use_query_cache" value="true"/>
		</properties>

EntityManagerFactory

EntityManagerFactory 接口主要用来创建 EntityManager 实例。该接口约定了如下4个方法：

    createEntityManager()：用于创建实体管理器对象实例。

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

    isOpen()：检查 EntityManagerFactory 是否处于打开状态。实体管理器工厂创建后一直处于打开状态，除非调用close()方法将其关闭。

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

EntityManager

以下代码省略了entityManager，entityManagerFactory，transaction的创建，关闭等过程。

2.预备知识：

在 JPA 规范中, EntityManager 是完成持久化操作的核心对象。实体作为普通 Java 对象，只有在调用 EntityManager 将其持久化后才会变成持久化对象。EntityManager 对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。
实体的状态:
新建状态:   新创建的对象，尚未拥有持久性主键。
持久化状态：已经拥有持久性主键并和持久化建立了上下文环境
游离状态：拥有持久化主键，但是没有与持久化建立上下文环境
删除状态:  拥有持久化主键，已经和持久化建立上下文环境，但是从数据库中删除。

# find (Class<T> entityClass,Object primaryKey)：

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

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

		System.out.println(customer);
	}

# getReference (Class<T> 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);
	}

这个会出现懒加载异常现象，比如将上述代码中的注释去掉就会发生懒加载异常。

在代码中，我先调用getReference，然后打印“- - - - - - ”，最后打印Customer对象

但是从截图看，是先打印“- - - - -”，然后才查询Customer，接着打印Customer。

原因：调用getReference()方法，返回的其实并不是Customer对象，而是一个代理。当你要使用Customer时，才会真正的调用查询语句来查询Customer对象。

#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.setBirth(new Date());
		customer.setCreatedTime(new Date());
		customer.setEmail("bb@163.com");
		customer.setLastName("BB");
		//customer.setId(100);

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

#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);
	}

以下代码会出现异常：

	@Test
	public void testRemove() {
		 Customer customer = new Customer();
		 customer.setId(2);

		//Customer customer = entityManager.find(Customer.class, 2);
		entityManager.remove(customer);
	}

# merge (T entity)：

merge() 用于处理 Entity 的同步。即数据库的插入和更新操作。

情况1：传入的对象没有id

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

情况2：传入的对象有id，entityManager的缓存中没有该对象，数据库中没有该记录

	//若传入的是一个游离对象, 即传入的对象有 OID. 
	//1. 若在 EntityManager 缓存中没有该对象
	//2. 若在数据库中也没有对应的记录
	//3. JPA 会创建一个新的对象, 然后把当前游离对象的属性复制到新创建的对象中
	//4. 对新创建的对象执行 insert 操作. 
	@Test
	public void testMerge2(){
		Customer customer = new Customer();
		customer.setAge(18);
		customer.setBirth(new Date());
		customer.setCreatedTime(new Date());
		customer.setEmail("dd@163.com");
		customer.setLastName("DD");
		
		customer.setId(100);
		
		Customer customer2 = entityManager.merge(customer);
		
		System.out.println("customer#id:" + customer.getId());
		System.out.println("customer2#id:" + customer2.getId());
	}

结论：在这种情况下，调用merge方法，将返回一个新的对象，并对该对象执行insert操作。新对象的id是数据库中这条记录的id（比如自增长的id），而不是我们自己传入的id。（其实和情况1的结果是一样的）

情况3：传入的对象有id，entityManager的缓存没有该对象，数据库中有该记录

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

结论：在这种情况下，调用merge方法，将会从数据库中查询对应的记录，生成新的对象，然后将我们传入的对象复制到新的对象，最后执行update操作。 简单来说，就是更新操作。

情况4：传入的对象有id，entityManager的缓存有该对象

	//若传入的是一个游离对象, 即传入的对象有 OID. 
	//1. 若在 EntityManager 缓存中有对应的对象
	//2. JPA 会把游离对象的属性复制到查询到EntityManager 缓存中的对象中.
	//3. EntityManager 缓存中的对象执行 UPDATE. 
	@Test
	public void testMerge4(){
		Customer customer = new Customer();
		customer.setAge(18);
		customer.setBirth(new Date());
		customer.setCreatedTime(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
	}

# 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();
	}

#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);
	}

运行以上代码，发现调用了两次find，但是只执行了一次select语句，这是缓存导致的。

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

只调用了一次find方法，却执行了两次select语句，这是因为refresh方法会去查看缓存中的数据状态和数据库中是否一致，因此又执行了一次select语句

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