Spring Data Jpa：分页、Specification、Criteria

分页的主要接口与类

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文档地址

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;

}

作者：林塬
链接：https://www.jianshu.com/p/e7882c4f29b6
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

巴特西

Spring Data Jpa：分页、Specification、Criteria

分页的主要接口与类

分页与排序的使用

分页

排序

分页与排序

JpaSpecificationExecutor

Criteria 查询

最新文章

热门文章