JPA - EntityManager详解

**
 * Interface used to interact with the persistence context.
 *//这里讲述了EntityManager的作用！！！
 * <p> An <code>EntityManager</code> instance is associated with
 * a persistence context. A persistence context is a set of entity
 * instances in which for any persistent entity identity there is
 * a unique entity instance. Within the persistence context, the
 * entity instances and their lifecycle are managed.
 * The <code>EntityManager</code> API is used
 * to create and remove persistent entity instances, to find entities
 * by their primary key, and to query over entities.
 *
 * <p> The set of entities that can be managed by a given
 * <code>EntityManager</code> instance is defined by a persistence
 * unit. A persistence unit defines the set of all classes that are
 * related or grouped by the application, and which must be
 * colocated in their mapping to a single database.
 *
 * @see Query
 * @see TypedQuery
 * @see CriteriaQuery
 * @see PersistenceContext
 *
 * @since Java Persistence 1.0
 */
public interface EntityManager {
//...
}

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

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();
    }
    //类似于hibernate中session的get方法--先创建
    @Test
    public void testFind(){
        Customer customer = entityManager.find(Customer.class,1);
        System.out.println(customer.getClass().getName());
        System.out.println("-----------------------------------------------");
        System.out.println(customer.toString());
    }

    //类似于hibernate中session的load方法--需要的时候再创建
    @Test
    public void testGetReference(){
        Customer customer = entityManager.getReference(Customer.class, 1);
        // 这里是代理对象 com.atguigu.jpa.helloworld.Customer_$$_javassist_0，容易出现懒加载异常
        System.out.println(customer.getClass().getName());
        System.out.println("-----------------------------------------------");
//      transaction.commit();
//      entityManager.close();
        System.out.println(customer.toString());
    }

    //类似于hibernate中session的save方法,使对象由临时状态变为持久化状态
    //和hibernate的save方法的不通之处：若对象由id，则不能执行持久化insert操作，而会抛出异常
    @Test
    public void testPersist(){
        Customer customer = new Customer();
//      customer.setId(3);
        customer.setAge(11);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("jane@163.com");
        customer.setLastName("jane");
        entityManager.persist(customer);
        System.out.println("-----------------------------------------------");
        System.out.println(customer.toString());
    }

    //类似于hibernate中session的delete方法,把对象对应的记录从数据库删除
    //但注意该方法只能移除持久化对象，而hibernate对象的delete方法还可以移除游离对象
    @Test
    public void testRemove(){
        Customer customer = entityManager.find(Customer.class, 2);
        entityManager.remove(customer);
        System.out.println("-----------------------------------------------");
        System.out.println(customer.toString());
    }

/**
     * 1.若传入的是一个临时对象,则会创建一个新对象，把临时对象的属性复制到新对象中，然后对新对象进行持久化操作
     * 即，新对象将有id，但以前的临时对象没有id
     */
    @Test
    public void testMerge1(){
        Customer customer = new Customer();
        customer.setAge(11);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("jane@163.com");
        customer.setLastName("jane");
        Customer customer2 = entityManager.merge(customer);
        System.out.println("customer#id :"+customer.getId());
        System.out.println("customer2#id :"+customer2.getId());
    }

/**
     * 3.若传入的对象是一个游离对象，即对象有OID；
     * em缓存中存在该对象，jpa会把游离对象复制到缓存中的对象，
     * 然后进行更新操作
     * 
     */
    @Test
    public void testMerge3(){
        Customer customer = new Customer();
        customer.setAge(11);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("jane4@163.com");
        customer.setLastName("jane4");
        customer.setId(4);
        System.out.println("customer :"+customer.toString());
        Customer customer2 = entityManager.find(Customer.class, 4);
        System.out.println("customer2 :"+customer2.toString());
        Customer merge = entityManager.merge(customer);
        System.out.println("merge :"+merge.toString());
    }

FlushModeType.AUTO 为自动更新数据库实体，
FlushModeType.COMMIT 为直到提交事务时才更新数据库记录。

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

/**
     * ͬ hibernate 的 Session 的 refresh 方法. 
     */
    @Test
    public void testRefresh(){
        Customer customer = entityManager.find(Customer.class, 1);
        customer = entityManager.find(Customer.class, 1);
        customer.setAge(100);
        System.out.println(customer.toString());
        entityManager.refresh(customer);
        System.out.println(customer.toString());
    }