71、Spring Data JPA 的 样本查询--参数作为样本去查询数据库的数据，也可以定义查询的匹配规则

Spring Data JPA 的 样本查询–参数作为样本去查询数据库的数据，也可以定义查询的匹配规则

样本查询

给Spring Data传入一个样本数据，Spring Data就能从数据库中查询出和样本相同的数据。

被查询的数据并不需要和样本是完全相同的，可能只需要和样本有几个属性是相同的。

总结：
样本查询–就是把参数作为样本去查询数据库的数据，根据自定义的匹配规则，如果对应上就能把数据查出来

样本查询也可以定义其中查询的一些匹配规则

样本查询的API（QueryByExampleExecutor）：

JpaRepository继承了QueryByExampleExecutor接口，该接口提供了如下“样本查询”方法：

<S extends T> Optional<S> findOne(Example<S> example);
<S extends T> Iterable<S> findAll(Example<S> example);
<S extends T> Iterable<S> findAll(Example<S> example, Sort sort);
<S extends T>   Page<S>   findAll(Example<S> example, Pageable pageable);
<S extends T>   long      count(Example<S> example);
<S extends T>   boolean   exists(Example<S> example);

只要让DAO接口继承该QueryByExampleExecutor接口，DAO组件就可调用上面的样本查询方法。
——方法实现不要你操心，Spring Data会负责搞定它们。

创建Example

Example查询的关键在于Example参数，它提供了如下两个of()类方法来创建Example对象：

of(T probe)：以probe对象创建最简单的Example对象，使用默认的匹配规则。
要求被查询对象与样本对象所有属性都严格相等。

of(T probe, ExampleMatcher matcher)：以probe创建Example对象，并使用matcher指定匹配规则。

ExampleMatcher提供了如下静态方法来创建实例：

static ExampleMatcher matching()：创建一个需要所有属性都匹配的匹配器。 (and运算符）

static ExampleMatcher matchingAll()：完全等同于matching()方法

static ExampleMatcher matchingAny()：创建一个只要任意一个属性匹配的匹配器。(or运算符）

ExampleMatcher 还可通过如下方法来指定对特定属性的匹配规则：

 withIgnoreCase()：指定属性匹配时默认不区分大小写。

 withIgnoreCase(String... propertyPaths)：指定propertyPaths参数列出的属性在匹配时不区分大小写。

 withIgnoreNullValues()：指定不比较Example对象中属性值为null的属性。

 withIgnorePaths(String... ignoredPaths)：指定忽略ignoredPaths参数列出的属性，也就是这些属性不参与匹配。

 withIncludeNullValues()：强行指定要比较Example对象中属性值为null的属性。

 withMatcher(String propertyPath, 比较器)：对propertyPath参数指定的属性使用专门的匹配规则。

样本查询的步骤：

1、让DAO接口要么继承JpaRepository（是QueryByExampleExecutor的子接口），或者增加继承QueryByExampleExecutor

2、DAO组件可调用QueryByExampleExecutor的样本查询方法

代码演示：

需求：根据一个对象中的某些属性作为样本，去数据库查询数据

要实现样本查询，Dao接口需要继承 JpaRepository 接口，或者增加继承 QueryByExampleExecutor 接口

接口可以继承接口,并且可以继承不只一个接口,但是不能实现接口。

因为接口的成员方法都具有抽象属性,不具有方法体,无法实现继承的接口

1、这样实现样本查询的接口继承

2、不需要在StudentDao组件写方法，或者写sql语句，直接在测试类进行查询方法的调用，因为DAO组件会调用QueryByExampleExecutor的样本查询方法，不用我们写。

DAO组件调用QueryByExampleExecutor的样本查询方法时，查询的默认的匹配规则，要求被查询对象与样本对象所有属性都严格相等。

如图：
样本查询的条件都符合，但是没查出数据，是因为没有添加匹配规则，
而默认的匹配规则，要求被查询对象与样本对象所有属性都严格相等。
而上面只有student的两个属性，其他没写上去就会为null，
所以就查询对象与样本对象的所有属性没有全部相等。
所以查不出数据
没有指定匹配规则，所以要求样本对象（s） 和 查询对象（Student） 的所有属性都相等才行

测试1：没有添加匹配规则的测试

默认匹配规则：要求被查询对象与样本对象所有属性都严格相等

测试2：添加匹配规则的测试

添加匹配规则：不比较 Null 值

解释：.withIgnorePaths (“id”, “gender”)
id 是 Integer 类型，默认值是null ， 所以也可以不排除
基本类型的属性，如果不作为参数去查询，就需要排除出去

测试3：添加匹配规则的测试

添加匹配规则：调用 matchingAny() ，

添加匹配规则：调用 matchingAny() ，相当于 OR 运算符，只要有一个参数和查询的student对象对应得上，就能将该对象查出来

测试4：添加匹配规则的测试

添加的匹配规则：.withMatcher()

添加的匹配规则：.withMatcher() 的 作用：

指定自己的匹配规则，指定要求以样本属性值作为结尾即可。
相当于查询 address like "%洞"就可以了，而不是 address = “洞”

需求：查询地址匹配指定后缀的student

匹配规则方法： .withMatcher() ，还能这样写，更灵活
.withMatcher(“address”,matcher -> matcher.endsWith())
也是以该样本属性作为后缀进行查询

完整代码

StudentDao

这个接口只需要再继承 QueryByExampleExecutor 这个接口就可以了，
或者直接继承 JpaRepository 接口也可以

不需要在StudentDao组件写方法，或者写sql语句，直接在测试类进行查询方法的调用，因为DAO组件会调用QueryByExampleExecutor的样本查询方法，不用我们写。

package cn.ljh.app.dao;

import cn.ljh.app.domain.Student;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;

import java.util.List;

//CrudRepository 的第一个泛型参数是被操作的实体类型，第二个参数是实体的主键类型
//public interface StudentDao extends CrudRepository<Student,Integer>

//如果要做样本查询，Dao接口需要继承 JpaRepository 接口,
//public interface StudentDao extends JpaRepository<Student,Integer>

//或者增加继承 QueryByExampleExecutor 接口
public interface StudentDao extends CrudRepository<Student,Integer> , QueryByExampleExecutor<Student>
{
    //查询年龄大于指定参数的学生
    List<Student> findByAgeGreaterThan(int startAge);

    //根据年龄和班级名称查询学生
    //Age 和 ClazzName 用 And 连接起来，表示两个查询条件，
    //ClazzName这两个单词中间没有And连接起来，表示是一个路径写法，表示是Clazz类的name属性
    List<Student> findByAgeAndClazzName(int age , String clazzName);

    //根据地址后缀进行分页查询，查询 address 带有 "洞" 的学生并进行分页
    Page<Student> findByAddressEndingWith(String addrSuffix, Pageable pageable);
}

StudentDaoTest

package cn.ljh.app.dao;


import cn.ljh.app.domain.Student;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.*;

import java.util.List;

//SpringBootTest.WebEnvironment.NONE : 表示不需要web环境
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE)
public class StudentDaoTest
{
    @Autowired
    private StudentDao studentDao;

    /**
     * @ValueSource: 每次只能传一个参数
     * @CsvSource：每次可以传多个参数
     */

    //需求：查询年龄大于指定参数的记录
    //参数化测试
    @ParameterizedTest
    @ValueSource(ints = {20, 200})
    public void testFindByAgeGreaterThan(int startAge)
    {
        List<Student> students = studentDao.findByAgeGreaterThan(startAge);
        students.forEach(System.err::println);
    }

    //根据年龄和班级名称查询学生
    //Age 和 ClazzName 用 And 连接起来，表示两个查询条件，
    //ClazzName这两个单词中间没有And连接起来，表示是一个路径写法，表示是Clazz类的name属性
    @ParameterizedTest
    //参数一个是int，一个是String，这个注解在传参的时候会自动进行类型转换
    @CsvSource(value = {"20,超级A营", "18,超级D班"})
    public void testFindByAgeAndClazzName(int age, String clazzName)
    {
        List<Student> students = studentDao.findByAgeAndClazzName(age, clazzName);
        students.forEach(System.err::println);
    }


    //pageNo: 要查询哪一页的页数 , pageSize: 每页显示的条数
    @ParameterizedTest
    @CsvSource({"洞,2,3", "洞,1,4", "洞,3,2"})
    public void testFindByAddressEndingWith(String addrSuffix, int pageNo, int pageSize)
    {
        //分页对象，此处的pageNo是从0开始的，0代表第一页，所以这里的 pageNo 要 -1
        Pageable pageable1 = PageRequest.of(pageNo - 1, pageSize);
        Page<Student> students = studentDao.findByAddressEndingWith(addrSuffix, pageable1);

        int number = students.getNumber() + 1;
        System.err.println("总页数：" + students.getTotalPages());
        System.err.println("总条数：" + students.getTotalElements());
        System.err.println("当前第：" + number + " 页");
        System.err.println("当前页有：" + students.getNumberOfElements() + " 条数据");
        students.forEach(System.err::println);
    }

    //==============测试样本查询从这里开始=====================================================
    
    //根据一个对象中的某些属性作为样本，去数据库查询数据
    @ParameterizedTest
    @CsvSource({"孙悟空,500", "猪八戒,200"})
    public void exampleTest1(String name, int age)
    {
        Student s = new Student();
        s.setName(name);
        s.setAge(age);
        //没有指定匹配规则，所以要求样本对象（s） 和 查询对象（Student） 的所有属性都相等才行
        Iterable<Student> students = studentDao.findAll(Example.of(s));
        students.forEach(System.err::println);
    }

    //根据一个对象中的某些属性作为样本，去数据库查询数据
    @ParameterizedTest
    @CsvSource({"孙悟空,500", "猪八戒,200"})
    public void exampleTest2(String name, int age)
    {
        Student s = new Student();
        s.setName(name);
        s.setAge(age);
        Iterable<Student> students = studentDao.findAll(Example.of(s,
                //添加匹配规则
                ExampleMatcher.matching()
                        //不比较Null值
                        .withIgnoreNullValues()
                        //不比较id、gender，因为gender是基本类型，有默认值，所以需要排除在外
                        .withIgnorePaths("gender")
        ));
        students.forEach(System.err::println);
    }


    //根据一个对象中的某些属性作为样本，去数据库查询数据
    @ParameterizedTest
    @CsvSource({"孙悟空,99999", "猪八戒,200"})
    public void exampleTest3(String name, int age)
    {
        Student s = new Student();
        s.setName(name);
        s.setAge(age);
        Iterable<Student> students = studentDao.findAll(Example.of(s,
                //添加匹配规则：Or 运算符，只要有一个属性对得上就查出来
                ExampleMatcher.matchingAny()
                        //不比较Null值
                        .withIgnoreNullValues()
                        //不比较id、gender
                        .withIgnorePaths("id", "gender")
        ));
        students.forEach(System.err::println);
    }

    //查询地址匹配指定后缀的student
    @ParameterizedTest
    @ValueSource(strings = {"洞", "河"})
    public void exampleTest4(String addressSuffix)
    {
        Student s = new Student();
        s.setAddress(addressSuffix);
        Iterable<Student> students = studentDao.findAll(Example.of(s,
                //添加匹配规则：Or 运算符，只要有一个属性对得上就查出来
                ExampleMatcher.matchingAny()
                        //不比较Null值
                        .withIgnoreNullValues()
                        //如果参数查询没用到 gender , age 这些基本类型，则排除在外不进行比较，因为有默认值
                        .withIgnorePaths("gender", "age")
                        //指定自己的匹配规则，指定要求以样本属性值作为结尾即可。
                        //相当于查询 address like "%洞"就可以了，而不是 address = "洞"
                        .withMatcher("address",
                                ExampleMatcher.GenericPropertyMatcher.of(ExampleMatcher.StringMatcher.ENDING))
        ));
        students.forEach(System.err::println);
    }

    //查询地址匹配指定后缀的student
    @ParameterizedTest
    @ValueSource(strings = {"洞", "河"})
    public void exampleTest5(String addressSuffix)
    {
        Student s = new Student();
        s.setAddress(addressSuffix);
        Iterable<Student> students = studentDao.findAll(Example.of(s,
                //添加匹配规则：Or 运算符，只要有一个属性对得上就查出来
                ExampleMatcher.matchingAny()
                        //不比较Null值
                        .withIgnoreNullValues()
                        //如果参数查询没用到 gender , age 这些基本类型，则排除在外不进行比较，因为有默认值
                        .withIgnorePaths("gender", "age")
                        //指定自己的匹配规则，指定要求以样本属性值作为结尾即可。
                        //相当于查询 address like "%洞"就可以了，而不是 address = "洞"
                        //更灵活的写法matcher -> matcher.endsWith()
                        .withMatcher("address",matcher -> matcher.endsWith())
        ));
        students.forEach(System.err::println);
    }

}