JPA(API)

1、

Persistence  

EntityManagerFactory

2、

EntityManager#find

EntityManager#getReference

EntityManager#persistence

EntityManager#remove

3、

EntityTransaction(事物)

4、EntityManager 其他方法

5、EntityManager#merge

 

1、JPA相关接口/类：Persistence

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

.createEntityManagerFactory 方法有如下两个重载版本。 带有一个参数的方法以 JPA 配置文件 persistence.xml 中的持久化单元名为参数 带有两个参数的方法：前一个参数含义相同，后一个参数 Map类型，用于设置 JPA 的相关属性，这时将忽略其它地方设置的属性。Map 对象的属性名必须是 JPA 实现库提供商的名字空间约定的属性名。

2、EntityManagerFactory

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

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

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

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

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

4、EntityManager

在 JPA 规范中, EntityManager 是完成持久化操作的核心对象。实体作为普通 Java 对象，只有在调用 EntityManager 将其持久化后才会变成持久化对象。EntityManager 对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

实体的状态: 新建状态: 新创建的对象，尚未拥有持久性主键。

持久化状态：已经拥有持久性主键并和持久化建立了上下文环境

游离状态：拥有持久化主键，但是没有与持久化建立上下文环境

删除状态: 拥有持久化主键，已经和持久化建立上下文环境，但是从数据库中删除。

 

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

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

 

getReference (Class<T> entityClass,Object primaryKey)：

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

persist (Object entity)：

用于将新创建的 Entity 纳入到 EntityManager 的管理。该方法执行后，传入 persist() 方法的 Entity 对象转换成持久化状态。

--如果传入 persist() 方法的 Entity 对象已经处于持久化状态，则 persist() 方法什么都不做。

--如果对删除状态的 Entity 进行 persist() 操作，会转换为持久化状态。

--如果对游离状态的实体执行 persist() 操作，可能会在 persist() 方法抛出 EntityExistException(也有可能是在flush或事务提交后抛出)。

remove (Object entity)

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

 

 

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

 

 

EntityTransaction(事物管理)

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

begin ()

----用于启动一个事务，此后的多个数据库操作将作为整体被提交或撤消。若这时事务已启动则会抛出 IllegalStateException 异常。

commit ()

----用于提交当前事务。即将事务启动以后的所有数据库更新操作持久化至数据库中。

rollback ()

-----撤消(回滚)当前事务。即撤消事务启动后的所有数据库更新操作，从而不对数据库产生影响。

setRollbackOnly ()

-----使当前事务只能被撤消。

getRollbackOnly ()

----查看当前事务是否设置了只能撤消标志。

isActive ()

 -----查看当前事务是否是活动的。如果返回true则不能调用begin方法，否则将抛出 IllegalStateException 异常；

如果返回 false 则不能调用 commit、rollback、setRollbackOnly 及 getRollbackOnly 方法，否则将抛出 IllegalStateException 异常。

 

相关测试代码：

 

package com.jpa.test;



import java.util.Date;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.guigu.jpa.helloword.Customer;

public class JPATest {
    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;
    @Before
    public void init(){
        entityManagerFactory= Persistence.createEntityManagerFactory("jpa-1");
        entityManager=entityManagerFactory.createEntityManager();
        transaction=entityManager.getTransaction();
        transaction.begin();//开启事务
        
    }
    @After
    public void destroy(){
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }
    
    /**
     * 若传入得是一个游离状态的对象，即传入的对象有OID
     * 1、若在EntityManager缓存中有该对象
     * 2、JPA会把游离状态的属性复制到EntityManager缓存中的对象中
     * 3、EntityManager缓存中的对象象执行update
     */
    @Test
    public void testMerge4(){
        Customer customer=new Customer();
        customer.setAge(16);
        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
        
    }
    
    /**
     * 若传入得是一个游离状态的对象，即穿入的对象有OID
     * 1、若在EntityManager缓存中没有该对象
     * 2、若在数据库中有改记录
     * 3JPA会查询对应的记录，然后返回该记录对应的一个对象，再然后会把游离对象的属性复制到查询到的对象中
     * 4、对查询到的对象执行update操作
     */
    @Test
    public void testMerge3(){
        Customer customer=new Customer();
        customer.setAge(16);
        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
        
    }
    
    
    /**
     * 若传入得是一个游离状态的对象，即穿入的对象有OID
     * 1、若在EntityManager缓存中没有该对象
     * 2、若在数据库中也没有改记录
     * 3JPA会创建一个新对象，然后把前游离对象的属性复制到新创建的对象中
     * 4、对新创建的对象执行insert操作
     */
    @Test
    public void testMerge2(){
        Customer customer=new Customer();
        customer.setAge(16);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("hello@163.com");
        customer.setLastName("李四");
        customer.setId(100);
        Customer customer2=entityManager.merge(customer);
        System.out.println("customer#id"+customer.getId());
        System.out.println("customer2#id"+customer2.getId());
        
    }
    
    
    /*
     * 总的来说：类似于hibernate session 的saveOrUpdate方法
     * 1.若传入得是一个临时对象则会创建一个新对象，把零时对象的属性复制到新对象中，然后对新对象执行持久化操作
     * 所以新的对象有id,但是以前的零时对象中没有id
     */
    @Test
    public void testMerge1(){
        Customer customer=new Customer();
        customer.setAge(16);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("hello@163.com");
        customer.setLastName("李四");
        
        Customer customer2=entityManager.merge(customer);
        System.out.println("customer#id"+customer.getId());
        System.out.println("customer2#id"+customer2.getId());
        
    }
    //类似于hibernated的delete方法，把对象对应的记录从数据库中移除
    //但注意：该方法只能移除持久化对象，而hibernate的delete方法实际上还可以移除游离对象
    @Test
    public void testRemove(){
//        Customer customer =new Customer();
//        customer.setId(2);
        Customer customer=entityManager.find(Customer.class, 2);
        entityManager.remove(customer);
        
        
        
        
    }
    
    //类似于hibernate的save方法使对象由临时状态转变为持久化状态
    //和hibernatede save方法不同之处：对象由id则不能执行insert操作，会抛出异常
    @Test
    public void testPersistence(){
        Customer customer=new Customer();
        customer.setAge(22);
        
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("@123456.conm");    
        customer.setLastName("张三");
//        customer.setId(100);//hi抛出异常
        entityManager.persist(customer);
        System.err.println(customer.getId());
        
    }
    
    //类似于hibernate 中的session中的load方法
    @Test
    public void testGetReference(){
        Customer customer=entityManager.getReference(Customer.class, 1);//1表示id
        System.out.println(customer.getClass().getName());
        System.out.println("-------------------------------");
//        transaction.commit();
//        entityManagerFactory.close();
        System.out.println(customer);
        
    }
    //类似于hibernate 中的session中的get方法
    @Test
    public void testFind(){
        Customer customer=entityManager.find(Customer.class, 1);//1表示id
        System.out.println("-------------------------------");
        System.out.println(customer);
        
    }

}

 

 

 

 

完整 源码地址：https://github.com/wuhongpu/JPA.git