JPA——API介绍、完成JPA的CRUD操作、JPQL完成复杂查询操作

亦凉 2023-05-21 05:58 15阅读 0赞

## 目录 ##

*  一、JPA的API介绍
 *  二、抽取JPAUtils工具类
 *  三、JPA完成增删改查操作
 *  四、JPA中的复杂查询(使用JPQL)
 *  五、总结

--------------------

# 一、JPA的API介绍 #

跳转到目录

*  `Persistence对象`: **Persistence**对象主要作用是用于获取**EntityManagerFactory**对象的 。通过调用该类的**createEntityManagerFactory**静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。
 *  `EntityManagerFactory`: **EntityManagerFactory** 接口主要用来创建 **EntityManager** 实例; 由于EntityManagerFactory 是一个`线程安全`的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个`EntityManagerFactory(单例)` 即可
 *  `EntityManager` : 在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象，只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 `O/R 映射的管理`。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过`JPQL语句`查询实体。
    
    我们可以通过调用`EntityManager`的方法完成获取 **`事`务**，以及`保存/更新/删除/查询`数据库的操作
    
    > 方法:
    > 
    >  *  getTransaction : 获取事务对象
    >  *  persist ： 保存操作
    >  *  merge ： 更新操作
    >  *  remove ： 删除操作
    >  *  find/getReference ： 根据id查询
 *  `EntityTransaction` : 在 JPA 规范中, EntityTransaction是完成事务操作的核心对象，对于EntityTransaction在我们的java代码中承接的功能比较简单
    
    > begin：开启事务  
    > commit：提交事务  
    > rollback：回滚事务

# 二、抽取JPAUtils工具类 #

跳转到目录

*  由于**EntityManagerFactory** 是一个`线程安全`的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个`EntityManagerFactory` 即可

/** * Description: Jpa的工具类 * * 解决实体管理器工厂的浪费资源和耗时问题 * 通过静态代码块的形式,当程序第一次访问此工具类时,创建一个公共的实体管理器工厂对象 * 第一次访问getEntityManager方法: 经过静态代码块创建一个factory对象, 再调用方法创建一个EntityManager对象 * 第二次方法getEntityManager方法: 直接通过一个已经创建好的factory对象, 创建EntityManager对象 * * @author zygui * @date 2020/5/5 10:30 */
    public class JpaUtils { 
    
        private static EntityManagerFactory factory;
    
        static { 
            // 加载配置文件, 创建entityManagerFactory
            factory = Persistence.createEntityManagerFactory("myJpa");
        }
    
        // 获取EntityManager对象
        public static EntityManager getEntityManager() { 
            return factory.createEntityManager();
        }
    }

# 三、JPA完成增删改查操作 #

跳转到目录

/** * Description: 测试Jpa的test * * @author zygui * @date 2020/5/5 08:53 */
    public class JpaTest { 
    
        /** * 测试jpa的保存 * 案例：保存一个客户到数据库中 * Jpa的操作步骤 * 1.加载配置文件创建工厂（实体管理器工厂）对象 * 2.通过实体管理器工厂获取实体管理器 * 3.获取事务对象，开启事务 * 4.完成增删改查操作 * 5.提交事务（回滚事务） * 6.释放资源 */
        @Test
        public void testSave() { 
            //1. 加载配置文件创建工厂(实体管理器工厂)对象
            EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
            //2. 通过实体管理器工厂获取实体管理器
            EntityManager em = factory.createEntityManager();
            //3. 获取事务对象, 开启事务
            EntityTransaction tx = em.getTransaction(); // 获取事务对象
            tx.begin(); // 开启事务
            //4. 完成增删改查操作: 保存一个客户到数据库中
            Customer customer = new Customer();
            customer.setCustName("gzy");
            customer.setCustIndustry("learn");
            // 保存到数据库的操作
            em.persist(customer);
            //5. 提交事务
            tx.commit();
            //6. 释放资源
            em.close();
            factory.close();
        }
    
        // 使用工具类
        @Test
        public void testSave1() { 
            // 通过工具类来创建实体管理器
            EntityManager em = JpaUtils.getEntityManager();
            //3. 获取事务对象, 开启事务
            EntityTransaction tx = em.getTransaction(); // 获取事务对象
            tx.begin(); // 开启事务
            //4. 完成增删改查操作: 保存一个客户到数据库中
            Customer customer = new Customer();
            customer.setCustName("gzy1");
            customer.setCustIndustry("learn1");
            // 保存到数据库的操作
            em.persist(customer);
            //5. 提交事务
            tx.commit();
            //6. 释放资源
            em.close();
            // factory.close(); 工厂不关闭, 因为是公共的,关闭后,其他线程就不能使用了,又需要重新创建
        }
    
        /** * 根据id查询客户 * 使用find方法查询： * 1.查询的对象就是当前客户对象本身 * 2.在调用find方法的时候，就会发送sql语句查询数据库 * * 立即加载 */
        @Test
        public void testFind() { 
            EntityManager entityManager = JpaUtils.getEntityManager();
            EntityTransaction tx = entityManager.getTransaction();
            tx.begin();
            /* 根据id来查询客户 find: 根据id查询数据 class: 查询数据的结果需要包装的实体类类型的字节码 id: 查询主键的取值 */
            Customer customer = entityManager.find(Customer.class, 1L);
            System.out.println(customer);
            tx.commit();
            entityManager.close();
        }
    
        /** * 根据id查询客户 * getReference方法 * 1.获取的对象是一个动态代理对象 * 2.调用getReference方法不会立即发送sql语句查询数据库 * * 当使用到查询结果对象的时候，才会发送查询的sql语句：什么时候用，什么时候发送sql语句查询数据库 * * 延迟加载（懒加载） * * 得到的是一个动态代理对象 * * 什么时候用，什么使用才会查询 */
        @Test
        public  void testReference() { 
            //1.通过工具类获取entityManager
            EntityManager entityManager = JpaUtils.getEntityManager();
            //2.开启事务
            EntityTransaction tx = entityManager.getTransaction();
            tx.begin();
            //3.增删改查 -- 根据id查询客户
            /** * getReference : 根据id查询数据 * class：查询数据的结果需要包装的实体类类型的字节码 * id：查询的主键的取值 */
            Customer customer = entityManager.getReference(Customer.class, 1L);
            System.out.print(customer);
            //4.提交事务
            tx.commit();
            //5.释放资源
            entityManager.close();
        }
    
        /** * 删除客户的案例 * */
        @Test
        public  void testRemove() { 
            //1.通过工具类获取entityManager
            EntityManager entityManager = JpaUtils.getEntityManager();
            //2.开启事务
            EntityTransaction tx = entityManager.getTransaction();
            tx.begin();
            //3.增删改查 -- 删除客户
    
            //i 根据id查询客户
            Customer customer = entityManager.find(Customer.class,1L);
            //ii 调用remove方法完成删除操作
            entityManager.remove(customer);
    
            //4.提交事务
            tx.commit();
            //5.释放资源
            entityManager.close();
        }
    
    
        /** * 更新客户的操作 * merge(Object) */
        @Test
        public  void testUpdate() { 
            //1.通过工具类获取entityManager
            EntityManager entityManager = JpaUtils.getEntityManager();
            //2.开启事务
            EntityTransaction tx = entityManager.getTransaction();
            tx.begin();
            //3.增删改查 -- 更新操作
    
            //i 查询客户
            Customer customer = entityManager.find(Customer.class,1L);
            //ii 更新客户
            customer.setCustIndustry("it教育");
            entityManager.merge(customer);
    
            //4.提交事务
            tx.commit();
            //5.释放资源
            entityManager.close();
        }
    
    }

# 四、JPA中的复杂查询(使用JPQL) #

跳转到目录  
`JPQL全称Java Persistence Query Language;`

Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。

其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。

/** * Description: 测试Jpql的test * * @author zygui * @date 2020/5/5 08:53 */
    public class JpqlTest { 
    
        /* * 测试jqpl查询 * jqpl: from com.zy.domain.Customer * sql: SELECT * FROM cst_customer */
        @Test
        public void testFindAll() { 
            EntityManager em = JpaUtils.getEntityManager();
            EntityTransaction tx = em.getTransaction();
            tx.begin();
            // 查询全部
            String jpql = "from com.zy.domain.Customer";
            Query query = em.createQuery(jpql); // 创建Query查询对象,Query执行的是jqpl对象
            // 发送查询,并封装结果集
            List resultList = query.getResultList();
            for (Object o : resultList) { 
                System.out.println(o);
            }
            tx.commit();
            em.close();
        }
    
        /** * 排序查询： 倒序查询全部客户（根据id倒序） * sql：SELECT * FROM cst_customer ORDER BY cust_id DESC * jpql：from Customer order by custId desc * * 进行jpql查询 * 1.创建query查询对象 * 2.对参数进行赋值 * 3.查询，并得到返回结果 */
        @Test
        public void testOrders() { 
            //1.获取entityManager对象
            EntityManager em = JpaUtils.getEntityManager();
            //2.开启事务
            EntityTransaction tx = em.getTransaction();
            tx.begin();
            //3.查询全部
            String jpql = "from Customer order by custId desc";
            Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象
    
            //发送查询，并封装结果集
            List list = query.getResultList();
    
            for (Object obj : list) { 
                System.out.println(obj);
            }
    
            //4.提交事务
            tx.commit();
            //5.释放资源
            em.close();
        }
    
        /** * 使用jpql查询，统计客户的总数 * sql：SELECT COUNT(cust_id) FROM cst_customer * jpql：select count(custId) from Customer */
        @Test
        public void testCount() { 
            EntityManager em = JpaUtils.getEntityManager();
            EntityTransaction tx = em.getTransaction();
            tx.begin();
            // 查询全部
            //1. 根据jpql语句创建Query查询对象
            String jpql = "select count(custId) from Customer";
            Query query = em.createQuery(jpql);
            /* getResultList: 直接将查询结果封装为list集合 getSingleResult: 得到唯一的结果集 */
            Object result = query.getSingleResult();
            System.out.println(result);
    
            tx.commit();
            em.close();
        }
    
        /** * 分页查询 * sql：select * from cst_customer limit 0,2 * jqpl : from Customer 需要对分页设置 */
        @Test
        public void testPaged() { 
            //1.获取entityManager对象
            EntityManager em = JpaUtils.getEntityManager();
            //2.开启事务
            EntityTransaction tx = em.getTransaction();
            tx.begin();
            //3.查询全部
            //i.根据jpql语句创建Query查询对象
            String jpql = "from Customer";
            Query query = em.createQuery(jpql);
            //ii.对参数赋值 -- 分页参数
            //起始索引
            query.setFirstResult(0);
            //每页查询的条数
            query.setMaxResults(1);
    
            //iii.发送查询，并封装结果
    
            /** * getResultList ： 直接将查询结果封装为list集合 * getSingleResult : 得到唯一的结果集 */
            List list = query.getResultList();
    
            for(Object obj : list) { 
                System.out.println(obj);
            }
    
            //4.提交事务
            tx.commit();
            //5.释放资源
            em.close();
        }
    
        /** * 条件查询 * 案例：查询客户名称以‘霸王别姬’开头的客户 * sql：SELECT * FROM cst_customer WHERE cust_name LIKE ? * jpql : from Customer where custName like ? */
        @Test
        public void testCondition() { 
            //1.获取entityManager对象
            EntityManager em = JpaUtils.getEntityManager();
            //2.开启事务
            EntityTransaction tx = em.getTransaction();
            tx.begin();
            //3.查询全部
            //i.根据jpql语句创建Query查询对象
            String jpql = "from Customer where custName like ? ";
            Query query = em.createQuery(jpql);
            //ii.对参数赋值 -- 占位符参数
            //第一个参数：占位符的索引位置（从1开始），第二个参数：取值
            query.setParameter(1, "g%");
    
            //iii.发送查询，并封装结果
    
            /** * getResultList ： 直接将查询结果封装为list集合 * getSingleResult : 得到唯一的结果集 */
            List list = query.getResultList();
    
            for(Object obj : list) { 
                System.out.println(obj);
            }
    
            //4.提交事务
            tx.commit();
            //5.释放资源
            em.close();
        }
    }

# 五、总结 #

跳转到目录

第一 orm思想
    	主要目的：操作实体类就相当于操作数据库表
    	建立两个映射关系：
    		实体类和表的映射关系
    		实体类中属性和表中字段的映射关系
    	不再重点关注：sql语句
    	
    	实现了ORM思想的框架：mybatis，hibernate
    
    第二 hibernate框架介绍
    	Hibernate是一个开放源代码的对象关系映射框架，
    		它对JDBC进行了非常轻量级的对象封装，
    		它将POJO与数据库表建立映射关系，是一个全自动的orm框架
    
    第三 JPA规范
    	jpa规范，实现jpa规范，内部是由接口和抽象类组成
    
    第四 jpa的基本操作
    	案例：是客户的相关操作（增删改查）
    		客户：就是一家公司
    	客户表：
    	
    	jpa操作的操作步骤
    		1.加载配置文件创建实体管理器工厂
    			Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）
    				createEntityMnagerFactory（持久化单元名称）
    			作用：创建实体管理器工厂
    			
    		2.根据实体管理器工厂，创建实体管理器
    			EntityManagerFactory ：获取EntityManager对象
    			方法：createEntityManager
    			* 内部维护的很多的内容
    				内部维护了数据库信息，
    				维护了缓存信息
    				维护了所有的实体管理器对象
    				再创建EntityManagerFactory的过程中会根据配置创建数据库表
    			* EntityManagerFactory的创建过程比较浪费资源
    			特点：线程安全的对象
    				多个线程访问同一个EntityManagerFactory不会有线程安全问题
    			* 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
    			思路：创建一个公共的EntityManagerFactory的对象
    			* 静态代码块的形式创建EntityManagerFactory
    			
    		3.创建事务对象，开启事务
    			EntityManager对象：实体类管理器
    				beginTransaction : 创建事务对象
    				presist ： 保存
    				merge  ： 更新
    				remove ： 删除
    				find/getRefrence ： 根据id查询
    				
    			Transaction 对象 ： 事务
    				begin：开启事务
    				commit：提交事务
    				rollback：回滚
    		4.增删改查操作
    		5.提交事务
    		6.释放资源
    	
    	i.搭建环境的过程
    		1.创建maven工程导入坐标
    		2.需要配置jpa的核心配置文件
    			*位置：配置到类路径下的一个叫做 META-INF 的文件夹下
    			*命名：persistence.xml
    		3.编写客户的实体类
    		4.配置实体类和表，类中属性和表中字段的映射关系
    		5.保存客户到数据库中
    	ii.完成基本CRUD案例
    		persist ： 保存
    		merge ： 更新
    		remove ： 删除
    		find/getRefrence ： 根据id查询
    		
    	iii.jpql查询
    		sql：查询的是表和表中的字段
    		jpql：查询的是实体类和类中的属性
    		* jpql和sql语句的语法相似
    		
    		1.查询全部
    		2.分页查询
    		3.统计查询
    		4.条件查询
    		5.排序