精通 Spring Boot 系列文（9）
程序IT圈
共 19402字，需浏览 39分钟
· 2020-07-27
阅读全文，约 30 分钟
案例2：关联查询和 @Query 查询
如果两个对象的查询，有关联关系，则可以在方法名中的添加下划线来标识。
我们就用 学生 和 班级 的关系，来给大家举个例子。
1）编辑 pom.xml 文件（与 CrudRepository 接口案例一样）
2）编辑 application.properties 文件（与 CrudRepository 接口案例一样）
3）创建 Student 和 Clazz 持久化类
// 学生
@Entity
@Table(name="tb_student")
public class Student implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name ;
private String address ;
private int age ;
private char sex;
// 学生与班级是多对一的关系，这里配置的是双向关联
@ManyToOne(fetch=FetchType.LAZY, targetEntity=Clazz.class)
@JoinColumn(name="clazzId", referencedColumnName="code")
// 班级
private Clazz clazz ;
// 学生构造器
public Student() {
}
public Student(String name, String address, int age, char sex,
Clazz clazz) {
super();
this.name = name;
this.address = address;
this.age = age;
this.sex = sex;
this.clazz = clazz;
}
// getXxx 和 setXxx 方法
}
@Entity
@Table(name="tb_clazz")
public class Clazz implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private int code ;
private String name ;
// 班级与学生是一对多的关联
@OneToMany(
fetch=FetchType.LAZY,
targetEntity=Student.class,
mappedBy="clazz"
)
private Set students = new HashSet<>();
public Clazz() {
}
// 班级对象
public Clazz(String name) {
this.name = name;
}
}
4）创建 ClazzRepository 和 StudentRepository 数据访问接口
public interface ClazzRepository extends JpaRepository<Clazz, Integer> {
}
public interface StudentRepository extends JpaRepository<Student, Integer> {
/**
* 根据班级名称查询这个班级下所有的学生信息
* 相当于JPQL语句
* select s from Student s where s.clazz.name = ?1
*/
List findByClazz_name(String clazzName) ;
/**
* @Query 写法
* 根据班级名称查询这个班级下所有的学生信息
* ?1 此处使用的是参数的位置，代表的是第一个参数
* 此写法与上面的方法实现的功能完全一致
* */
@Query("select s from Student s where s.clazz.name = ?1")
List findStudentsByClazzName(String clazzName) ;
/**
* 使用 @Query 注解的形式，查询某个班级下所有学生的姓名和性别
*/
@Query("select new Map(s.name as name , s.sex as sex) "
+ "from Student s where s.clazz.name = ?1")
List> findNameAndSexByClazzName(String clazzName);
/**
* 使用 @Query 注解的形式，查询某个班级下某种性别的所有学生的姓名
* 上面方法是用的是参数的位置来查询的，Spring Data JPA中还支持用
* 名称来匹配查询使用格式 “:参数名称” 引用
*/
@Query("select s.name from Student s "
+ "where s.clazz.name = :clazzName and s.sex = :sex ")
List findNameByClazzNameAndSex(@Param("clazzName")String clazzName , @Param("sex")char sex) ;
/**
* 使用 @Query 注解的形式，查询某个学生属于哪个班级
*/
@Query("select c.name from Clazz c inner join c.students s "
+ "where s.name = ?1 ")
String findClazzNameByStuName(String stuName);
/**
* 执行更新查询，使用 @Query与 @Modifying 可以执行更新操作
*/
@Modifying
@Query("delete from Student s where s.name = ?1")
int deleteStuByStuName(String stuName);
}
5）创建 SchoolService 业务层类
@Service
public class SchoolService {
// 注入数据访问层接口对象
@Resource
private StudentRepository studentRepository;
@Resource
private ClazzRepository clazzRepository;
@Transactional
public void saveClazzAll(List clazzs) {
clazzRepository.saveAll(clazzs);
}
@Transactional
public void saveStudentAll(List students) {
studentRepository.saveAll(students);
}
public List> getStusByClazzName(String clazzName) {
List students = studentRepository.findByClazz_name(clazzName);
// List students = studentRepository.findStudentsByClazzName(clazzName);
List> results = new ArrayList<>();
// 遍历查询出的学生对象，提取姓名，年龄，性别信息
for(Student student:students){
Map stu = new HashMap<>();
stu.put("name", student.getName());
stu.put("age", student.getAge());
stu.put("sex", student.getSex());
results.add(stu);
}
return results;
}
public List> findNameAndSexByClazzName(String clazzName) {
return studentRepository.findNameAndSexByClazzName(clazzName);
}
public List findNameByClazzNameAndSex(
String clazzName, char sex) {
return studentRepository.findNameByClazzNameAndSex(clazzName, sex);
}
public String findClazzNameByStuName(String stuName) {
return studentRepository.findClazzNameByStuName(stuName);
}
@Transactional
public int deleteStuByStuName(String stuName) {
return studentRepository.deleteStuByStuName(stuName);
}
}
6）创建 StudentController 控制器类
@RestController
@RequestMapping("/student")
public class StudentController {
@Resource
private SchoolService schoolService;
@RequestMapping("/save")
public String save() {
Clazz clazz1 = new Clazz("架构师 001 班");
Clazz clazz2 = new Clazz("架构师 002 班");
// 保存班级对象数据
List clazzs = new ArrayList<>();
clazzs.add(clazz1);
clazzs.add(clazz2);
schoolService.saveClazzAll(clazzs);
Student s1 = new Student("小黄","广州",18,'男',clazz1);
Student s2 = new Student("小红","北京",17,'女',clazz1);
Student s3 = new Student("小绿","成都",15,'男',clazz2);
List students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
schoolService.saveStudentAll(students);
return "保存学生对象成功";
}
/**
* 查询某个班级下所有的学生姓名，年龄，性别
*/
@RequestMapping("/getClazzStus")
public List> getClazzStus(String clazzName){
return schoolService.getStusByClazzName(clazzName);
}
/**
* 查询某个班级下所有的学生姓名，性别
*/
@RequestMapping("/findNameAndSexByClazzName")
public List> findNameAndSexByClazzName(String clazzName){
return schoolService.findNameAndSexByClazzName(clazzName);
}
/**
* 查询某个班级下某种性别的所有学生的姓名
*/
@RequestMapping("/findNameByClazzNameAndSex")
public List findNameByClazzNameAndSex(String clazzName ,Character sex) {
return schoolService.findNameByClazzNameAndSex(clazzName ,sex);
}
/**
* 查询某个学生属于哪个班级
*/
@RequestMapping("/findClazzNameByStuName")
public String findClazzNameByStuName(String stuName){
return schoolService.findClazzNameByStuName(stuName);
}
/**
* 删除某个学生对象
*/
@RequestMapping("/deleteStuByStuName")
public String deleteStuByStuName(String stuName){
return "删除数据："+schoolService.deleteStuByStuName(stuName);
}
}
7）测试
http://localhost:8080/student/save
案例3：NamedQuery 查询
使用 NameQuery 就是一个名称映射一个查询语句的查询操作。
1）编辑 pom.xml 文件（与 CrudRepository 接口案例一样）
2）创建 Student 和 Clazz 持久化类
先看 Student 类。
@Entity
@Table(name="tb_student")
// 查询班级下的学生
@NamedQuery(name="Student.findStudentsByClazzName",query="select s from Student s where s.clazz.name = ?1")
public class Student implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name ;
private String address ;
private int age ;
private char sex;
// 学生与班级是多对一的关系，这里配置的是双向关联
@ManyToOne(fetch=FetchType.LAZY,
targetEntity=Clazz.class
)
@JoinColumn(name="clazzId",referencedColumnName="code")
private Clazz clazz ;
public Student() {
}
public Student(String name, String address, int age, char sex,
Clazz clazz) {
super();
this.name = name;
this.address = address;
this.age = age;
this.sex = sex;
this.clazz = clazz;
}
// setXxx 和 getXxx 方法
}
再来看看 Clazz 类。
@Entity
@Table(name="tb_clazz")
public class Clazz implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private int code ;
private String name ;
// 班级与学生是一对多的关联
@OneToMany(
fetch=FetchType.LAZY,
targetEntity=Student.class,
mappedBy="clazz"
)
private Set students = new HashSet<>();
public Clazz() {
}
// 班级对象
public Clazz(String name) {
this.name = name;
}
// setXxx 和 getXxx 方法
}
3）创建 StudentRepository 和 ClazzRepository 数据访问接口
先看 StudentRepository 类。
public interface StudentRepository extends JpaRepository<Student, Integer> {
/**
* 查询班级下的所有学生
*/
List findStudentsByClazzName(String clazzName) ;
}
再看 ClazzRepository 类。
public interface ClazzRepository extends JpaRepository<Clazz, Integer> {
}
4）创建 ShcoolService 业务层
@Service
public class ShcoolService {
// 注入数据访问层接口对象
@Resource
private StudentRepository studentRepository;
@Resource
private ClazzRepository clazzRepository;
@Transactional
public void saveClazzAll(List clazzs) {
clazzRepository.saveAll(clazzs);
}
@Transactional
public void saveStudentAll(List students) {
studentRepository.saveAll(students);
}
public List> getStusByClazzName(String clazzName) {
// 查询班级下的所有学生
List students = studentRepository.findStudentsByClazzName(clazzName);
List> results = new ArrayList<>();
// 遍历查询出的学生对象，提取姓名，年龄，性别信息
for(Student student:students){
Map stu = new HashMap<>();
stu.put("name", student.getName());
stu.put("age", student.getAge());
stu.put("sex", student.getSex());
results.add(stu);
}
return results;
}
}
5）创建 StudentController 控制器类
@RestController
@RequestMapping("/student")
public class StudentController {
@Resource
private ShcoolService shcoolService;
@RequestMapping("/save")
public String save() {
Clazz clazz1 = new Clazz("架构师001班");
Clazz clazz2 = new Clazz("架构师002班");
// 保存班级对象数据
List clazzs = new ArrayList<>();
clazzs.add(clazz1);
clazzs.add(clazz2);
shcoolService.saveClazzAll(clazzs);
Student s1 = new Student("帅帅","广州",18,'男',clazz1);
Student s2 = new Student("小黄","广州",17,'女',clazz1);
Student s3 = new Student("小红","广州",15,'男',clazz2);
List students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
shcoolService.saveStudentAll(students);
return "保存学生成功";
}
/**
* 查询某个班级下所有的学生姓名，年龄，性别
*/
@RequestMapping("/getClazzStus")
public List> getClazzStus(String clazzName){
return shcoolService.getStusByClazzName(clazzName);
}
}
6）测试
http://localhost:8080/student/save
案例4：Specification 查询
1）编辑 pom.xml 文件（与 CrudRepository 接口案例一样）
2）编辑 application.properties 文件（与 CrudRepository 接口案例一样）
3）创建 Clazz 和 Student 持久化类
先来看 Clazz 类。
@Entity
@Table(name="tb_clazz")
public class Clazz implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private int code ;
private String name ;
// 班级与学生是一对多的关联
@OneToMany(
fetch=FetchType.LAZY,
targetEntity=Student.class,
mappedBy="clazz"
)
private Set students = new HashSet<>();
public Clazz() {
}
// 班级对象
public Clazz(String name) {
this.name = name;
}
// setXxx 和 getXxx 方法
}
再来看看 Student 类。
@Entity
@Table(name="tb_student")
public class Student implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name ;
private String address ;
private int age ;
private char sex;
// 学生与班级是多对一的关系，这里配置的是双向关联
@ManyToOne(fetch=FetchType.LAZY,
targetEntity=Clazz.class
)
@JoinColumn(name="clazzId",referencedColumnName="code")
private Clazz clazz ;
public Student() {
}
public Student(String name, String address, int age, char sex,
Clazz clazz) {
super();
this.name = name;
this.address = address;
this.age = age;
this.sex = sex;
this.clazz = clazz;
}
// setXxx 和 getXxx 方法
}
4）创建 ClazzRepository 和 StudentRepository 数据访问接口
先看 ClazzRepository 类。
public interface ClazzRepository extends JpaRepository<Clazz, Integer> ,JpaSpecificationExecutor<Clazz>{
}
再看 StudentRepository 类。
public interface StudentRepository extends JpaRepository<Student,Integer>,JpaSpecificationExecutor<Student>{
}
5）创建 ShcoolService 业务层
@Service
public class ShcoolService {
// 注入数据访问层接口对象
@Resource
private StudentRepository studentRepository;
@Resource
private ClazzRepository clazzRepository;
@Transactional
public void saveClazzAll(List clazzs) {
clazzRepository.saveAll(clazzs);
}
@Transactional
public void saveStudentAll(List students) {
studentRepository.saveAll(students);
}
/**
* 根据性别查询学生信息
*/
@SuppressWarnings("serial")
public List> getStusBySex(char sex) {
List students = studentRepository.findAll(new Specification() {
@Override
public Predicate toPredicate(Root root, CriteriaQuery query,
CriteriaBuilder cb) {
Predicate p1 = cb.equal(root.get("sex"), sex);
return p1;
}
});
List> results = new ArrayList<>();
for(Student student:students){
Map stu = new HashMap<>();
stu.put("name", student.getName());
stu.put("age", student.getAge());
stu.put("sex", student.getSex());
results.add(stu);
}
return results;
}
/**
* 动态查询学生信息
* 可以根据学生对象的姓名（模糊匹配）
* 地址查询（模糊匹配）、性别、班级查询学生信息
* 如果没有传输参数，默认查询所有的学生信息
*/
@SuppressWarnings("serial")
public List> getStusByDynamic(Student student) {
List students = studentRepository.findAll(new Specification() {
@Override
public Predicate toPredicate(Root root, CriteriaQuery query,
CriteriaBuilder cb) {
// 本集合用于封装查询条件
List predicates = new ArrayList();
if(student!=null){
/** 是否传入了姓名来查询 */
if(!StringUtils.isEmpty(student.getName())){
predicates.add(cb.like(root. get("name"),"%" + student.getName() + "%"));
}
/** 是否传入了地址来查询 */
if(!StringUtils.isEmpty(student.getAddress())){
predicates.add(cb.like(root. get("address"),"%" + student.getAddress() + "%"));
}
/** 是否传入了性别来查询 */
if(student.getSex() != '\0'){
predicates.add(cb.equal(root. get("sex"),student.getSex()));
}
/** 判断是否传入了班级信息来查询 */
if(student.getClazz()!=null && !StringUtils.isEmpty(student.getClazz().getName())){
root.join("clazz", JoinType.INNER);
Path clazzName = root.get("clazz").get("name");
predicates.add(cb.equal(clazzName, student.getClazz().getName()));
}
}
return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
}
});
List> results = new ArrayList<>();
for(Student stu :students){
Map 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;
}
/**
* 分页查询某个班级的学生信息
*/
@SuppressWarnings("serial")
public Page getStusByPage(String clazzName , int pageIndex , int pageSize ) {
// 指定排序参数对象：根据id，进行降序查询
Sort sort = new Sort(Sort.Direction.DESC, "id");
// 分页查询学生信息，返回分页实体对象数据
// pages对象中包含了查询出来的数据信息，以及与分页相关的信息
Page pages = studentRepository.findAll(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 ;
}
},PageRequest.of(pageIndex-1, pageSize, sort));
return pages;
}
}
6）创建分页对象
添加 nx.vo 文件夹，然后创建分页对象，具体如下：
public class PageData {
// 定义一个变量用于存放当前页码
private int pageIndex;
// 定义一个变量用于保存满足查询条件下用于分页的数据总量
private long totalCount ;
// 定义一个变量用于保存当前条件下总共可以分的总页数
private int pageSize ;
// 定义一个变量用于保存当前页码查询出的数据总量
private int pageNum;
// 定义一个变量用于保存当前查询出来的学生信息
private List> stuDatas = new ArrayList<>();
// setXxx 和 getXxx 方法
}
7）创建 StudentController 控制器类
@RestController
@RequestMapping("/student")
public class StudentController {
// 注入ShcoolService
@Resource
private ShcoolService shcoolService;
@RequestMapping("/save")
public String save() {
Clazz clazz1 = new Clazz("架构师001班");
Clazz clazz2 = new Clazz("架构师002班");
// 保存班级对象数据
List clazzs = new ArrayList<>();
clazzs.add(clazz1);
clazzs.add(clazz2);
shcoolService.saveClazzAll(clazzs);
Student s1 = new Student("小黄","广州",17,'男',clazz1);
Student s2 = new Student("小红","成都",15,'女',clazz1);
Student s3 = new Student("小绿","上海",15,'男',clazz1);
Student s4 = new Student("小豆","北京",15,'女',clazz2);
Student s5 = new Student("小牛","西藏",15,'男',clazz2);
Student s6 = new Student("小兰","黑龙江",17,'女',clazz2);
List students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
students.add(s5);
students.add(s6);
shcoolService.saveStudentAll(students);
return "保存学生成功";
}
@RequestMapping("/getStusBySex")
public List> getStusBySex(char sex){
return shcoolService.getStusBySex(sex);
}
// 动态的查询学生信息
@RequestMapping("/getStusByDynamic")
public List> getStusByDynamic(Student student) {
return shcoolService.getStusByDynamic(student);
}
// 分页查询某个班级下的学生信息
@RequestMapping("/getStusByPage")
public PageData getStusByPage(String clazzName , int pageIndex , int pageSize ) {
// 分页查询某个班级的学生信息
Page page = shcoolService.getStusByPage(clazzName , pageIndex , pageSize);
// 对查询出来的结果数据进行分析
List students = page.getContent();
List> stuDatas = new ArrayList<>();
for(Student stu :students){
Map stuMap = new HashMap<>();
stuMap.put("id", stu.getId());
stuMap.put("name", stu.getName());
stuMap.put("age", stu.getAge());
stuMap.put("sex", stu.getSex());
stuMap.put("address", stu.getAddress());
stuMap.put("clazzName", clazzName);
stuDatas.add(stuMap);
}
// 将分页查询出的结果数据进行分析，然后把数据存入到PageData对象中去保存起来响应给浏览器展示
PageData data = new PageData();
data.setStuDatas(stuDatas);
data.setPageIndex(page.getNumber()+1);
data.setPageSize(page.getTotalPages());
data.setTotalCount(page.getTotalElements());
data.setPageNum(page.getSize());
return data ;
}
}
8）测试
http://localhost:8080/student/save
Java后端编程
更多Java推文，关注公众号
评论
文心一言 vs GPT-4 —— 全面横向比较
向AI转型的程序员都关注了这个号👇👇👇文章目录PK方法PK过程Round 1: 语义理解简单语义文言文理解孤立语理解上下文理解Round 2: 内容创作撰写邮件撰写影评撰写软文Round 3: 逻辑推理简单推理逻辑陷阱逻辑干扰多链条推理Round 4: 编码能力常见算法高级算法找bug代码理解Rou
机器学习AI算法工程
0
学一学 Spring Boot 3.x
在 Java 后端开发领域，功能强大的 Spring 开源框架不仅是首选，也是事实上的标准。但由于 Spring 存在配置烦琐、部署不易、依赖管理困难等问题，因此基于 Spring 的快速开发框架 Spring Boot 应运而生，它能大大简化 Spring 应用程序的配置和部署过程。2018 年，
小哈学Java
0
Go 1.22 的新增功能系列之二：reflect.TypeFor
Go 1.22 的第一个候选版本已经发布，这意味着最终版本即将发布，现在是我在博客中介绍我在这个周期中所做工作的时候了。像往常一样，我的贡献很小，但它们是我的，所以我将从幕后的角度来谈谈它们。首先是reflect.TypeFor。这是整个函数：// TypeFor returns the [Type
GoCN
0
有意思！一个关于 Spring 历史的在线小游戏
发现 Spring One 的官网上有个好玩的彩蛋，分享给大家！进到Spring One的官网，可以看到右下角有个类似马里奥游戏中的金币图标。点击该金币之后，会打开一个新的页面，进入下面这样一个名为：The History Of Spring 的在线小游戏你可以使用上下左右的方向键来控制Spring
公众号程序猿DD
1
豆瓣9分线代教材免费了！斯坦福伯克利都在用，新版PDF直接下载
西风 发自 凹非寺 量子位 | 公众号 QbitAI豆瓣评分9.2、斯坦福都在用的线性代数教材，全新第四版免费来袭！没错，就是那本被认为“直击线性代数理论核心”的Linear Algebra Done Right。此书之前已发售三版，风靡30多个国家的200多所高校，这其中就包括斯坦福、UCB等顶尖
机器学习算法与Python实战
0
Go 1.22 的新增功能系列之一：cmp.Or
截至撰写本文时，Go 1.22 已经发布几个月了。早就该结束我为 1.22 所做的工作的系列了。抱歉耽搁了这么久，我最近忙于生活事务。如果您错过了我关于reflect.TypeFor(https://blog.carlana.net/post/2024/golang-reflect-type-for
GoCN
1
全新 SOTA backbone | 2024年了，再见ViT系列Backbone，实数难得，不知道效果如何？
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达在构建用于精确匹配的深度固定长度表示时，确定指纹上的密集特征点，特别是在像素 Level 上，具有重大意义。为了探索指纹匹配的可解释性，作者提出了一种多阶段可解释的指纹匹配网络，名为通过视觉 Transformer 进行指纹匹配的
小白学视觉
10
Spring Boot + flowable 快速实现工作流
关注我们,设为星标,每天7:40不见不散,架构路上与您共享回复架构师获取资源大家好，我是你们的朋友架构君，一个会写代码吟诗的架构师。来源：blog.csdn.net/zhan107876/article/details/120815560总览一、flowable-ui部署运行二、绘制流程图绘图细节：
Java架构师社区
0