方法演示：

    @Autowired
    CustomerQBERepository repository;  //把刚刚自己定义的接口注入到容器
 
 
   //根据客户名称  客户地址动态查询
 
    @Test
    public  void test01(){
 
        //构建实体类需要动态查询的条件  比如需要通过名字和地址进行动态查询
        Customer customer=new Customer();
        customer.setCustName("徐庶");  //在实际开发中这个查询的条件都是从前端传过来的，比如传了name和address过来，你需要使用对应的数据类型进行接收就行，这里是演示所以直接写死了查询条件
        customer.setCustAddress("BEIJING");
 
        // 通过Example构建查询条件  特别注意这个Example对象是spring data中的依赖，别引成了hibernate的
        Example example = Example.of(customer);  
 
        List list = (List) repository.findAll(example);
        System.out.println(list);
    }
 
 
 
    /**
     * 通过匹配器进行条件的限制    客户名称  客户地址动态查询
     */
    @Test
    public  void test02(){
 
        // 查询条件
        Customer customer=new Customer();
        customer.setCustName("庶");
        customer.setCustAddress("JING");
 
        // 通过匹配器 对条件行为进行设置
        ExampleMatcher matcher = ExampleMatcher.matching()
                //.withIgnorePaths("custName")       // 设置忽略的属性
                //.withIgnoreCase("custAddress")      // 设置忽略大小写
                //.withStringMatcher(ExampleMatcher.StringMatcher.ENDING);    // 对所有条件字符串进行了结尾匹配
                .withMatcher("custAddress",m -> m.endsWith().ignoreCase());      // 针对单个条件进行限制, 会使withIgnoreCase失效，需要单独设置，第一个参数是需要对那个属性进行匹配，第二个参数表示的是需要对属性使用什么样的匹配规则
                //.withMatcher("custAddress",ExampleMatcher.GenericPropertyMatchers.endsWith().ignoreCase());
 
        // 通过Example构建查询条件  加了匹配器的查询条件
        Example example = Example.of(customer,matcher);
 
        List list = (List) repository.findAll(example);
        System.out.println(list);
    }

匹配器提供的一些方法：

注意演示案例使用的持久层框架是spring data jpa中的hibernate。

pom文件依赖：我的演示环境的spring boot是 2.6.10

<dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-jpaartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
 
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <scope>runtimescope>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
dependencies>

1、创建实体类

package com.ljm.entity;
import javax.persistence.*;
import java.util.Objects;
 
/**
 * @author LJM
 * @create 2022/8/1
 */
@Entity
@Table(name = "student")
public class Student {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
 
 
    @Column(name = "name")
    private String name;
 
 
    @Column(name = "age")
    private Long age;
 
    @Column(name = "loves")
    private String loves;
 
 
    @Column(name = "card_num")
    private String cardNum;
 
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public Long getId() {
        return this.id;
    }
 
 
    public void setName(String name) {
        this.name = name;
    }
 
 
    public String getName() {
        return this.name;
    }
 
    public void setAge(Long age) {
        this.age = age;
    }
 
    public Long getAge() {
        return this.age;
    }
 
    public void setLoves(String loves) {
        this.loves = loves;
    }
 
 
    public String getLoves() {
        return this.loves;
    }
 
    public String getCardNum() {
        return cardNum;
    }
 
    public void setCardNum(String cardNum) {
        this.cardNum = cardNum;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id) && Objects.equals(name, student.name) && Objects.equals(age, student.age) && Objects.equals(loves, student.loves) && Objects.equals(cardNum, student.cardNum);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(id, name, age, loves, cardNum);
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", loves='" + loves + '\'' +
                ", cardNum='" + cardNum + '\'' +
                '}';
    }
}
 

2、数据库创建表（实际上hibernate会帮我们自动创建，只要我们在配置文件中提供库名就行），

或者是使用sql：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
 
-- ----------------------------
-- Table structure for student
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student`  (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `age` bigint NULL DEFAULT NULL,
  `card_num` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
  `loves` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
 
-- ----------------------------
-- Records of student
-- ----------------------------
INSERT INTO `student` VALUES (1, 16, '12345', '打篮球', '小李');
INSERT INTO `student` VALUES (2, 16, '123456', '测试', '小王');
INSERT INTO `student` VALUES (3, 17, '123456', '测试', '小王');
 
SET FOREIGN_KEY_CHECKS = 1;

3、创建dao层

package com.ljm.dao;
 
import com.ljm.entity.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 
public interface StudentRepository extends JpaRepository, JpaSpecificationExecutor {
 
}

使用example进行的动态条件分页查询案例演示

创建实体类和数据库表相关步骤在上面；

4、直接编写service层具体的实现，这里就不编写service接口了。

@Service
public class StudentService {
 
    @Autowired
    private StudentRepository studentRepository;
 
    public Page queryStudent(Student queryStudent, Pageable pageable) {
 
        //创建匹配条件
        ExampleMatcher matcher = ExampleMatcher.matching().withIgnoreNullValues();
 
        Example example = Example.of(queryStudent, matcher);
        Page pageStudent = studentRepository.findAll(example, pageable);
        return pageStudent ;
    }
}

5、编写controller

@RestController
@RequestMapping("/student")
public class StudentController {
 
    @Autowired
    StudentService studentService;
 
    @GetMapping("/list")
    public Page list(int page, int size, @RequestBody Student student) {
 
        PageRequest pageRequest = PageRequest.of(page, size);
        Page pageStudent =
                studentService.queryStudent(student, pageRequest);
        return pageStudent;
 
    }
}

Specification分页查询

Specifications分页查询基础知识

之前使用Query by Example只能针对字符串进行条件设置，那如果希望对所有类型支持，可以使用Specifications。

1、继承接口JpaSpecificationExecutor。

public interface CustomerSpecificationsRepository
        extends PagingAndSortingRepository,
        JpaSpecificationExecutor {  //这个泛型表示的是你要操作的Java实体类
 
}

2、传入Specification的实现： 结合lambda表达式

• Root：查询哪个表（关联查询） = from

• CriteriaQuery：查询哪些字段，排序是什么 =组合(order by . where )

• CriteriaBuilder：条件之间是什么关系，如何生成一个查询条件，每一个查询条件都是什么类型（> between in...) = where

• Predicate（Expression）： 每一条查询条件的详细描述

            root对象可以让我们从表中获取我们想要的列
            CriteriaBuilder where 设置各种条件  (> < in between......)
            query  组合（order by , where)

    @Autowired
    CustomerSpecificationsRepository repository; //把刚刚自定义的接口注入到容器中
 
 
	//进行精确匹配，单一条件查询
    @Test
    public  void testR2(){
 
        List customer = repository.findAll(new Specification() {
            @Override
            public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
 
                // root对象可以让我们从表中获取我们想要的列
                // CriteriaBuilder where 设置各种条件  (> < in ..)
                // query  组合（order by , where)
                Path