JPA的几个常用操作

测试几个JPA的常用操作，并和hibernate的Session作对比

直接上代码
以表格Customer为例

package com.bart.jpa.JapTest;

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.bart.jpa.beans.Customer;

public class JpaTest {

    private String persistenceUnitName = "jpa-1";
    private EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
    private EntityManager manager = entityManagerFactory.createEntityManager();
    private EntityTransaction transaction ;

    /**
     * 同 hibernate 中 Session 的 refresh 方法. 
     */
    @Test
    public void testRefresh(){
        //因为一级缓存的原因，只有一条sql语句
        Customer customer = manager.find(Customer.class, 1);
        customer = manager.find(Customer.class, 1);

        //refresh之后仍然会发送一条sql语句
        manager.refresh(customer);
    }

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

        customer.setLastName("AA");
      //本来是在commit的时候才会刷新缓存，但是使用flush之后会提前强制书刷新缓存
        manager.flush();
    }


    //若传入的是一个游离对象, 即传入的对象有 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.setCreateTime(new Date());
        customer.setEmail("dd@163.com");
        customer.setLastName("DD");

        customer.setId(4);
        Customer customer2 = manager.find(Customer.class, 4);

        manager.merge(customer);

        System.out.println(customer == customer2); //false
    }

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

        customer.setId(4);

        Customer customer2 = manager.merge(customer);

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

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

        customer.setId(100);

        Customer customer2 = manager.merge(customer);

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

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

        Customer customer2 = manager.merge(customer);

        System.out.println("customer#id:" + customer.getId());
        System.out.println("customer2#id:" + customer2.getId());
    }
    /**
     * 类似 hibernate 的session 的 delete 方法，把对象移除
     * 注意：该方法只能够移除持久化对象，但是hibernate 的 session
     * 能够移除 游离态对象
     */
    @Test
    public void testRemove(){
        Customer customer = new Customer();
//        customer.setId(2);

        customer = manager.find(Customer.class, 3);
        manager.remove(customer);
    }

    /**
     *  类似 hibernate 的 save 方法，是对象从游离态转变为持久态
     *  和 hibernate 的 save 方法不同的是，若对象有id，则不能执行
     *  insert操作 否则会抛出异常 
     */
    @Test
    public void testPersistence(){
       Customer customer = new Customer();
       customer.setAge(23);
       customer.setLastName("Lisa");
       customer.setEmail("lisa@163.com");
       //customer.setId(3);//不能 setId 会报错

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

    /**
     * 类似 hibernate 的session 的load 方法，
     * 当真正调用对象的时候才会执行查询操作
     */
    @Test
    public void testGetReference(){
        Customer customer = manager.getReference(Customer.class, 1);
        System.out.println("---------------------");
        System.out.println(customer);
    }
    /** 类似 hibernate 的 Session 的 get 方法
      * 当 find 方法执行的，不管是否使用返回的对象，都已经查询过了
      */
    @Test
    public void testFind(){
        Customer c = manager.find(Customer.class, 1);
        System.out.println("---------");
        System.out.println(c);

    }

    @Test//创建数据库并增添对象
    public void test(){
        //4.创建对象啊ing
        Customer c = new Customer("bart", "bart@163.com", 25, new Date());
        //5.保存
        manager.persist(c);
    }
    @Before
    public void before(){
      //1.创建EntityManagerFactory
      entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
      //2.创建EntityManager
      manager = entityManagerFactory.createEntityManager();
      //3.开启事务管理
      transaction = manager.getTransaction();
      transaction.begin();
    }
    @After
    public void after(){
        transaction.commit();
        //6. 关闭factory
        entityManagerFactory.close();
        //7. 关闭manager
        manager.close();
    }
}