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

下面是“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 数据模型关联使用操作（一对一、一对多、多对多）”的完整攻略。