使用JPA完成增删改查操作

基础的增删改查操作如下:

  1 package cn.itheima.test;
  2 
  3 import cn.itcast.domain.Customer;
  4 import cn.itcast.utils.JpaUtils;
  5 import org.junit.Test;
  6 
  7 import javax.persistence.EntityManager;
  8 import javax.persistence.EntityManagerFactory;
  9 import javax.persistence.EntityTransaction;
 10 import javax.persistence.Persistence;
 11 
 12 public class JpaTest {
 13 
 14     /**
 15      * 测试jpa的保存
 16      * 案例:保存一个客户到数据库中
 17      * Jpa的操作步骤
 18      * 1.加载配置文件创建工厂(实体管理器工厂)对象
 19      * 2.通过实体管理器工厂获取实体管理器
 20      * 3.获取事务对象,开启事务
 21      * 4.完成增删改查操作
 22      * 5.提交事务(回滚事务)
 23      * 6.释放资源
 24      */
 25     @Test
 26     public void testSave() {
 27 //        //1.加载配置文件创建工厂(实体管理器工厂)对象
 28 //        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
 29 //        //2.通过实体管理器工厂获取实体管理器
 30 //        EntityManager em = factory.createEntityManager();
 31         EntityManager em = JpaUtils.getEntityManager();
 32         //3.获取事务对象,开启事务
 33         EntityTransaction tx = em.getTransaction(); //获取事务对象
 34         tx.begin();//开启事务
 35         //4.完成增删改查操作:保存一个客户到数据库中
 36         Customer customer = new Customer();
 37         customer.setCustName("传智播客");
 38         customer.setCustIndustry("教育");
 39         //保存,
 40         em.persist(customer); //保存操作
 41         //5.提交事务
 42         tx.commit();
 43         //6.释放资源
 44         em.close();
 45         //       factory.close();
 46 
 47     }
 48 
 49     /**
 50      * 根据id查询客户
 51      *  使用find方法查询:
 52      *      1.查询的对象就是当前客户对象本身
 53      *      2.在调用find方法的时候,就会发送sql语句查询数据库
 54      *
 55      *  立即加载
 56      *
 57      *
 58      */
 59     @Test
 60     public  void testFind() {
 61         //1.通过工具类获取entityManager
 62         EntityManager entityManager = JpaUtils.getEntityManager();
 63         //2.开启事务
 64         EntityTransaction tx = entityManager.getTransaction();
 65         tx.begin();
 66         //3.增删改查 -- 根据id查询客户
 67         /**
 68          * find : 根据id查询数据
 69          *      class:查询数据的结果需要包装的实体类类型的字节码
 70          *      id:查询的主键的取值
 71          */
 72         Customer customer = entityManager.find(Customer.class, 1l);
 73         // System.out.print(customer);
 74         //4.提交事务
 75         tx.commit();
 76         //5.释放资源
 77         entityManager.close();
 78     }
 79 
 80     /**
 81      * 根据id查询客户
 82      *      getReference方法
 83      *          1.获取的对象是一个动态代理对象
 84      *          2.调用getReference方法不会立即发送sql语句查询数据库
 85      *              * 当调用查询结果对象的时候,才会发送查询的sql语句:什么时候用,什么时候发送sql语句查询数据库
 86      *
 87      * 延迟加载(懒加载)
 88      *      * 得到的是一个动态代理对象
 89      *      * 什么时候用,什么使用才会查询
 90      */
 91     @Test
 92     public  void testReference() {
 93         //1.通过工具类获取entityManager
 94         EntityManager entityManager = JpaUtils.getEntityManager();
 95         //2.开启事务
 96         EntityTransaction tx = entityManager.getTransaction();
 97         tx.begin();
 98         //3.增删改查 -- 根据id查询客户
 99         /**
100          * getReference : 根据id查询数据
101          *      class:查询数据的结果需要包装的实体类类型的字节码
102          *      id:查询的主键的取值
103          */
104         Customer customer = entityManager.getReference(Customer.class, 1l);
105         System.out.print(customer);
106         //4.提交事务
107         tx.commit();
108         //5.释放资源
109         entityManager.close();
110     }
111 
112     /**
113      * 删除客户的案例
114      *
115      */
116     @Test
117     public  void testRemove() {
118         //1.通过工具类获取entityManager
119         EntityManager entityManager = JpaUtils.getEntityManager();
120         //2.开启事务
121         EntityTransaction tx = entityManager.getTransaction();
122         tx.begin();
123         //3.增删改查 -- 删除客户
124 
125         //i 根据id查询客户
126         Customer customer = entityManager.find(Customer.class,1l);
127         //ii 调用remove方法完成删除操作
128         entityManager.remove(customer);
129 
130         //4.提交事务
131         tx.commit();
132         //5.释放资源
133         entityManager.close();
134     }
135 
136     /**
137      * 更新客户的操作
138      *      merge(Object)
139      */
140     @Test
141     public  void testUpdate() {
142         //1.通过工具类获取entityManager
143         EntityManager entityManager = JpaUtils.getEntityManager();
144         //2.开启事务
145         EntityTransaction tx = entityManager.getTransaction();
146         tx.begin();
147         //3.增删改查 -- 更新操作
148 
149         //i 查询客户
150         Customer customer = entityManager.find(Customer.class,1l);
151         //ii 更新客户
152         customer.setCustIndustry("it教育");
153         entityManager.merge(customer);
154 
155         //4.提交事务
156         tx.commit();
157         //5.释放资源
158         entityManager.close();
159     }
160 
161 }

说明:find()和getReference()区别:

根据id查询客户
    使用find方法查询:
    1.查询的对象就是当前客户对象本身
    2.在调用find方法的时候,就会发送sql语句查询数据库
立即加载
=====================================================
根据id查询客户
    getReference方法
         1.获取的对象是一个动态代理对象
         2.调用getReference方法不会立即发送sql语句查询数据库
             * 当调用查询结果对象的时候,才会发送查询的sql语句:什么时候用,什么时候发送sql语句查询数据库
延迟加载(懒加载)
     * 得到的是一个动态代理对象
     * 什么时候用,什么使用才会查询
原文地址:https://www.cnblogs.com/116970u/p/11589895.html