JPA(API)

一、

Persistence  

EntityManagerFactory

二、

EntityManager#find

EntityManager#getReference

EntityManager#persistence

EntityManager#remove

三、

EntityTransaction(事物)

四、EntityManager 其余方法

五、EntityManager#merge

 

一、JPA相关接口/类：Persistence

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

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

二、EntityManagerFactory

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

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

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

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

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

四、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
     * 一、若在EntityManager缓存中有该对象
     * 二、JPA会把游离状态的属性复制到EntityManager缓存中的对象中
     * 三、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
     * 一、若在EntityManager缓存中没有该对象
     * 二、若在数据库中有改记录
     * 3JPA会查询对应的记录，而后返回该记录对应的一个对象，再而后会把游离对象的属性复制到查询到的对象中
     * 四、对查询到的对象执行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
     * 一、若在EntityManager缓存中没有该对象
     * 二、若在数据库中也没有改记录
     * 3JPA会建立一个新对象，而后把前游离对象的属性复制到新建立的对象中
     * 四、对新建立的对象执行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