SpringBoot学习之旅(八)---JPA进阶篇之联表操作

阳光穿透心脏的1/2处 2022-03-06 03:03 395阅读 0赞

文章目录

        • 前言
        • 源码下载
        • 其他文章
        • 数据关联关系映射
        • 数据库创建
        • 数据库表映射对象
        • 操作及测试
          • 学生操作及测试
          • 其他功能测试
        • 常见问题
        • 总结

前言

前两节有说道JPA的基础操作及JPA自定义查询、修改、分页等操作，有兴趣的可以去看看，前面两章的所有操作都只是在操作一张表，但是真实的项目中，不可能所有的业务都只去做单标的操作，因为这不符合数据库表的设计法则，因此，各个表之间就总会发生那么点正当、或者不正当的关系；那么我们就得去理清各个要素之间的关系；

源码下载

点击开源中国下载源码

由于代码内容比较多多，建议优先下载代码，对着代码读更加快捷

其他文章

SpringBoot学习之旅(七)—JPA进阶篇之自定义查询、修改、分页

数据关联关系映射


























关系类型 Owning-Side Inverse-Side
one-to-one @OneToOne @OneToOne(mappedBy=“othersideName”)
one-to-many / many-to-one @ManyToOne @OneToMany(mappedBy=“xxx”)
many-to-many @ManyToMany @ManyToMany(mappedBy =“xxx”)

针对以上关系，举一下常见例子

  • 一对一
    一个学生只能对应一个档案编号及学号
  • 一对多/多对一
    一个班级可以容纳多个学生
  • 多对多
    一个学生可以选择多门学科，一个学科允许有多个学生学习

数据库创建

  • 表结构

    1. -- 学生信息表
    2. DROP TABLE IF EXISTS `student_info`;
    3. CREATE TABLE `student_info` (
    4.   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '索引ID',
    5.   `stu_name` varchar(20) NOT NULL COMMENT '学生姓名',
    6.   `stu_sex` int(2) NOT NULL COMMENT '学生性别',
    7.   `stu_age` int(3) NOT NULL COMMENT '学生年龄',
    8.   `stu_class_id` int(5) NOT NULL COMMENT '学生班级ID',
    9.   `stu_file_id` int(5) NOT NULL COMMENT '学生档案ID',
    10.   PRIMARY KEY (`id`),
    11.   KEY `student_info_class_id` (`stu_class_id`),
    12.   KEY `student_info_file_id` (`stu_file_id`),
    13.   CONSTRAINT `student_info_class_id` FOREIGN KEY (`stu_class_id`) REFERENCES `class_info` (`id`),
    14.   CONSTRAINT `student_info_file_id` FOREIGN KEY (`stu_file_id`) REFERENCES `file_info` (`id`)
    15. ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
    17. -- ----------------------------
    18. -- Records of student_info
    19. -- ----------------------------
    20. INSERT INTO `student_info` VALUES ('1', '张三', '0', '7', '1', '1');
    21. INSERT INTO `student_info` VALUES ('2', '李四', '1', '7', '1', '2');
    22. INSERT INTO `student_info` VALUES ('3', '王五', '2', '7', '2', '3');
    24. -- 班级表
    25. DROP TABLE IF EXISTS `class_info`;
    26. CREATE TABLE `class_info` (
    27.   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '班级ID',
    28.   `class_name` varchar(255) DEFAULT NULL COMMENT '班级名称',
    29.   PRIMARY KEY (`id`)
    30. ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
    32. -- ----------------------------
    33. -- Records of class_info
    34. -- ----------------------------
    35. INSERT INTO `class_info` VALUES ('1', '一年级一班');
    36. INSERT INTO `class_info` VALUES ('2', '一年级二班');
    37. INSERT INTO `class_info` VALUES ('3', '一年级三班');
    38. INSERT INTO `class_info` VALUES ('4', '二年级一班');
    40. --档案表
    41. DROP TABLE IF EXISTS `file_info`;
    42. CREATE TABLE `file_info` (
    43.   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '索引ID',
    44.   `file_id` int(11) DEFAULT NULL COMMENT '档案编号',
    45.   PRIMARY KEY (`id`)
    46. ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
    48. -- ----------------------------
    49. -- Records of file_info
    50. -- ----------------------------
    51. INSERT INTO `file_info` VALUES ('1', '100001');
    52. INSERT INTO `file_info` VALUES ('2', '100002');
    53. INSERT INTO `file_info` VALUES ('3', '100003');
    55. -- 科目表
    56. DROP TABLE IF EXISTS `subject_info`;
    57. CREATE TABLE `subject_info` (
    58.   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '索引ID',
    59.   `subject_name` varchar(50) DEFAULT NULL COMMENT '科目名称',
    60.   PRIMARY KEY (`id`)
    61. ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
    63. -- ----------------------------
    64. -- Records of subject_info
    65. -- ----------------------------
    66. INSERT INTO `subject_info` VALUES ('1', '语文');
    67. INSERT INTO `subject_info` VALUES ('2', '数学');
    68. INSERT INTO `subject_info` VALUES ('3', '英语');
    69. INSERT INTO `subject_info` VALUES ('4', '体育');
    70. INSERT INTO `subject_info` VALUES ('5', '音乐');
    72. -- 学生与科目关联表
    73. DROP TABLE IF EXISTS `subject_selection_info`;
    74. CREATE TABLE `subject_selection_info` (
    75.   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '索引ID',
    76.   `student_id` int(11) NOT NULL COMMENT '学生ID',
    77.   `subject_id` int(11) NOT NULL COMMENT '科目ID',
    78.   PRIMARY KEY (`id`),
    79.   KEY `subject_selection_info_stu_id` (`student_id`),
    80.   KEY `subject_selection_info_sub_id` (`subject_id`),
    81.   CONSTRAINT `subject_selection_info_stu_id` FOREIGN KEY (`student_id`) REFERENCES `student_info` (`id`),
    82.   CONSTRAINT `subject_selection_info_sub_id` FOREIGN KEY (`subject_id`) REFERENCES `subject_info` (`id`)
    83. ) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8;
    85. -- ----------------------------
    86. -- Records of subject_selection_info
    87. -- ----------------------------
    88. INSERT INTO `subject_selection_info` VALUES ('1', '1', '1');
    89. INSERT INTO `subject_selection_info` VALUES ('2', '1', '2');
    90. INSERT INTO `subject_selection_info` VALUES ('3', '1', '3');
    91. INSERT INTO `subject_selection_info` VALUES ('4', '1', '4');
    92. INSERT INTO `subject_selection_info` VALUES ('5', '2', '1');
    93. INSERT INTO `subject_selection_info` VALUES ('6', '2', '2');
    94. INSERT INTO `subject_selection_info` VALUES ('7', '2', '3');
    95. INSERT INTO `subject_selection_info` VALUES ('8', '2', '5');
    96. INSERT INTO `subject_selection_info` VALUES ('9', '3', '1');
    97. INSERT INTO `subject_selection_info` VALUES ('10', '3', '2');
    98. INSERT INTO `subject_selection_info` VALUES ('11', '3', '3');
  • 数据库ER图表
    watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70

数据库表映射对象

本文的所有对象均使用Lombok生成对象get set方法

  • 学生对象

    1. package com.lupf.springbootjpa.dbobject;
    3. import lombok.Data;
    4. import lombok.ToString;
    6. import javax.persistence.*;
    7. import java.io.Serializable;
    8. import java.util.List;
    10. @Data
    11. @Entity
    12. public class StudentInfo implements Serializable {
    13.     @Id
    14.     @GeneratedValue(strategy = GenerationType.IDENTITY)
    15.     private Integer id;
    16.     private String stuName;
    17.     private Integer stuSex;
    18.     private Integer stuAge;
    20.     //---------以下配置是为了方便查询学生信息的时候一并查询出其关联的信息
    22.     //由于学号及档案信息是一对一的关系，因此这里是一对一的
    23.     @OneToOne(cascade = CascadeType.ALL)
    24.     //name为当前表中列的名称  referencedColumnName标表示外键关联了对方的表内容
    25.     @JoinColumn(name = "stu_file_id", referencedColumnName = "id")
    26.     private FileInfo fileInfo;
    28.     //对于学生来说，是多个学生对应一个班级，因此这里是一对多的关系
    29.     //设置为CascadeType.MERGE时，当添加数据的时候，会自动插入class表中的数据
    30.     @ManyToOne(cascade = CascadeType.MERGE)
    31.     //name在表中的列
    32.     @JoinColumn(name = "stu_class_id", referencedColumnName = "id")
    33.     private ClassInfo classInfo;
    35.     //这里的fetch要使用EAGER(全部抓取)  LAZY懒加载会报错
    36.     //由于一个学生可以选择多个科目 因此这里相对与科目来说是一对多的关系
    37.     //设置为CascadeType.MERGE时，当添加数据的时候，会自动插入subject_selection_info表中的数据
    38.     @ManyToMany(cascade = CascadeType.MERGE, fetch = FetchType.EAGER)
    39.     //由于学生表和所选的科目表是使用subject_selection_info关联的  因此这里需要设置他们的关联关系
    40.     @JoinTable(name = "subject_selection_info", joinColumns = @JoinColumn(name = "student_id"), inverseJoinColumns = @JoinColumn(name = "subject_id"))
    41.     private List<SubjectInfo> subjectInfos;
    42. }

  • 科目对象

    1. package com.lupf.springbootjpa.dbobject;
    3. import com.alibaba.fastjson.annotation.JSONField;
    4. import lombok.Data;
    6. import javax.persistence.*;
    7. import java.io.Serializable;
    8. import java.util.List;
    10. @Data
    11. @Entity
    12. public class SubjectInfo implements Serializable {
    13.     @Id
    14.     @GeneratedValue(strategy = GenerationType.IDENTITY)
    15.     private Integer id;
    16.     private String subjectName;
    18.     //这里需要加上反序列化忽略，因为StudentInfo关联了SubjectInfo 这里又关联了StudentInfo
    19.     // 就出现了你中有我，我中有你的问题，从未导致反序列话的时候堆栈溢出(死循环)的问题
    20.     @JSONField(serialize = false)
    21.     //这里关联是为了满足，删除这里面的数据的时候，自动删除subject_selection_info并在学生与科目之间的关系
    22.     @ManyToMany(cascade = CascadeType.MERGE, fetch = FetchType.EAGER)
    23.     @JoinTable(name = "subject_selection_info", joinColumns = @JoinColumn(name = "subject_id"), inverseJoinColumns = @JoinColumn(name = "student_id"))
    24.     private List<StudentInfo> studentInfos;
    25. }

  • 班级对象

    1. package com.lupf.springbootjpa.dbobject;
    3. import lombok.Data;
    5. import javax.persistence.*;
    6. import java.util.List;
    7. import java.util.Objects;
    8. import java.util.Set;
    10. @Data
    11. @Entity
    12. public class ClassInfo {
    13.     @Id
    14.     @GeneratedValue(strategy = GenerationType.IDENTITY)
    15.     private Integer id;
    16.     @Column(insertable = false, updatable = false)
    17.     private String className;
    19. //    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    20. //    @JoinColumn(name = "id")
    21. //    private List<StudentInfo> studentInfos;
    22. }

  • 档案对象

    1. package com.lupf.springbootjpa.dbobject;
    3. import lombok.Data;
    5. import javax.persistence.*;
    6. import java.util.Objects;
    8. @Data
    9. @Entity
    10. public class FileInfo {
    11.     @Id
    12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
    13.     private Integer id;
    14.     private Integer fileId;
    15. }

  • 学生及科目关系映射对象

    1. package com.lupf.springbootjpa.dbobject;
    3. import lombok.Data;
    5. import javax.persistence.*;
    7. @Data
    8. @Entity
    9. public class SubjectSelectionInfo {
    10.     @Id
    11.     @GeneratedValue(strategy = GenerationType.IDENTITY)
    12.     private Integer id;
    14.     @Column(name = "student_id")
    15.     private Integer studentId;
    17.     @Column(name = "subject_id")
    18.     private Integer subjectId;
    20.     @ManyToOne(cascade = CascadeType.ALL)
    21.     //name在表中的列
    22.     @JoinColumn(name = "student_id", referencedColumnName = "id", insertable = false, updatable = false)
    23.     private StudentInfo studentInfo;
    25.     @ManyToOne(cascade = CascadeType.ALL)
    26.     //name在表中的列
    27.     @JoinColumn(name = "subject_id", referencedColumnName = "id", insertable = false, updatable = false)
    28.     private SubjectInfo subjectInfo;
    29. }

操作及测试

学生操作及测试

  • StudentRepository

    1. @Repository
    2. public interface StudentRepository extends JpaRepository<StudentInfo, Integer> {
    4.     //根据班级ID查询学生信息
    5.     @Query(value = "select a.* from student_info as a where stu_class_id = ?1", nativeQuery = true)
    6.     List<StudentInfo> findByStuClassId(Integer classId);
    7. }

  • StudentService

    1. package com.lupf.springbootjpa.service;
    3. import com.lupf.springbootjpa.dbobject.StudentInfo;
    5. import java.util.List;
    7. /**
    8.  * 学生的Service
    9.  */
    10. public interface StudentService {
    12.     //添加学生 并添加学生的档案信息、分班信息以及学生选择的科目
    13.     StudentInfo save(StudentInfo studentInfo);
    15.     //查询某个学生的信息
    16.     StudentInfo findById(Integer id);
    18.     //删除学生信息
    19.     void deleteById(Integer id);
    21.     //修改信息
    22.     StudentInfo update(StudentInfo studentInfo);
    24.     //根据班级名称查询学生信息
    25.     List<StudentInfo> findByStuClassId(Integer classId);
    26. }

  • StudentServiceImpl

    1. package com.lupf.springbootjpa.service.impl;
    3. import com.lupf.springbootjpa.dbobject.StudentInfo;
    4. import com.lupf.springbootjpa.repository.StudentRepository;
    5. import com.lupf.springbootjpa.service.StudentService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    9. import java.util.List;
    10. import java.util.Optional;
    12. @Service
    13. public class StudentServiceImpl implements StudentService {
    15.     @Autowired
    16.     StudentRepository studentRepository;
    18.     @Override
    19.     public StudentInfo findById(Integer id) {
    20.         Optional<StudentInfo> studentInfoOptional = studentRepository.findById(id);
    21.         if (null != studentInfoOptional && studentInfoOptional.isPresent())
    22.             return studentInfoOptional.get();
    23.         return null;
    24.     }
    26.     @Override
    27.     public void deleteById(Integer id) {
    28.         studentRepository.deleteById(id);
    29.     }
    31.     @Override
    32.     public StudentInfo update(StudentInfo studentInfo) {
    33.         return studentRepository.save(studentInfo);
    34.     }
    36.     @Override
    37.     public List<StudentInfo> findByStuClassId(Integer classId) {
    38.         List<StudentInfo> studentInfos = studentRepository.findByStuClassId(classId);
    39.         return studentInfos;
    40.     }
    42.     @Override
    43.     public StudentInfo save(StudentInfo studentInfo) {
    44.         StudentInfo saveStudentInfo = studentRepository.save(studentInfo);
    45.         return saveStudentInfo;
    46.     }
    47. }

  • 学生测试用例

    1. @RunWith(SpringRunner.class)
    2. @SpringBootTest
    3. @Slf4j
    4. public class StudentServiceImplTest {
    5.     @Autowired
    6.     StudentService studentService;
    8.     @Test
    9.     public void findById() {
    10.         //查询学生信息会一并查处用户所属的班级信息及选择的科目信息
    11.         StudentInfo studentInfo = studentService.findById(1);
    12.         log.info(JSON.toJSONString(studentInfo));
    13.     }
  1.         @Test
  2.         public void deleteById() {
  3.             //用户时会级联删除学生信息  学生档案信息  学生科目选择信息
  4.             studentService.deleteById(16);
  5.         }
  7.         @Test
  8.         public void update() {
  9.             StudentInfo studentInfo = studentService.findById(20);
  10.             studentInfo.setStuAge(8);
  11.             ClassInfo classInfo = new ClassInfo();
  12.             //这个classID必须在class_info表中存在，否则这里会报错
  13.             classInfo.setId(2);
  14.             studentInfo.setClassInfo(classInfo);
  15.             studentService.update(studentInfo);
  16.         }
  18.         @Test
  19.         public void save() {
  20.             StudentInfo studentInfo = new StudentInfo();
  21.             studentInfo.setStuAge(8);
  22.             studentInfo.setStuName("唐七");
  23.             studentInfo.setStuSex(1);
  25.             //级联更新 这里设置的id属性在添加学生信息的时候会一并将这部分数据添加到class_info表
  26.             ClassInfo classInfo = new ClassInfo();
  27.             //这个classID必须在class_info表中存在，否则这里会报错
  28.             classInfo.setId(2);
  29.             studentInfo.setClassInfo(classInfo);
  31.             //绑定并插入学生的用户信息
  32.             //这里是级联插入 添加的时候自动插入相关的档案信息
  33.             FileInfo fileInfo = new FileInfo();
  34.             fileInfo.setFileId(100004);
  35.             studentInfo.setFileInfo(fileInfo);
  37.             //级联更新学生选择的科目信息
  38.             //语文
  39.             SubjectInfo subjectInfo = new SubjectInfo();
  40.             //这里的ID必须在subject_info表中存在，否则这里会报错
  41.             subjectInfo.setId(1);
  42.             //数学
  43.             SubjectInfo subjectInfo2 = new SubjectInfo();
  44.             //这里的ID必须在subject_info表中存在，否则这里会报错
  45.             subjectInfo2.setId(2);
  46.             //英语
  47.             SubjectInfo subjectInfo3 = new SubjectInfo();
  48.             //这里的ID必须在subject_info表中存在，否则这里会报错
  49.             subjectInfo3.setId(3);
  51.             List<SubjectInfo> subjectInfos = new ArrayList<>();
  52.             subjectInfos.add(subjectInfo);
  53.             subjectInfos.add(subjectInfo2);
  54.             subjectInfos.add(subjectInfo3);
  56.             studentInfo.setSubjectInfos(subjectInfos);
  57.             studentService.save(studentInfo);
  58.         }
  60.         @Test
  61.         public void findByStuClassId() {
  62.             List<StudentInfo> s = studentService.findByStuClassId(2);
  63.             String va = JSON.toJSONString(s, SerializerFeature.DisableCircularReferenceDetect);
  64.             log.info(va);
  65.         }
  66.     }

  • 测试详情

    • 根据ID查询用户
      watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70 1
    • 插入测试
      下图可见，插入学生信息的时候，同步插入了档案信息、班级信息及选择科目的关联关系watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70 2
      20190319153642420.
      20190319153724670.
      20190319154030301.
  • 修改测试
    watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70 3
    20190319160204742.
  • 学生信息删除测试
    删除学生的时候会同步删除档案信息及学生管理的科目信息
    watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70 4
其他功能测试

其他对象为一些基础性的操作，没有什么特殊性，因此，这里就不占用篇幅，需要了解的可以下载源码查看。

常见问题

  • could not initialize proxy - no Session
    20190319160858885.
    由于对象中管理了其他的对象，因此这里使用懒加载会出现未找到session的问题，需要将LAZY改为EAGER
    20190319161025122.
  • java.lang.StackOverflowError
    为Json反序列化导致的堆栈溢出
    一般出现ManyToMany下，因为两个对象是你中有我，我中有你的关系，从而反序列化时导致递归堆栈溢出；
    解决方案：可以使用@JSONField(serialize = false)注解忽略对应对象的反序列化
    20190319161647563.

  • Multiple representations of the same entity […] are being merged. Detached: […]; Detached: […]; nested exception is java.lang.IllegalStateException: Multiple representations of the same entity […] are being merged. Detached: […]; Detached: […]
    更新修改的时候，合并对象的问题
    20190319162159804.
    以上示例为将用户从其他班调整到id为3的班级，可能会报以上的错
    解决方案:
    在application.yml中添加以下配置

    1. spring:
    2.   jpa:
    3.     show-sql: true
    4.     properties:
    5.       hibernate:
    6.         event:
    7.           merge:
    8.             entity_copy_observer: allow

总结

到此，使用JPA操作关联表已经完了，可以看出，使用JPA，我们只需要关注于业务流程，几乎不用、或者很少去关注数据库那边的操作，从手动档直接换成了自动档，从而让我们有更多的精力去写业务层那一块儿的代码。

发表评论

表情：
评论列表 （有 0 条评论，395人围观）

还没有评论，来说两句吧...

相关阅读