Spring Data JPA——原理剖析、Spring Data JPA的四种查询方式

分手后的思念是犯贱 2023-05-21 05:57 73阅读 0赞

## 目录 ##

*  一、Spring Data JPA的内部原理剖析
 *  二、Spring Data JPA的查询方式
    
     *  1、使用Spring Data JPA中接口定义的方法进行查询
     *  2、使用JPQL的方式查询
     *  3、使用SQL语句查询
     *  4、使用方法命名规则查询
 *  三、总结

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

# 一、Spring Data JPA的内部原理剖析 #

跳转到目录

### 1、Spring Data JPA的常用接口分析 ###

*  在客户的案例中，我们发现在自定义的`CustomerDao`中，**并没有提供任何方法就可以使用其中的很多方法，那么这些方法究竟是怎么来的呢？答案很简单，对于我们自定义的Dao接口，由于继承了`JpaRepository`和`JpaSpecificationExecutor`，所以我们可以使用这两个接口的所有方法。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]
 *  在使用`Spring Data JPA`时，一般实现`JpaRepository`和`JpaSpecificationExecutor`接口，这样就可以使用这些接口中定义的方法，但是这些方法都只是一些声明，没有具体的实现方式，那么在 Spring Data JPA中它又是怎么实现的呢？

### 2、Spring Data JPA的实现过程 ###

*  通过对上篇博客的客户案例，以debug断点调试的方式，通过分析Spring Data JPA的执行过程  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 1]
 *  断点执行到方法上时，我们可以发现注入的customerDao对象，本质上是通过`JdkDynamicAopProxy`生成的一个`代理对象`
 *  代理对象中方法调用的分析
 *  当程序执行的时候，会通过JdkDynamicAopProxy的`invoke`方法，对customerDao对象生成动态代理对象。根据对Spring Data JPA介绍而知，要想进行`findOne查询方法`，最终还是会出现JPA规范的API完成操作，那么这些底层代码存在于何处呢？答案很简单，都隐藏在通过**JdkDynamicAopProxy**生成的动态代理对象当中，而这个动态代理对象就是`SimpleJpaRepository`  
    ![在这里插入图片描述][20200505210254948.png]
 *  通过`SimpleJpaRepository`的源码分析，定位到了`findOne方法`，在此方法中，返回 **em.find()** 的返回结果，那么em又是什么呢？  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]
 *  **带着问题继续查找`em对象`，我们发现em就是`EntityManager对象`，而它是JPA原生的实现方式，所以我们得到结论Spring Data JPA只是对标准JPA操作进行了进一步封装，简化了Dao层代码的开发;** (在本系列的第一篇, 介绍了JPA的原生API)

### 3、Spring Data JPA完整的调用过程分析 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 3]

# 二、Spring Data JPA的查询方式 #

### 1、使用Spring Data JPA中接口定义的方法进行查询 ###

跳转到目录  
在继承`JpaRepository`，和J`paRepository接口`后,我们就可以使用接口中定义的方法进行查询  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 4]

### 2、使用JPQL的方式查询 ###

跳转到目录

*  使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景，但是对于某些业务来说，我们还需要灵活的构造查询条件，这时就可以使用`@Query`注解，结合`JPQL`的语句方式完成查询; **`(和原生JPA操作JPQL类似, 如下图)`**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 5]
 *  `@Query 注解的使用非常简单，只需在方法上面标注该注解，同时提供一个JPQL查询语句即可`

public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> { 
    
        /** * 案例: 根据客户名称查询客户 * 使用jpql的形式查询 * jpql: from Customer where custName = ? * * 配置jpql语句, 使用@Query注解 */
        @Query("from Customer where custName = ?")
        public Customer findJpql(String custName);
    
        /** * 案例：根据客户名称和客户id查询客户 * jpql： from Customer where custName = ? and custId = ? * * 对于多个占位符参数 * 赋值的时候，默认的情况下，占位符的位置需要和方法参数中的位置保持一致 * * 可以指定占位符参数的位置 * ? 索引的方式，指定此占位的取值来源 */
        // @Query("from Customer where custName = ? and custId = ?")
        // public Customer findCustNameAndId(String name, Long id);
        @Query("from Customer where custName = ?2 and custId = ?1")
        public Customer findCustNameAndId(Long id, String name);
    
        /** * 使用jpql完成更新操作 * 案例 ： 根据id更新，客户的名称 * 更新4号客户的名称，将名称改为“黑马程序员” * * sql ：update cst_customer set cust_name = ? where cust_id = ? * jpql : update Customer set custName = ? where custId = ? * * @Query : 代表的是进行查询 * * 声明此方法是用来进行更新操作 * @Modifying * * 当前执行的是一个更新操作 * */
        @Query("update Customer set custName = ?2 where custId = ?1")
        @Modifying
        public void updateCustomer(long custId, String custName);
    }

测试

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = "classpath:applicationContext.xml")
    public class JpqlTest { 
    
        @Autowired
        private CustomerDao customerDao;
    
        @Test
        public void testFindJPQL() { 
            Customer customer = customerDao.findJpql("bb");
            System.out.println("customer = " + customer);
        }
    
        @Test
        public void testFindNameAndId() { 
            // Customer customer = customerDao.findCustNameAndId("gzy1", 2L);
            Customer customer = customerDao.findCustNameAndId(2L, "gzy1");
            System.out.println("customer = " + customer);
        }
    
        /** * 测试jpql的更新操作 * * springDataJpa中使用jpql完成 更新/删除操作 * * 需要手动添加事务的支持 * * 默认会执行结束之后，回滚事务 * @Rollback : 设置是否自动回滚 * false | true */
        @Test
        @Transactional //添加事务的支持
        @Rollback(value = false)
        public void testUpdateCustomer() { 
            customerDao.updateCustomer(4L,"桂朝阳");
        }
    }

*  此外，也可以通过使用 `@Query` 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，用 `@Modifying` 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询

### 3、使用SQL语句查询 ###

跳转到目录

*  Spring Data JPA同样也`支持sql语句`的查询，如下：

public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> { 
    	/** * 使用sql的形式查询： * 查询全部的客户 * sql ： select * from cst_customer; * Query : 配置sql查询 * value ： sql语句 * nativeQuery ： 查询方式 * true ： sql查询 * false：jpql查询 * */
        @Query(value = "select * from cst_customer", nativeQuery = true)
        public List<Object[]> findSql();
    
        /** * 根据条件来查询 */
        @Query(value = "select * from cst_customer where cust_name like ?1", nativeQuery = true)
        public List<Object[]> findSqlCondition(String likeName);
    }

测试

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = "classpath:applicationContext.xml")
    public class JpqlTest { 
    
    	@Autowired
        private CustomerDao customerDao;
    
    	//测试sql查询
        @Test
        public void testFindSql() { 
            List<Object[]> list = customerDao.findSql();
            for (Object[] objects : list) { 
                System.out.println(Arrays.toString(objects));
            }
        }
    
        // 根据条件来查询
        @Test
        public void testFindSqlCondition() { 
            List<Object[]> objs = customerDao.findSqlCondition("g%");
            for (Object[] obj : objs) { 
                System.out.println(Arrays.toString(obj));
            }
        }
    }

### 4、使用方法命名规则查询 ###

跳转到目录  
顾名思义，`方法命名规则查询`就是根据`方法的名字`，就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询

按照Spring Data JPA 定义的规则，**`查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接`**，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。

*  `findBy + 属性名称 （根据属性名称进行完成匹配的查询）`
 *  `findBy + 属性名称 + “ 查询方式（Like | isnull）”`
 *  多条件查询  
    `findBy + 属性名 + “查询方式” + “多条件的连接符（and|or）” + 属性名 + “查询方式”`

public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> { 
        /** * 方法名的约定： * findBy : 查询 * 对象中的属性名（首字母大写） ： 查询的条件 * CustName * * 默认情况 ： 使用 等于的方式查询 * 特殊的查询方式 * * findByCustName -- 根据客户名称查询 * * 再springdataJpa的运行阶段 * 会根据方法名称进行解析 findBy from xxx(实体类) * 属性名称 where custName = * * * 1.findBy + 属性名称 （根据属性名称进行完成匹配的查询=） * * 2.findBy + 属性名称 + “查询方式（Like | isnull）” * findByCustNameLike * * 3.多条件查询 * findBy + 属性名 + “查询方式” + “多条件的连接符（and|or）” + 属性名 + “查询方式” */
    
        // 根据名称查询
        public Customer findByCustName(String custName);
    
        //使用客户名称模糊匹配查询
        public List<Customer> findByCustNameLike(String custName);
    
        //使用客户名称模糊匹配和客户所属行业精准匹配的查询
        public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);
    }

测试

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = "classpath:applicationContext.xml")
    public class JpqlTest { 
    
        // 测试方法命名规则的查询
        @Test
        public void testNaming() { 
            Customer custName = customerDao.findByCustName("gzy1");
            System.out.println("custName = " + custName);
        }
    
        @Test
        public void testFindByCustNameLike() { 
            List<Customer> list = customerDao.findByCustNameLike("g%");
            for (Customer customer : list) { 
                System.out.println("customer = " + customer);
            }
        }
    
        @Test
        public void testFindByCustNameLikeAndCustIndustry() { 
            Customer customer = customerDao.findByCustNameLikeAndCustIndustry("g%", "leaf");
            System.out.println("customer = " + customer);
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 8]

# 三、总结 #

跳转到目录

* SpringDataJpa
    
    第一 springDataJpa的概述
    
    第二 springDataJpa的入门操作
    	案例：客户的基本CRUD
    	i.搭建环境
    		创建工程导入坐标
    		配置spring的配置文件（配置spring Data jpa的整合）
    		编写实体类（Customer），使用jpa注解配置映射关系
    	ii.编写一个符合springDataJpa的dao层接口
    		* 只需要编写dao层接口，不需要编写dao层接口的实现类
    		* dao层接口规范
    			1.需要继承两个接口（JpaRepository，JpaSpecificationExecutor）
    			2.需要提供响应的泛型
    	
    	*   findOne（id） ：根据id查询
    		save(customer):保存或者更新（依据：传递的实体类对象中，是否包含id属性）
    		delete（id） ：根据id删除
    		findAll() : 查询全部
    
    第三 springDataJpa的运行过程和原理剖析
    	1.通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象
    	2.SimpleJpaRepository当中封装了JPA的操作（借助JPA的api完成数据库的CRUD）
    	3.通过hibernate完成数据库操作（封装了jdbc）
    
    
    第四 复杂查询
    	i.借助接口中的定义好的方法完成查询
    		findOne(id):根据id查询
    	ii.jpql的查询方式
    		jpql ： jpa query language  （jpq查询语言）
    		特点：语法或关键字和sql语句类似
    			查询的是类和类中的属性
    			
    		* 需要将JPQL语句配置到接口方法上
    			1.特有的查询：需要在dao接口上配置方法
    			2.在新添加的方法上，使用注解的形式配置jpql查询语句
    			3.注解 ： @Query
    
    	iii.sql语句的查询
    			1.特有的查询：需要在dao接口上配置方法
    			2.在新添加的方法上，使用注解的形式配置sql查询语句
    			3.注解 ： @Query
    				value ：jpql语句 | sql语句
    				nativeQuery ：false（使用jpql查询） | true（使用本地查询：sql查询）
    					是否使用本地查询
    					
    	iiii.方法名称规则查询

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]: /images/20230521/b31be6dc02d84251b91acf013de96cc6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 1]: /images/20230521/308209718fa0479fbe96359817111adb.png
[20200505210254948.png]: /images/20230521/c282c82537a44660922510dd931d197a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]: /images/20230521/05947ce9b9a844bd9784089fac21e922.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 3]: /images/20230521/3e51e7ca5f7f4408882f671169be857f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 4]: /images/20230521/7838d42743fc4dedafd9f4a26d76dbe0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 5]: /images/20230521/28cf8b6aae0e486bbe40c54a4dfdb0d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 6]: /images/20230521/a87457ea17a5494a9a53bc037b50bce3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 7]: /images/20230521/01118a10344a4563aa92dde9841f441b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 8]: /images/20230521/75c34f727c694ee983ed4212a3170d20.png