Spring Data Jpa：分页、Specification、Criteria

青旅半醒 2021-10-01 11:34 473阅读 0赞

## 分页的主要接口与类 ##

> **PagingAndSortingRepository**

*  继承自 CrudRepository 接口，提供了排序以及分页查询能力，提供了两个方法

Iterable<T> findAll(Sort var1);
    Page<T> findAll(Pageable var1);

*  虽然 PagingAndSortingRepository 接口中只有 findAll 方法，但是我们依然可以使用 Repository 中的衍生查询，我们只要把 Pageable 放到最后一个参数即可
 *  JpaRepository 接口继承了 PagingAndSortingRepository 接口，并封装了常用的 CRUD 方法，通常我们继承 JpaRepository 来进行操作

> **Sort**

*  Sort 主要为了实现排序功能，内有枚举类指示排序方式

public static enum Direction {
        ASC,
        DESC;
        //省略方法
      }

*  Sort 的构造函数如下

//可以输入多个Sort.Order对象，在进行多个值排序时有用
    public Sort(Sort.Order... orders)
    //和上面的方法一样，无非把多个参数换成了一个List
    public Sort(List<Sort.Order> orders)
    //当排序方向固定时，使用这个比较方便，第一个参数是排序方向，第二个开始就是排序的字段，还有一个方法第二个参数是list，原理相同
    public Sort(Sort.Direction direction, String... properties)

*  建立一个 Sort

Sort sort = new Sort(Direction.DESC, "id");

*  Sort 中有一个内部类 Order，它用来定义排序方向和排序的列

Sort sort = new Sort(
        new Sort.Order(Sort.Direction.ASC,"name"),
        new Sort.Order(Sort.Direction.DESC,"address"));

> **Pageable**

*  Pageable 是一个接口，提供了分页一组方法的声明，如第几页，每页多少条记录，排序信息等

int getPageNumber();
    
    int getPageSize();
    
    int getOffset();
    
    Sort getSort();
    
    Pageable next();
    
    Pageable previousOrFirst();
    
    Pageable first();
    
    boolean hasPrevious();

> **PageRequest**

*  它是 Pageable 的实现类，它提供三个构造方法

//这个构造出来的分页对象不具备排序功能
    public PageRequest(int page, int size) {
        this(page, size, (Sort)null);
    }
    //Direction和properties用来做排序操作
    public PageRequest(int page, int size, Direction direction, String... properties) {
        this(page, size, new Sort(direction, properties));
    }
    //自定义一个排序的操作
    public PageRequest(int page, int size, Sort sort) {
        super(page, size);
        this.sort = sort;
    }

*  第二个构造函数的 Direction 同样为 Sort 中的内部枚举，构建好 Sort、Pageable，就能实现 PagingAndSortingRepository 接口的排序和分页功能

## 分页与排序的使用 ##

### 分页 ###

> 声明一个 StudentPageRepository 接口继承自 PagingAndSortingRepository

public interface StudentPageRepository extends PagingAndSortingRepository<Student,Integer> {
    
        Page<Student> findByAge(int age, Pageable pageable);
    }

> 创建分页对象 PageRequest，进行分页查询

//显示第1页每页显示3条
    PageRequest pr = new PageRequest(1,3);
    //根据年龄进行查询
    Page<Student> stus = studentPageRepository.findByAge(22,pr);

*  虽然 PagingAndSortingRepository 接口中只有 findAll 方法，但是我们依然可以使用 Repository 中的衍生查询，我们只要把 Pageable 放到最后一个参数即可

### 排序 ###

> 声明一个 StudentPageRepository 接口继承自 PagingAndSortingRepository

public interface StudentPageRepository extends PagingAndSortingRepository<Student,Integer> {
        Page<Student> findByAge(int age, Pageable pageable);
        List<Student> findByAge(int age, Sort sort);
    }

> 创建排序对象 Sort，进行查询排序

//设置排序方式为name降序
    List<Student> stus = studentPageRepository.findByAge(22,new Sort(Sort.Direction.DESC,"name"));
    //设置排序以name和address进行升序
    stus = studentPageRepository.findByAge(22,new Sort(Sort.Direction.ASC,"name","address"));
    //设置排序方式以name升序，以address降序
    Sort sort = new Sort(new Sort.Order(Sort.Direction.ASC,"name"),new Sort.Order(Sort.Direction.DESC,"address"));
    stus = studentPageRepository.findByAge(22,sort);

### 分页与排序 ###

> PageRequest 还提供了分页时进行排序的构造函数

public PageRequest(int page, int size, Direction direction, String... properties) {
        this(page, size, new Sort(direction, properties));
    }
    
    public PageRequest(int page, int size, Sort sort) {
        super(page, size);
        this.sort = sort;
    }

## JpaSpecificationExecutor ##

*  Spring Data Jpa 支持 Criteria 查询方式，使用这种方式需要继承 **JpaSpecificationExecutor** 接口，该接口提供了如下一些方法

T findOne(Specification<T> var1);
    List<T> findAll(Specification<T> var1);
    Page<T> findAll(Specification<T> var1, Pageable var2);
    List<T> findAll(Specification<T> var1, Sort var2);
    long count(Specification<T> var1);

> 通过实现 **Specification** 中的 **toPredicate** 方法来定义动态查询，通过 CriteriaBuilder 来创建查询条件

List<Student> stus = studentSpecificationRepository.findAll(new Specification<Student>() {
        @Override
        public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
        //root.get("address")表示获取address这个字段名称,like表示执行like查询,%zt%表示值
        Predicate p1 = criteriaBuilder.like(root.get("address"), "%zt%");
        Predicate p2 = criteriaBuilder.greaterThan(root.get("id"),3);
        //将两个查询条件联合起来之后返回Predicate对象
        return criteriaBuilder.and(p1,p2);
        }
    });

> 可以定义多个 Specification，然后通过 Specifications 对象将其连接起来

//第一个Specification定义了两个or的组合
    Specification<Student> s1 = new Specification<Student>() {
        @Override
        public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
            Predicate p1 = criteriaBuilder.equal(root.get("id"),"2");
            Predicate p2 = criteriaBuilder.equal(root.get("id"),"3");
            return criteriaBuilder.or(p1,p2);
        }
    };
    //第二个Specification定义了两个or的组合
    Specification<Student> s2 = new Specification<Student>() {
        @Override
        public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
            Predicate p1 = criteriaBuilder.like(root.get("address"),"zt%");
            Predicate p2 = criteriaBuilder.like(root.get("name"),"foo%");
            return criteriaBuilder.or(p1,p2);
        }
    };
    //通过Specifications将两个Specification连接起来，第一个条件加where，第二个是and
    List<Student> stus = studentSpecificationRepository.findAll(Specifications.where(s1).and(s2));

> 这个代码生成的 SQL 是

select * from t_student where (id=2 or id=3) and (address like 'zt%' and name like 'foo%')

*  toPredicate 中还有 CriteriaQuery 参数，这个对象提供了更多有用的查询，如分组之类的查询

## Criteria 查询 ##

> [API文档地址][API]

*  **CriteriaQuery** 接口：该接口定义了顶级查询功能，它包含着查询到各个部分，如：select、from、where、group by、order by 等，CriteriaQuery 对象必须在实体类或嵌入式类型上才起作用
 *  **CriteriaBuilder**：它是 CriteriaQuery 的工厂类，用于构建 JPA 安全查询，可通过 EntityManager.getCriteriaBuilder 而得
 *  **Root** 接口：该接口继承了 From接口，From 接口继承了 Path 接口，该代表 Criteria 查询的根对象，定义了查询的实体类型，类似于 SQL 中的 FROM 子句，可有多个查询根
 *  **Predicate** 接口：代表了简单或复杂的查询断言（语句），一个 Predicate 可认为由多个连接词构成

> Criteria 查询 Demo

//创建CriteriaBuilder安全查询工厂
            //CriteriaBuilder是一个工厂对象,安全查询的开始.用于构建JPA安全查询.
            CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
            //创建CriteriaQuery安全查询主语句
            //CriteriaQuery对象必须在实体类型或嵌入式类型上的Criteria 查询上起作用。
            CriteriaQuery<Item> query = criteriaBuilder.createQuery(Item.class);
            //Root 定义查询的From子句中能出现的类型
            Root<Item> itemRoot = query.from(Item.class);
            //Predicate 过滤条件 构建where字句可能的各种条件
            //这里用List存放多种查询条件,实现动态查询
            List<Predicate> predicatesList = new ArrayList<>();
            //name模糊查询 ,like语句
            if (name != null) {
                predicatesList.add(
                        criteriaBuilder.and(
                                criteriaBuilder.like(
                                        itemRoot.get(Item_.itemName), "%" + name + "%")));
            }
            // itemPrice 小于等于 <= 语句
            if (price != null) {
                predicatesList.add(
                        criteriaBuilder.and(
                                criteriaBuilder.le(
                                        itemRoot.get(Item_.itemPrice), price)));
            }
            //itemStock 大于等于 >= 语句
            if (stock != null) {
                predicatesList.add(
                        criteriaBuilder.and(
                                criteriaBuilder.ge(
                                        itemRoot.get(Item_.itemStock), stock)));
            }
            //where()拼接查询条件
            query.where(predicatesList.toArray(new Predicate[predicatesList.size()]));
            TypedQuery<Item> typedQuery = entityManager.createQuery(query);
            List<Item> resultList = typedQuery.getResultList();
            return resultList;

> CriteriaBuilder 中各个方法的对应

equle : filed = value
    
    gt / greaterThan : filed > value
    
    lt / lessThan : filed < value
    
    ge / greaterThanOrEqualTo : filed >= value
    
    le / lessThanOrEqualTo: filed <= value
    
    notEqule : filed != value
    
    like : filed like value
    
    notLike : filed not like value

> 若使用 Spring Data Jpa 则 Specification 代码如下

public Page<Item> findByConditions(String name, Integer price, Integer stock, Pageable page) {
         Page<Item> page = itemRepository.findAll((root, criteriaQuery, criteriaBuilder) -> {
                List<Predicate> predicatesList = new ArrayList<>();
                //name模糊查询 ,like语句
                if (name != null) {
                    predicatesList.add(
                            criteriaBuilder.and(
                                    criteriaBuilder.like(
                                            root.get(Item_.itemName), "%" + name + "%")));
                }
                // itemPrice 小于等于 <= 语句
                if (price != null) {
                    predicatesList.add(
                            criteriaBuilder.and(
                                    criteriaBuilder.le(
                                            root.get(Item_.itemPrice), price)));
                }
                //itemStock 大于等于 >= 语句
                if (stock != null) {
                    predicatesList.add(
                            criteriaBuilder.and(
                                    criteriaBuilder.ge(
                                            root.get(Item_.itemStock), stock)));
                }
                return criteriaBuilder.and(
                        predicatesList.toArray(new Predicate[predicatesList.size()]));
            }, page);
        return page;
    }

[API]: https://link.jianshu.com?t=https%3A%2F%2Fdocs.oracle.com%2Fjavaee%2F6%2Fapi%2Fjavax%2Fpersistence%2Fcriteria%2FPath.html