Spring Data JPA复杂动态查询

Spring Data JPA其诸多优点给我们的工作带来了很多便利，但对于接触不久的同学来说，有些情况让我们头疼。一些复杂的查询，比如涉及到聚合函数、动态多条件等，着实有些棘手。在不够了解的情况下，觉得Spring Data JPA在这方面不太人性化，有时候我们干脆使用原生sql粗暴的来解决这类查询问题。但这与Spring Data JPA的初衷是相悖的，在不断的学习中，慢慢发现Spring Data JPA的冰山一角，不禁感叹于它的强大。现将一些所得，与大家分享。

先看示例的数据表：

一张简单的学生信息表：包含住址、姓名、学校、电话、出生日期、分数等信息。

应用场景：查询某几个学校出生日期在某个范围内的学生信息，按学校分组统计，并计算各学校人数、总分数、第一名姓名及分数，另外还涉及到排序和筛选。

实现方式：

EntityManager：EntityManager是JPA中用于增删改查的接口，它的作用相当于一座桥梁，连接内存中的java对象和数据库的数据存储。可以用getCriteriaBuilder()的方式获取CriteriaBuilder对象。

CriteriaBuilder接口：用于构造标准查询、复合条件、表达式、排序等。可以通过createQuery的方式获取CriteriaQuery实例。

CriteriaQuery接口：代表一个specific的顶层查询对象，它包含着查询的各个部分，比如：select 、from、where、group by、order by。

Root接口：代表Criteria查询的根对象，定义了实体类型，能为将来导航获得想要的结果，它与SQL查询中的FROM子句类似。

实现代码：

    //通过注解@PersistenceContext注入的方式来获得EntityManager对象
    @PersistenceContext
    private EntityManager entityManager;

    public void multiQueryStudent (StudentParam studentParam) {   //studentParam:自定义的查询参数体
        List<String> schoolList = studentParam.getSchoolList();   //查询条件：学校List
        String startDate = studentParam.getStartDate();   //查询条件：出生日期-起
        String endDate = studentParam.getEndDate();   //查询条件：出生日期-止
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        //StudentScoreSum指定了查询结果返回至自定义对象
        CriteriaQuery<StudentScoreSum> query = cb.createQuery(StudentScoreSum.class);
        Root<StudentEntity> root = query.from(StudentEntity.class);
        Path<String> schoolPath = root.get("school");
        Path<Integer> scorePath = root.get("score");
        Path<String> namePath = root.get("name");
        Path<String> birthdayPath = root.get("birthday");
        //拼接where条件
        List<Predicate> predicateList = new ArrayList<Predicate>();
        if (schoolList != null && schoolList.size() > 0) {
            CriteriaBuilder.In<String> in = cb.in(schoolPath);
            for (String school : schoolList) {
                in.value(school);
            }
            predicateList.add(in);
        }
        if (startDate != null && !"".equals(startDate)) {
            predicateList.add(cb.greaterThan(birthdayPath, startDate));
        }
        if (endDate != null && !"".equals(endDate)) {
            predicateList.add(cb.lessThan(birthdayPath, endDate));
        }
        Predicate[] predicates = new Predicate[predicateList.size()];
        predicates = predicateList.toArray(predicates);
        //加上where条件
        query.where(predicates);
        //指定查询项，select后面的东西
        query.multiselect(schoolPath, cb.count(root).as(Integer.class), cb.sum(scorePath), namePath, cb.max(scorePath));
        //按学校分组
        query.groupBy(schoolPath);
        //排序
        query.orderBy(cb.desc(cb.max(scorePath)));
        //筛选第一名成绩大于80分的
        query.having(cb.greaterThan(cb.max(scorePath), 80));
        TypedQuery<StudentScoreSum> q = entityManager.createQuery(query);
        List<StudentScoreSum> result = q.getResultList();
        for (StudentScoreSum studentScoreSum : result) {
            //打印查询结果
            System.out.println(studentScoreSum.toString());
        }
    }

自定义的查询参数体：

public class StudentParam {
    private String name;   //姓名
    private String address;   //住址
    private List<String> schoolList;   //学校
    private String startDate;   //出生日期-起
    private String endDate;   //出生日期-止

    //省略get、set方法
}

自定义的查询结果实体类：

public class StudentScoreSum {
    private String school;
    private Integer count;   //学生人数
    private Long scoreSum;   //总分数
    private String name;   //第一名姓名
    private Integer score;   //第一名分数

    //省略了set、get方法

    public StudentScoreSum(String school, Integer count, Long scoreSum, String name, Integer score) {
        this.school = school;
        this.count = count;
        this.scoreSum = scoreSum;
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "StudentScoreSum{" +
                "school='" + school + '\'' +
                ", count=" + count +
                ", scoreSum=" + scoreSum +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

Entity实体类：

@Entity
@Table(name = "t_student")
public class StudentEntity {
    @Id
    private String id;
    private String name;
    private String address;
    private String tel;
    private String school;
    private String birthday;
    private Integer score;

    //省略set、get方法。
}

查询参数赋值及查询接口调用（本人用的Junit测试方法）：

@Test
    public void multiQueryStudentTest() {
        StudentParam studentParam = new StudentParam();
        List<String> schoolList = new ArrayList<String>();
        schoolList.add("上大附中");
        schoolList.add("实验中学");
        schoolList.add("山大附中");
        schoolList.add("育英中学");
        schoolList.add("西城中学");
        schoolList.add("青大附中");
        studentParam.setSchoolList(schoolList);
        studentParam.setStartDate("2001-01-01");
        studentParam.setEndDate("2003-01-01");
        studentService.multiQueryStudent(studentParam);
    }

执行结果如下：

Hibernate: 
    select
        studentent0_.school as col_0_0_,
        cast(count(studentent0_.id) as signed) as col_1_0_,
        sum(studentent0_.score) as col_2_0_,
        studentent0_.name as col_3_0_,
        max(studentent0_.score) as col_4_0_ 
    from
        t_student studentent0_ 
    where
        (
            studentent0_.school in (
                ? , ? , ? , ? , ? , ?
            )
        ) 
        and studentent0_.birthday>? 
        and studentent0_.birthday<? 
    group by
        studentent0_.school 
    having
        max(studentent0_.score)>80 
    order by
        max(studentent0_.score) desc

StudentScoreSum{school='青大附中', count=4, scoreSum=286, name='李四', score=99}
StudentScoreSum{school='西城中学', count=2, scoreSum=196, name='郎芬', score=98}
StudentScoreSum{school='山大附中', count=3, scoreSum=254, name='杜吉祥', score=89}
StudentScoreSum{school='育英中学', count=1, scoreSum=89, name='陆大安', score=89}
StudentScoreSum{school='上大附中', count=1, scoreSum=81, name='李天山', score=81}

Process finished with exit code 0

上半部分是Hibernate输出的自动生成的sql语句，自己不需要写一句sql，都是自动生成的，下半部分是查询结果。越了解，越佩服Spring Data JPA的强大，另外，常用的，像：avg()、exists、distinct、between等等，都可以支持。

最后，希望我的分享能给需要的朋友带来一点参考或帮助，不足之处请斧正。