Spring-Data-Jpa动态查询（Specification）

import org.springframework.data.jpa.domain.Specification;

import org.springframework.lang.Nullable;

public interface JpaSpecificationExecutor {

//根据Specification接口封装的查询条件，查询出单一实例

Optional findOne(@Nullable Specification spec);

//根据Specification接口封装的查询条件，查询出满足条件的所有对象数据，返回的是List集合

List findAll(@Nullable Specification spec);

/**

• 根据Specification接口封装的查询条件以及Pageable封装的分页及排序规则查询出满足条件

• 的对象数据，返回的是Page对象，Page对象中封装了查询出的数据信息以及分页信息。

*/

Page findAll(@Nullable Specification spec, Pageable pageable);

//根据Specification接口封装的查询条件以及Sort封装的排序规则查询出满足条件的所有对象数据，返回的是List集合

List findAll(@Nullable Specification spec, Sort sort);

//根据Specification接口封装的查询条件，查询出满足此条件的数据总数

long count(@Nullable Specification spec);

}

从JpaSpecificationExecutor的方法中可以看出，一般通过创建Specification的匿名内部类对象来封装Criteria条件查询信息然后交由JpaSpecification提供的方法进行相关数据的查询操作。

1. Optional findOne(@Nullable Specification spec)；根据Specification接口封装的查询条件，查询出单一实例。

2. List findAll(@Nullable Specification spec)；根据Specification接口封装的查询条件，查询出满足条件的所有对象数据，返回的是List集合。

3. Page findAll(@Nullable Specification spec, Pageable pageable)；根据Specification接口封装的查询条件以及Pageable封装的分页及排序规则查询出满足条件的对象数据，返回的是Page对象，Page对象中封装了查询出的数据信息以及分页信息。

4. List findAll(@Nullable Specification spec, Sort sort)；根据Specification接口封装的查询条件以及Sort封装的排序规则查询出满足条件的所有对象数据，返回的是List集合。

5. long count(@Nullable Specification spec)；根据Specification接口封装的查询条件，查询出满足此条件的数据总数。

所以在实际项目开发中，如果希望使用Specification查询，数据访问层的定义通常如下代码所示。

public interface StuRepository1 extends JpaRepository<Stu, Integer>, JpaSpecificationExecutor {

}

编写代码

---

上一篇讲了Spring-Data-Jpa入门，这一篇来看一下Spring-Data-Jpa条件查询（基于上一篇Spring-Data-Jpa入门的项目中写的，配置文件没有任何改动，详情可以参考Spring-Data-Jpa入门）。

1、创建持久化类

在entity包中创建两个持久化类学生类Stu.java和班级类Clazz.java，代码如下

Stu.java类（Stu和Clazz是多对一关系，表关联注解代码中有注释）

import com.fasterxml.jackson.annotation.JsonIgnore;

import org.springframework.data.annotation.CreatedBy;

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Table;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.ManyToOne;

//用于标记持久化类，SpringBoot项目加载后会自动根据持久化类建表

@Entity

//设置表名为tb_stu

@Table(name=“tb_stu”)

public class Stu {

private Integer id; //主键

private String name;    //姓名

private String address;     //地址

private Integer age;    //年龄

private char sex;   //性别

//@JsonIgnore注解是类注解，作用是json序列化时将java bean中的一些属性忽略掉

@JsonIgnore

private Clazz clazz;

/**

• 使用@id指定主键。使用代码@GeneratedValue

• 指定主键的生存策略，mysql默认为自动增长

*/

@Id

@GeneratedValue

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

public char getSex() {

return sex;

}

public void setSex(char sex) {

this.sex = sex;

}

//关联表对应关系，学生与班级的多对一的关系

@ManyToOne

@CreatedBy

public Clazz getClazz() {

return clazz;

}

public void setClazz(Clazz clazz) {

this.clazz = clazz;

}

public Stu() {

}

public Stu(String name, String address, Integer age, char sex, Clazz clazz) {

this.name = name;

this.address = address;

this.age = age;

this.sex = sex;

this.clazz = clazz;

}

}

Class.java类（Clazz和Stu是一对多关系，表关联注解代码中有注释）

import com.fasterxml.jackson.annotation.JsonIgnore;

import javax.persistence.*;

import java.util.ArrayList;

import java.util.List;

//用于标记持久化类，SpringBoot项目加载后会自动根据持久化类建表

@Entity

//设置表名为tb_clazz

@Table(name=“tb_clazz”)

public class Clazz {

private Integer id; //主键

private String name;    //班级名称

//@JsonIgnore注解是类注解，作用是json序列化时将java bean中的一些属性忽略掉

@JsonIgnore

private List stuList = new ArrayList<>();

/**

• 使用@id指定主键。使用代码@GeneratedValue(strategy = GenerationType.IDENTITY)

• 指定主键的生存策略，mysql默认为自动增长

*/

@Id

@GeneratedValue

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

//班级与学生是一对多的关联，mappedBy对应Stu表中clazz字段

@OneToMany(cascade=CascadeType.ALL,mappedBy=“clazz”)

public List getStuList() {

return stuList;

}

public void setStuList(List stuList) {

this.stuList = stuList;

}

public Clazz(String name) {

this.name = name;

}

public Clazz() {

}

}

从上述代码可以看出，班级与学生是一对多的关系，一个班级可以有多名学生，此处做的是双向关联，即在班级对象中关联了学生对象，在学生对象中也关联了班级对象。

2、定义数据访问层接口

之后在repository包下新建一个接口，命名为StuRepository1，该接口继承JpaRepository接口，以持久化对象Stu作为JpaRepository的第一个类型参数，表示当前所操作的持久化对象类型，Integer作为JpaRepository的第二个类型参数，用于指定ID类型，同时创建一个接口名称为ClazzRepository1，继承JpaRepository的接口，用于访问班级信息的数据。完整代码如下。

ClazzRepository1.java接口

import com.mcy.springdatajpa.entity.Clazz;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface ClazzRepository1 extends JpaRepository<Clazz, Integer>, JpaSpecificationExecutor {

}

以上数据访问层接口用于对班级表进行相关的CRUD操作，同时由于实现了JpaSpecificationExecutor接口，ClazzRepository接口也将拥有JpaSpecificationExecutor接口提供的功能。

StuRepository1.java接口

import com.mcy.springdatajpa.entity.Stu;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface StuRepository1 extends JpaRepository<Stu, Integer>, JpaSpecificationExecutor {

}

3、定义业务层类

在service包下新建一个SchoolService1.java类，其中主要的几个查询方法有。

根据性别查询学生信息方法。

@SuppressWarnings(“serial”)

public List<Map<String, Object>> getStusBySex(char sex){

List stus = stuRepository1.findAll(new Specification(){

@Override

public Predicate toPredicate(Root root, CriteriaQuery<?> query, CriteriaBuilder cb) {

//root.get(“sex”)表示获取sex这个字段名称，equal表示执行equal查询

//相当于select s from Stu s where s.sex = ?1

Predicate p1 = cb.equal(root.get(“sex”), sex);

return p1;

}

});

List<Map<String, Object>> results = new ArrayList<>();

//遍历查询出的学生对象，提取姓名，年龄，性别信息

for(Stu s: stus){

Map<String, Object> stu = new HashMap<>();

stu.put(“name”, s.getName());

stu.put(“age”, s.getAge());

stu.put(“sex”, s.getSex());

results.add(stu);

}

return results;

}

动态查询学生信息：可以根据学生对象的姓名（模糊匹配），地址查询（模糊匹配），性别，班级查询学生信息，如果没有传入参数，默认查询所有的学生信息。

@SuppressWarnings(“serial”)

public List<Map<String, Object>> getStusByDynamic(Stu stu){

List stus = stuRepository1.findAll(new Specification() {

@Override

public Predicate toPredicate(Root root, CriteriaQuery<?> query, CriteriaBuilder cb) {

//本集合用于封装查询条件

List predicates = new ArrayList<>();

if(stu != null){

//是否传入用于查询的姓名

if(!StringUtils.isEmpty(stu.getName())){

predicates.add(cb.like(root.get(“name”), “%”+stu.getName()+“%”));

}

//判断是否传入查询的地址

if(!StringUtils.isEmpty(stu.getAddress())){

predicates.add(cb.like(root.get(“address”), “%”+stu.getAddress()+“%”));

}

//判断是否传入查询的性别

if(stu.getSex() != ‘\0’){

predicates.add(cb.equal(root.get(“sex”), stu.getSex()));

}

//判断是否传入用于查询的班级信息

if(stu.getClazz() != null && !StringUtils.isEmpty(stu.getClazz().getName())){

root.join(“clazz”, JoinType.INNER);

Path clazzName = root.get(“clazz”).get(“name”);

predicates.add(cb.equal(clazzName, stu.getClazz().getName()));

}

}

return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();

}

});

List<Map<String, Object>> results = new ArrayList<>();

//遍历查询出的学生对象，提取姓名，年龄，性别信息

for(Stu s : stus){

Map<String, Object> stuMap = new HashMap<>();

stuMap.put(“name”, stu.getName());

stuMap.put(“age”, stu.getAge());

stuMap.put(“sex”, stu.getSex());

stuMap.put(“address”, stu.getAddress());

stuMap.put(“clazzName”, stu.getClazz().getName());

results.add(stuMap);

}

return results;

}

分页查询某个班级的学生信息 @param clazzName 代表班级名称，@param pageIndex 代表当前查询第几页 ，@param pageSize 代表每页查询的最大数据量。

@SuppressWarnings(“serial”)

public Page getStusByPage(String clazzName, int pageIndex, int pageSize){

//指定排序参数对象：根据id，进行降序查询

Sort sort = Sort.by(Sort.Direction.DESC, “id”);

//Specification动态查询

Specification spec = buildSpec(clazzName, pageIndex, pageSize);

//分页查询学生信息，返回分页实体对象数据

//pages对象中包含了查询出来的数据信息以及与分页相关的信息

Page pages = stuRepository1.findAll(spec, PageRequest.of(pageIndex-1, pageSize, sort));

return pages;

}

private Specification buildSpec(String clazzName, int pageIndex, int pageSize) {

Specification spec = new Specification() {

@Override

public Predicate toPredicate(Root root, CriteriaQuery<?> query, CriteriaBuilder cb) {

root.join(“clazz”, JoinType.INNER);

Path cn = root.get(“clazz”).get(“name”);

Predicate p1 = cb.equal(cn, clazzName);

return p1;

}

};

return spec;

}

SchoolService1.java中全部代码。

import com.mcy.springdatajpa.entity.Clazz;

import com.mcy.springdatajpa.entity.Stu;

import com.mcy.springdatajpa.repository.ClazzRepository1;

import com.mcy.springdatajpa.repository.StuRepository1;

import org.springframework.data.domain.Page;

import org.springframework.data.domain.PageRequest;

import org.springframework.data.domain.Sort;

import org.springframework.data.jpa.domain.Specification;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.util.StringUtils;

import javax.annotation.Resource;

import javax.persistence.criteria.*;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

@Service

public class SchoolService1 {

//注入数据访问层接口对象

@Resource

private StuRepository1 stuRepository1;

@Resource

private ClazzRepository1 clazzRepository1;

@Transactional

public void saveClazzAll(List clazzes){

clazzRepository1.saveAll(clazzes);

}

@Transactional

public void saveStuAll(List stu){

stuRepository1.saveAll(stu);

}

/**

• 根据性别查询学生信息

• @param sex

• @return

*/

@SuppressWarnings(“serial”)

public List<Map<String, Object>> getStusBySex(char sex){

List stus = stuRepository1.findAll(new Specification(){

@Override

public Predicate toPredicate(Root root, CriteriaQuery<?> query, CriteriaBuilder cb) {

//root.get(“sex”)表示获取sex这个字段名称，equal表示执行equal查询

//相当于select s from Stu s where s.sex = ?1

Predicate p1 = cb.equal(root.get(“sex”), sex);

return p1;

}

});

List<Map<String, Object>> results = new ArrayList<>();

//遍历查询出的学生对象，提取姓名，年龄，性别信息

for(Stu s: stus){

Map<String, Object> stu = new HashMap<>();

stu.put(“name”, s.getName());

stu.put(“age”, s.getAge());

stu.put(“sex”, s.getSex());

results.add(stu);

}

return results;

}

/**

• 动态查询学生信息：可以根据学生对象的姓名（模糊匹配），地址查询（模糊匹配），性别，班级查询学生信息

• 如果没有传入参数，默认查询所有的学生信息

• @param stu

• @return

*/

@SuppressWarnings(“serial”)

public List<Map<String, Object>> getStusByDynamic(Stu stu){

List stus = stuRepository1.findAll(new Specification() {

@Override

public Predicate toPredicate(Root root, CriteriaQuery<?> query, CriteriaBuilder cb) {

//本集合用于封装查询条件

List predicates = new ArrayList<>();

if(stu != null){

//是否传入用于查询的姓名

if(!StringUtils.isEmpty(stu.getName())){

predicates.add(cb.like(root.get(“name”), “%”+stu.getName()+“%”));

}

//判断是否传入查询的地址

if(!StringUtils.isEmpty(stu.getAddress())){

predicates.add(cb.like(root.get(“address”), “%”+stu.getAddress()+“%”));

}

//判断是否传入查询的性别

if(stu.getSex() != ‘\0’){

predicates.add(cb.equal(root.get(“sex”), stu.getSex()));

}

//判断是否传入用于查询的班级信息

if(stu.getClazz() != null && !StringUtils.isEmpty(stu.getClazz().getName())){

root.join(“clazz”, JoinType.INNER);

Path clazzName = root.get(“clazz”).get(“name”);

predicates.add(cb.equal(clazzName, stu.getClazz().getName()));

}

}

return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();

}

});

List<Map<String, Object>> results = new ArrayList<>();

//遍历查询出的学生对象，提取姓名，年龄，性别信息

for(Stu s : stus){

Map<String, Object> stuMap = new HashMap<>();

stuMap.put(“name”, s.getName());

stuMap.put(“age”, s.getAge());

stuMap.put(“sex”, s.getSex());

stuMap.put(“address”, s.getAddress());

stuMap.put(“clazzName”, s.getClazz().getName());

results.add(stuMap);

}

return results;

}

/***

• 分页查询某个班级的学生信息

• @param clazzName 代表班级名称

• @param pageIndex 代表当前查询第几页

• @param pageSize 代表每页查询的最大数据量

• @return

*/

@SuppressWarnings(“serial”)

public Page getStusByPage(String clazzName, int pageIndex, int pageSize){

//指定排序参数对象：根据id，进行降序查询

Sort sort = Sort.by(Sort.Direction.DESC, “id”);

//Specification动态查询

Specification spec = buildSpec(clazzName, pageIndex, pageSize);

//分页查询学生信息，返回分页实体对象数据

//pages对象中包含了查询出来的数据信息以及与分页相关的信息

Page pages = stuRepository1.findAll(spec, PageRequest.of(pageIndex-1, pageSize, sort));

return pages;

}

private Specification buildSpec(String clazzName, int pageIndex, int pageSize) {

Specification spec = new Specification() {

@Override

public Predicate toPredicate(Root root, CriteriaQuery<?> query, CriteriaBuilder cb) {

root.join(“clazz”, JoinType.INNER);

Path cn = root.get(“clazz”).get(“name”);

Predicate p1 = cb.equal(cn, clazzName);

return p1;

}

};

return spec;

}

}

在业务层中需要注入数据访问层对象，在上述代码中我们是通过@Resource注解将StuRepository接口以及ClazzRepository接口对应的实现类对象注入的，同时在业务层方法中定义三个方法，分别实现了对班级信息的条件查询，动态SQL语句以及分页查询。

4、定义分页的页面数据对象

在项目下新建一个包，命名为custom，在custom下新建一个java类，命名为PageData.java，此类用于封装分页查询出的数据信息，主要包含了当前页码（pageIndex）、满足查询条件下用于分页的数据总量（totalCount）、当前条件下总共可以分的总页数（pageSize）、当前页码展示的数据量（pageNum）以及查询出的数据信息（stuDatas）。详细代码如下。

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

/**

• 定义一个对象用于封装一页的数据

*/

public class PageData {

//定义一个变量用于存放当前页码

private int pageIndex;

//定义一个变量用于保存满足查询条件下用于分页的数据总量

private long totalCount;

//定义一个变量用于保存当前条件下可以分页的总页数

private int pageSize;

//定义一个变量用于保存当前页码查询出的数据总量

private int pageNum;

//定义一个变量用于保存当前查询出来的学生信息

private List<Map<String, Object>> stuDates = new ArrayList<>();

public int getPageIndex() {

return pageIndex;

}

public void setPageIndex(int pageIndex) {

this.pageIndex = pageIndex;

}

public long getTotalCount() {

return totalCount;

}

public void setTotalCount(long totalCount) {

this.totalCount = totalCount;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

金三银四到了，送上一个小福利！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

public long getTotalCount() {

return totalCount;

}

public void setTotalCount(long totalCount) {

this.totalCount = totalCount;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-YFt1dcvE-1713398833524)]

[外链图片转存中…(img-eD6yRaAa-1713398833525)]

[外链图片转存中…(img-8mDdx6Dz-1713398833525)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

金三银四到了，送上一个小福利！

[外链图片转存中…(img-qL5rrgbo-1713398833525)]

[外链图片转存中…(img-NGCK2Yh8-1713398833525)]

[外链图片转存中…(img-VcH0S39r-1713398833526)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！