之前我们学习了如何使用Jpa访问关系型数据库。比较完整Spring MVC和JPA教程请见Spring Data JPA实战入门Spring MVC实战入门

通过Jpa大大简化了我们对数据库的开发工作。但是,之前的例子中我们只提到了最简单的CRUD(增删改查)操作。实际上,Spring Data Jpa对于分页以及排序的查询也有着完美的支持,接下来,我们来学习如何通过Pageable来对数据库进行分页查询。

添加maven依赖

首先我们需要引入Jpa,数据库直接使用hsqldb内存数据库就可以了:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.2.5.RELEASE</version>
    </parent>
    <groupId>tmy</groupId>
    <artifactId>demo.jpa.page</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>tmy-spring-jpa-page-demo</name>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hsqldb</groupId>
            <artifactId>hsqldb</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
</project>

继承PagingAndSortingRepository

Jpa的基本使用方法在如何使用Jpa访问关系型数据库已经介绍过,我们暂且跳过,这里我们直接来看接口BlogRepository的定义:

public interface BlogRepository extends PagingAndSortingRepository<Blog, Integer> {

    Page<Blog> findByDeletedFalse(Pageable pageable);

}

我们可以看到,BlogRepository定义了这样一个方法:Page<Blog> findByDeletedFalse(Pageable pageable);,我们主要关注它的参数以及返回值。

  • Pageable 是Spring Data库中定义的一个接口,该接口是所有分页相关信息的一个抽象,通过该接口,我们可以得到和分页相关所有信息(例如pageNumberpageSize等),这样,Jpa就能够通过pageable参数来得到一个带分页信息的Sql语句。
  • Page类也是Spring Data提供的一个接口,该接口表示一部分数据的集合以及其相关的下一部分数据、数据总数等相关信息,通过该接口,我们可以得到数据的总体信息(数据总数、总页数...)以及当前数据的信息(当前数据的集合、当前页数等)

Spring Data Jpa除了会通过命名规范帮助我们扩展Sql语句外,还会帮助我们处理类型为Pageable的参数,将pageable参数转换成为sql'语句中的条件,同时,还会帮助我们处理类型为Page的返回值,当发现返回值类型为Page,Spring Data Jpa将会把数据的整体信息、当前数据的信息,分页的信息都放入到返回值中。这样,我们就能够方便的进行个性化的分页查询。

Pageable只是一个抽象的接口,那么,家下来我们学习如何获得pageable对象。

通过参数生成Pageable对象

Pageable定义了很多方法,但其核心的信息只有两个:一是分页的信息(page、size),二是排序的信息。Spring Data Jpa提供了PageRequest的具体实现,Spring MVC提供了对Spring Data JPA非常好的支持,我们只提供分页以及排序信息即可:

@RequestMapping(value = "/params", method=RequestMethod.GET)
public Page<Blog> getEntryByParams(@RequestParam(value = "page", defaultValue = "0") Integer page,
        @RequestParam(value = "size", defaultValue = "15") Integer size) {
    Sort sort = new Sort(Direction.DESC, "id");
    Pageable pageable = new PageRequest(page, size, sort);
    return blogRepository.findAll(pageable);
}

在这里,我们通过参数获得分页的信息,并通过Sort以及Direction告诉pageable需要通过id逆序排列。Spring MVC的介绍情移步这里:Spring MVC快速入门

这里可以看到,通过参数来得到一个pageable对象还是比较繁琐的,当查询的方法比较多的时候,会产生大量的重复代码。为了避免这种情况,Spring Data提供了直接生成pageable的方式。

直接获取Pageable对象

@RequestMapping(value = "", method=RequestMethod.GET)
public Page<Blog> getEntryByPageable(@PageableDefault(value = 15, sort = { "id" }, direction = Sort.Direction.DESC) 
    Pageable pageable) {
    return blogRepository.findAll(pageable);
}

我们可以看到,我们只需要在方法的参数中直接定义一个pageable类型的参数,当Spring发现这个参数时,Spring会自动的根据request的参数来组装该pageable对象,Spring支持的request参数如下:

  • page,第几页,从0开始,默认为第0页
  • size,每一页的大小,默认为20
  • sort,排序相关的信息,以property,property(,ASC|DESC)的方式组织,例如sort=firstname&sort=lastname,desc表示在按firstname正序排列基础上按lastname倒序排列

这样,我们就可以通过url的参数来进行多样化、个性化的查询,而不需要为每一种情况来写不同的方法了。

通过url来定制pageable很方便,但唯一的缺点是不太美观,因此我们需要为pageable设置一个默认配置,这样很多情况下我们都能够通过一个简洁的url来获取信息了。

Spring提供了@PageableDefault帮助我们个性化的设置pageable的默认配置。例如@PageableDefault(value = 15, sort = { "id" }, direction = Sort.Direction.DESC)表示默认情况下我们按照id倒序排列,每一页的大小为15。

返回结果

最后,让我们进入程序的根目录,运行命令mvn spring-boot:run将web应用启动起来,启动完成后,访问http://localhost:8080/页面,我们将看到如下结果:

{
  "content":[
    {"id":123,"title":"blog122","content":"this is blog content"},
    {"id":122,"title":"blog121","content":"this is blog content"},
    {"id":121,"title":"blog120","content":"this is blog content"},
    {"id":120,"title":"blog119","content":"this is blog content"},
    {"id":119,"title":"blog118","content":"this is blog content"},
    {"id":118,"title":"blog117","content":"this is blog content"},
    {"id":117,"title":"blog116","content":"this is blog content"},
    {"id":116,"title":"blog115","content":"this is blog content"},
    {"id":115,"title":"blog114","content":"this is blog content"},
    {"id":114,"title":"blog113","content":"this is blog content"},
    {"id":113,"title":"blog112","content":"this is blog content"},
    {"id":112,"title":"blog111","content":"this is blog content"},
    {"id":111,"title":"blog110","content":"this is blog content"},
    {"id":110,"title":"blog109","content":"this is blog content"},
    {"id":109,"title":"blog108","content":"this is blog content"}],
  "last":false,
  "totalPages":9,
  "totalElements":123,
  "size":15,
  "number":0,
  "first":true,
  "sort":[{
    "direction":"DESC",
    "property":"id",
    "ignoreCase":false,
    "nullHandling":"NATIVE",
    "ascending":false
  }],
  "numberOfElements":15
}

通过查询结果,我们可以知道:

  • 以id倒序排列的10条数据
  • 当前页不是最后一页,后面还有数据
  • 总共有9页
  • 每页大小为15
  • 当前页为第0页
  • 当前页是第一页
  • 当前页是以id倒序排列的
  • 当前页一共有15条数据

怎么样,信息是不是很丰富,代码是不是很简单,快点来尝试一下Jpa的分页查询吧。


进一步阅读

登录发表评论 注册

cdwenhao

spring data JPA 在动态查询方面还是没有Hibernate 原来的Legacy Hibernate Criteria Queries方便,但是为了遵从JAP2.0标准,Hibernate Criteria Queries建议废弃了。

可以看看https://github.com/wenhao/jpa-spec这个动态查询库。简化了动态查询过程。举个例子:

public Page<Person> findAll(SearchRequest request) {
    Specification<Person> specification = new Specifications<Person>()
            .eq(StringUtils.isNotBlank(request.getName()), "name", request.getName())
            .gt(Objects.nonNull(request.getAge()), "age", 18)
            .between("birthday", new Range<>(new Date(), new Date()))
            .like("nickName", "%og%", "%me")
            .build();
    return personRepository.findAll(specification, new PageRequest(0, 15)); 
}
Cliff

@gaoyadong

我们目前也遇到条件查询条件比较多的情况,这个需要根据业务逻辑来定,我们遇到的情况基本都是通过传回来的数据将所有条件通过and连接起来就可以,所以我们在Repository中添加了这么一个方法:

class XXXRepositoryImpl implements XXXRepositoryCustom {

    @PersistenceContext
    private EntityManager em;

    private boolean isBoolean(Object obj) {
        if (obj instanceof String) {
            String str = (String) obj;
            return "true".equals(str) || "false".equals(str);
        }

        return false;
    }

    private Boolean booleanValue(Object obj) {
        return (obj instanceof String) ? Boolean.valueOf((String) obj) : null;
    }

    @Override
    public List<Course> findByField(Map<String, ?> params) {
        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<XXX> query = builder.createQuery(XXX.class);
        Root<Course> root = query.from(XXX.class);
        Predicate[] predicates = params.entrySet()
                .stream()
                .filter(p -> p.getValue() != null)
                .map(p -> builder.equal(root.get(p.getKey()),
                        isBoolean(p.getValue()) ? booleanValue(p.getValue()) : p.getValue()))
                .toArray(Predicate[]::new);
        query.where(builder.and(predicates));
        return em.createQuery(query.select(root)).getResultList();
    }
}

Spring Data JPA: 为单个Repository添加自定义方法 这里讲了如何为单个Repository添加自定义方,这里就不啰嗦了。

主要说一下这个方法本身。JPA是可以通过普通的Java语句拼接一个查询的,这里我们就用了这种方法,将前端传过来的参数通过key-value手工的把它变成查询的条件,通过这种方式做到了and的条件查询。当然这里还有很多情况没有考虑,例如or、大于、小于等的情况,但大概思路是明确的,就是根据传递进来的map去拼接这么查询语句,最终返回查询结果。这里拼接查询语句的逻辑目前来说是无论如何省不了的。所以还得一个一个情况的处理。

对于返回的数据是多表字段的情况,我们目前是使用比较生猛的方法,直接通过关联的方式把所有关联的对象都取出来。一般来说,这种方法已经可以满足绝大部分情况了。当然,全部数据取出来有时候可能会有效率问题,这时候我们是使用JPA的延迟加载去提高效率,将关联的对象以及关联对象中比较大的blob的数据变为延迟加载。具体问题具体分析,如果是多表数据的情况使用属性关联的方式就可以了,效率问题会有很多种解决方案,需要一个一个的做调优。

对于最后一个问题,我们都是使用属性进行关联的,根据我们的经验,这样可以大大的简化开发中的一些问题,提高开发效率。

gaoyadong

确实不错,我们也用spring boot跟spring data jpa,学到了不少,但是有些问题想请教,现在有这种条件查询需求,有很多可选条件,而且返回的数据可能是多个表的字段合并来的,并不直接是实体类,像这种应该怎么做比较好,还有就是对象关联,直接把关联对象作为属性映射关联还是只使用ID,请问您在这方面有没有比较好的实践经验分享呢?

反馈意见