1. Python技术站首页
  2. 其他
  3. Java

Spring Boot 整合JPA 数据模型关联使用操作(一对一、一对多、多对多)

• Java

下面是“Spring Boot 整合 JPA 数据模型关联使用操作（一对一、一对多、多对多）”的完整攻略。

简介

在讲解具体的操作步骤之前，我们需要先了解一些基础知识。

JPA

JPA，全称为 Java Persistence API，即 Java 持久化 API，是 Java EE 技术的一部分，是一种轻量级的 Java ORM 框架，主要是作为 Hibernate、TopLink 等 ORM 框架的规范。

数据模型关联

在开发实际应用时，一个实体类往往不是孤立地存在，它需要与其他实体类产生联系，这些联系被称为数据模型关联。常见的数据模型关联有以下几种：

  • 一对一：表示两个实体类之间的关系是一对一的，例如，“一张学生证对应一个学生”。
  • 一对多：表示一个实体类有多个相同类型的实体类与之关联，例如，“一个部门对应多个员工”。
  • 多对多：表示两个实体类之间的关系是多对多的，例如，“一个学生可以选择多门课程，一门课程可以被多个学生选择”。

Spring Boot

Spring Boot 是一个快速开发的框架，不需要进行繁琐的配置，体现了“约定优于配置”的思想。使用 Spring Boot 可以快速构建 Web 应用程序。

一对一关系

在 JPA 中，可以通过 @OneToOne 注解实现一对一关系。

创建实体类

我们以一个学生证实体类和一个学生实体类为例，来演示一对一关系。首先需要创建两个实体类，代码如下：

@Data
@Entity
@Table(name = "tb_student_card")
public class StudentCard {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "card_number")
    private String cardNumber;

    @OneToOne(mappedBy="studentCard")
    private Student student;
}

@Data
@Entity
@Table(name = "tb_student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name="card_id", referencedColumnName="id")
    private StudentCard studentCard;
}

上述实体类中，@OneToOne 注解表示了这两个实体类之间的一对一关系，其中 Student 实体类中的 @JoinColumn 注解表示了与 StudentCard 实体类之间的关联关系，通过该注解可以指定外键对应的字段。

创建 DAO 层

  1. 创建继承 JpaRepository 的 StudentDao 和 StudentCardDao 接口：

```java
public interface StudentDao extends JpaRepository{}

public interface StudentCardDao extends JpaRepository{}
```

  1. 在 Service 层中进行业务操作：

```java
@Service
public class StudentService {
@Autowired
private StudentDao studentDao;
@Autowired
private StudentCardDao studentCardDao;

 public void saveStudent(Student student) {
   studentDao.save(student);
 }

 public void saveStudentCard(StudentCard studentCard) {
   studentCardDao.save(studentCard);
 }

 public void deleteStudent(Long id) {
   studentDao.deleteById(id);
 }

 public void deleteStudentCard(Long id) {
   studentCardDao.deleteById(id);
 }

}
```

创建 Controller 层

  1. 在 Controller 中调用 Service 层方法进行业务操作：

```java
@RestController
@RequestMapping("/student")
public class StudentController {
@Autowired
private StudentService studentService;

 @PostMapping("/saveStudent")
 public void saveStudent(@RequestBody Student student) {
   studentService.saveStudent(student);
 }

 @PostMapping("/saveStudentCard")
 public void saveStudentCard(@RequestBody StudentCard studentCard) {
   studentService.saveStudentCard(studentCard);
 }

 @DeleteMapping("/deleteStudent/{id}")
 public void deleteStudent(@PathVariable Long id) {
   studentService.deleteStudent(id);
 }

 @DeleteMapping("/deleteStudentCard/{id}")
 public void deleteStudentCard(@PathVariable Long id) {
   studentService.deleteStudentCard(id);
 }

}
```

至此，我们已经完成了一对一关系的实现。

一对多关系

在 JPA 中，可以通过 @OneToMany 和 @ManyToOne 注解实现一对多关系。

创建实体类

我们以一个部门实体类和一个员工实体类为例，来演示一对多关系。需要创建两个实体类，代码如下：

@Data
@Entity
@Table(name = "tb_department")
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @OneToMany(mappedBy = "department")
    private List<Employee> employees;
}

@Data
@Entity
@Table(name = "tb_employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "job")
    private String job;

    @ManyToOne(targetEntity = Department.class)
    @JoinColumn(name = "dept_id")
    private Department department;
}

上述实体类中，@OneToMany 注解表示了 Department 实体类和 Employee 实体类之间的一对多关系，其中 mappedBy 属性指定了关联关系的另一端属性名，是 Employee 实体类中的 department 对应的属性。@ManyToOne 注解表示了 Employee 实体类和 Department 实体类之间的多对一关系。

创建 DAO 层

创建继承 JpaRepository 的 DepartmentDao 和 EmployeeDao 接口：

public interface DepartmentDao extends JpaRepository<Department, Long>{}

public interface EmployeeDao extends JpaRepository<Employee, Long>{}

在 Service 层中进行业务操作：

@Service
public class EmployeeService {
  @Autowired
  private DepartmentDao departmentDao;
  @Autowired
  private EmployeeDao employeeDao;

  public void saveDepartment(Department department) {
    departmentDao.save(department);
  }

  public void saveEmployee(Employee employee) {
    employeeDao.save(employee);
  }

  public void deleteDepartment(Long id) {
    departmentDao.deleteById(id);
  }

  public void deleteEmployee(Long id) {
    employeeDao.deleteById(id);
  }
}

创建 Controller 层

在 Controller 中调用 Service 层方法进行业务操作：

@RestController
@RequestMapping("/employee")
public class EmployeeController {
  @Autowired
  private EmployeeService employeeService;

  @PostMapping("/saveDepartment")
  public void saveDepartment(@RequestBody Department department) {
    employeeService.saveDepartment(department);
  }

  @PostMapping("/saveEmployee")
  public void saveEmployee(@RequestBody Employee employee) {
    employeeService.saveEmployee(employee);
  }

  @DeleteMapping("/deleteDepartment/{id}")
  public void deleteDepartment(@PathVariable Long id) {
    employeeService.deleteDepartment(id);
  }

  @DeleteMapping("/deleteEmployee/{id}")
  public void deleteEmployee(@PathVariable Long id) {
    employeeService.deleteEmployee(id);
  }
}

至此，我们已经完成了一对多关系的实现。

多对多关系

在 JPA 中，可以通过 @ManyToMany 注解实现多对多关系。

创建实体类

我们以一个课程实体类和一个学生实体类为例，来演示多对多关系。需要创建两个实体类，代码如下：

@Data
@Entity
@Table(name = "tb_course")
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @ManyToMany
    @JoinTable(name = "tb_course_student", joinColumns = @JoinColumn(name = "course_id"), inverseJoinColumns = @JoinColumn(name = "student_id"))
    private List<Student> students;
}

@Data
@Entity
@Table(name = "tb_student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private Integer age;

    @ManyToMany(mappedBy = "students")
    private List<Course> courses;
}

上述实体类中，@ManyToMany 注解表示了 Course 实体类和 Student 实体类之间的多对多关系，其中 @JoinTable 注解指定了关联关系的数据表名称，joinColumns 属性指定了与 Course 实体类关联的数据表中的字段，inverseJoinColumns 属性指定了与 Student 实体类关联的数据表中的字段。@ManyToMany 注解需要在双方实体类中都定义，并且在一方定义 mappedBy 属性。

创建 DAO 层

创建继承 JpaRepository 的 CourseDao 和 StudentDao 接口：

public interface CourseDao extends JpaRepository<Course, Long>{}

public interface StudentDao extends JpaRepository<Student, Long>{}

在 Service 层中进行业务操作：

@Service
public class CourseService {
  @Autowired
  private CourseDao courseDao;
  @Autowired
  private StudentDao studentDao;

  public void saveCourse(Course course) {
    courseDao.save(course);
  }

  public void saveStudent(Student student) {
    studentDao.save(student);
  }

  public void deleteCourse(Long id) {
    courseDao.deleteById(id);
  }

  public void deleteStudent(Long id) {
    studentDao.deleteById(id);
  }
}

创建 Controller 层

在 Controller 中调用 Service 层方法进行业务操作：

@RestController
@RequestMapping("/course")
public class CourseController {
  @Autowired
  private CourseService courseService;

  @PostMapping("/saveCourse")
  public void saveCourse(@RequestBody Course course) {
    courseService.saveCourse(course);
  }

  @PostMapping("/saveStudent")
  public void saveStudent(@RequestBody Student student) {
    courseService.saveStudent(student);
  }

  @DeleteMapping("/deleteCourse/{id}")
  public void deleteCourse(@PathVariable Long id) {
    courseService.deleteCourse(id);
  }

  @DeleteMapping("/deleteStudent/{id}")
  public void deleteStudent(@PathVariable Long id) {
    courseService.deleteStudent(id);
  }
}

至此，我们已经完成了多对多关系的实现。

以上就是关于“Spring Boot 整合 JPA 数据模型关联使用操作（一对一、一对多、多对多）”的完整攻略。

阅读剩余 87%

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Spring Boot 整合JPA 数据模型关联使用操作(一对一、一对多、多对多) - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月20日
下一篇 2023年5月20日

相关文章

  • 浅谈Mysql大数据分页查询解决方案

    首先我们需要了解什么是大数据分页查询。当一个数据表记录非常多时，如果需要一次性查询出所有数据，在性能和效率上都会产生很大的压力，因此需要进行数据分页查询。而Mysql是一款非常流行的数据库，支持分页查询操作，但在大数据量下，Mysql的分页查询会带来性能和效率的问题。 那么如何解决Mysql的大数据分页查询问题呢？以下是一些实用的方法。 1.使用Limit分…

    Java 2023年6月15日
    00

  • Springboot通用mapper和mybatis-generator代码示例

    下面是关于“Springboot通用mapper和mybatis-generator代码示例”的完整攻略： 一、什么是Springboot通用mapper和mybatis-generator 1. Springboot通用mapper Springboot通用mapper是一款能够提高数据访问的工具，主要用于深度整合Mybatis和Spring Data J…

    Java 2023年5月20日
    00

  • Mybatis表的关联查询详情

    您想了解“Mybatis表的关联查询详情”的完整攻略，以下是详细介绍。 Mybatis表的关联查询详情 在实际开发中，一个业务往往需要从多张表中查询数据并进行关联，这时候就需要使用表的关联查询。在 Mybatis 中，我们通常使用 XML 映射文件来实现表的关联查询。 一对一关联查询 一对一关联查询就是在两张表中建立一个一对一的关系，并且查询的两张表有主从关…

    Java 2023年5月20日
    00

  • java实现两个对象之间传值及简单的封装

    下面是详细讲解“java实现两个对象之间传值及简单的封装”的完整攻略。 什么是对象间传值 在 Java 中，变量本身是没有值的，它只是指向内存中存储数据的位置，也就是说，对象间传值其实就是将一个对象中的数据（值）赋值给另一个对象，使它们拥有相同的数据。 简单的封装 Java 中的封装是将数据和操作数据的方法(行为)包装在一起，对数据的访问进行限制，使其不能随…

    Java 2023年5月26日
    00

  • 从JVM的内存管理角度分析Java的GC垃圾回收机制

    从JVM的内存管理角度分析Java的GC垃圾回收机制的完整攻略如下： 1. 垃圾回收机制的概念 Java垃圾回收机制是JVM一项非常重要的特性，主要用于自动管理Java程序运行时的内存分配与回收。Java程序在执行过程中会不断地动态分配内存，而程序员要考虑如何处理分配的内存，在不再需要使用时及时释放内存。Java的垃圾回收机制极大地方便了程序员的编程，不用考…

    Java 2023年5月20日
    00

  • Java多线程实例

    Java多线程实例攻略 Java多线程是Java的一大特性，它可以使程序在运行时同时执行多个任务，提高了程序的效率。在本篇文章中，我们将讲述Java多线程的实例及使用方法，包含以下主题： Java多线程基本概念 Java多线程创建方式 Java多线程共享变量及协调执行 多线程应用——生产者和消费者模型 1. Java多线程基本概念 在Java中，一个程序可以…

    Java 2023年5月30日
    00

  • Midjourney：一步一步教你如何使用 AI 绘画 MJ

    一步一步如何使用 Midjourney 教程：教学怎么用 MJ？ 一、Midjourney（MJ）是什么？ Midjourney是一款使用文字描述来生成高质量图像的AI绘画工具。这篇文章主要介绍了Midjourney及其用途，并针对Midjourney的使用提供了一些指南。该工具可以帮助人们更快速、更容易地创建图像。 与市场上的其他AI绘画工具相比，Midj…

    Java 2023年4月22日
    00

  • Java NegativeArraySizeException异常解决方案

    我将为您讲解解决“Java NegativeArraySizeException异常”的完整攻略。 什么是NegativeArraySizeException异常？ 首先，我们需要了解一下NegativeArraySizeException异常。它是Java中的一种运行时异常，当我们使用负数作为数组大小时，就会抛出这个异常。 解决方案 要解决Negative…

    Java 2023年5月27日
    00
合作推广
合作推广
分享本页
返回顶部