[增删改查] 最简单的 JPA 一对多/多对一 CRUD 设计

最新推荐文章于 2024-08-15 06:45:00 发布
最新推荐文章于 2024-08-15 06:45:00 发布
阅读量5.6k 收藏 15
点赞数 1
文章标签： mysql jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/larger5/article/details/79811192
版权

一、前言

1、之前写过很多 SpringBoot 使用 JPA 实现 dao 层的 CRUD：
[增删改查] SpringBoot+JPA+EasyUI+MySQL 基本 CURD
但基本都是单表的
2、而实际开发中，最常见的就是 一对多/多对一 的关系，
3、实现 JPA 多表的 CRUD 的方式主要有两种：
① 使另一个实体为另一个实体的属性，成对使用注解 @ManyToOne、@JoinColumn 就可以了，如：

    @ManyToOne
    @JoinColumn(name="webSiteId")
    private WebSite webSite; // 网站

② 另外一种就是，不使用上述的关系，直接绑定 Integer 类型的主外键即可，相对上面，简单多了，但是人为编写 Service/Controller 层 CRUD 容易出现逻辑不严谨的现象，下面会涉及到
如：

    @Column(name="department_id")
    private Integer departmentId; //学生的宿舍外键

二、代码

https://github.com/larger5/SpringBootJPA.git

1、代码结构

这里写图片描述

2、pom
①生成接口测试文档
        <!-- swagger生成接口API -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>

        <!-- 接口API生成html文档 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.6.1</version>
        </dependency>
②MySQL、JPA、web
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
3、yml 全局配置文件
server:
  port: 80 #为了以后访问项目不用写端口号
  context-path: / #为了以后访问项目不用写项目名
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8  #解决中文乱码的问题
    username: root
    password: 123
  jpa: 
    hibernate:
      ddl-auto: update  #数据库同步代码
    show-sql: true      #dao操作时，显示sql语句
4、实体
①学生
package com.cun.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "t_student")
public class Student {

    @Id
    @GeneratedValue
    private Integer id;

    @Column(length = 100,name="name")
    private String name;

    @Column(name="department_id")
    private Integer departmentId;

    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 Integer getDepartmentId() {
        return departmentId;
    }

    public void setDepartmentId(Integer departmentId) {
        this.departmentId = departmentId;
    }

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

}
②宿舍
package com.cun.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "t_department")
public class Department {

    @Id
    @GeneratedValue
    private Integer id;

    @Column(length = 100)
    private String name;

    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 Department() {
        super();
        // TODO Auto-generated constructor stub
    }

}
5、dao
①学生
package com.cun.dao;

import java.util.List;

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

import com.cun.entity.Student;

public interface StudentDao extends JpaRepository<Student, Integer> {
    @Query(value = "select * from t_student where department_id=?1", nativeQuery = true)
    List<Student> getStudentsByDepartmentId(Integer id);

}
②宿舍
package com.cun.dao;

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

import com.cun.entity.Department;

public interface DepartmentDao extends JpaRepository<Department, Integer> {

}
6、Controller
①学生
package com.cun.controller;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.cun.dao.DepartmentDao;
import com.cun.dao.StudentDao;
import com.cun.entity.Department;
import com.cun.entity.Student;

import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * 主 Student CRUD
 * ==>和单表的 CRUD 异同：
 *      ① insert（同）
 *      ② update（同）
 *      ③ delete（同）
 *      ④ select（异）：关联查询
 * @author linhongcun
 *
 */
@RestController
@RequestMapping("/student")
@EnableSwagger2
public class StudentController {

    @Autowired
    private StudentDao studentDao;

    @Autowired
    private DepartmentDao departmentDao;

    /**
     * 1、增
     * ①学生姓名
     * ②宿舍 id 
     * @param student
     */
    @PostMapping("/insert")
    public void insertStudent(Student student) {
        studentDao.save(student);
    }

    /**
     * 2、根据id获取一个学生信息（个人、宿舍）
     * @param id
     * @return
     */
    @GetMapping("/get/{id}")
    public Map<String, Object> getStudent(@PathVariable Integer id) {
        Map<String, Object> map = new HashMap<String, Object>();
        Student student = studentDao.findOne(id);
        // 这一步很关键
        Department department = departmentDao.findOne(student.getDepartmentId());
        map.put("student", student);
        map.put("department", department);
        return map;
    }

    /**
     * 3、删
     * @param id
     */
    @DeleteMapping("/delete/{id}")
    public void deleteStudentById(@PathVariable Integer id) {
        studentDao.delete(id);
    }

    /**
     * 4、改
     * @param student
     */
    @PutMapping("/update")
    public void updateStudent(Student student) {
        studentDao.save(student);
    }

    /**
     * 5、全
     * @return
     */
    @GetMapping("/all")
    public List<Map<String, Object>> getAllStudent() {
        List<Student> studentList = studentDao.findAll();
        List<Map<String, Object>> list=new ArrayList<Map<String, Object>>();
        for (int i = 0; i < studentList.size(); i++) {
            Map<String, Object> map1 = new HashMap<String, Object>();
            map1.put("student", studentList.get(i));
            map1.put("department", departmentDao.findOne(studentList.get(i).getDepartmentId()));
            list.add(map1);
        }
        return list;
    }

}
②宿舍
package com.cun.controller;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.cun.dao.DepartmentDao;
import com.cun.dao.StudentDao;
import com.cun.entity.Department;
import com.cun.entity.Student;

import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * 副 Department CRUD
 * ==>和单表简单的 CURD 的异同：
 *      ① delete（异）：有 id 作为 Student 的 departmentId 者不能删
 *      ② insert（同）
 *      ③ select（同）
 *      ④ update（同）
 * @author linhongcun
 *
 */
@EnableSwagger2
@RestController
@RequestMapping("/department")
public class DepartmentController {

    @Autowired
    private StudentDao studentDao;

    @Autowired
    private DepartmentDao departmentDao;

    /**
     * 1、增
     * @param department
     */
    @PostMapping("/insert")
    public void insertDepartment(Department department) {
        departmentDao.save(department);
    }

    /**
     * 2、改
     * @param department
     */
    @PutMapping("/update")
    public void updateDepartment(Department department) {
        departmentDao.save(department);
    }

    /**
     * 3、删（优化）
     * @param id
     * @return 
     */
    @DeleteMapping("/delete/{id}")
    public Map<String, Object> deleteDepartment(@PathVariable Integer id) {
        Map<String, Object> map = new HashMap<String, Object>();
        // 以下两步很关键
        List<Student> studentsByDepartmentId = studentDao.getStudentsByDepartmentId(id);
        if (studentsByDepartmentId.size() == 0) {
            departmentDao.delete(id);
            map.put("status", true);
        } else {
            map.put("status", false);
        }
        return map;
    }

    /**
     * 4、全
     * @return
     */
    @GetMapping("/all")
    public List<Department> getAllDepartment() {
        return departmentDao.findAll();
    }

    /**
     * 5、查
     * @param id
     * @return
     */
    @GetMapping("/get/{id}")
    public Department getDepartmentById(@PathVariable Integer id) {
        return departmentDao.findOne(id);
    }
}

三、其他

1、Swagger 接口

这里写图片描述

IT小村
关注
基于Java的泛型和反射实现通用的增删改查(2)——通用增删改查操作的底层设计
如不來的博客
12-23 1385
一、设计理念  在互联网项目或者其他传统Web项目的开发过程中，对数据库的操作可以说是项目的核心和根本，而数据库操作无非就是增删改查，而对所有表的增删改查操作都大同小异，非常相似。如果我们能够将对单表的增删改查操作抽象出来放在父类中去实现，让所有的子类继承这个已实现了增删改查操作的父类，那么我们的工作效率无疑会大大地提升，也会使我们从这些简单无聊但又不得不去做的工作中解脱出来，将有限的精力投入到较...
SpringDataJpa 一对多表关系，映射对象CRUD
guohao_Kwok的博客
04-07 306
面试：你懂什么是分布式系统吗？Redis分布式锁都不会？>>> ...
JPA开发(下)一(多)对多的配置与crud操作
CSDN
06-18 1038
1 一对多案例(部门与员工) 1.1 实体类注解 1.2 级联添加、级联更新与级联删除 2 多对多案例(学生与教师) 2.1 实体类注解 2.2 级联添加、级联删除与级联更新 3 多表查询 资源下载 更多JPA在框架开发 1 一对多案例(部门与员工) 1.1 实体类注解 package edu.kmust.entity; import java....
深入理解JPA注解：从基础到高级
最新发布
xycxycooo的博客
08-15 905
JPA是Java EE 5规范中引入的一种ORM技术，旨在简化Java应用程序与关系型数据库之间的交互。JPA提供了一套标准的API和注解，使得开发者可以专注于业务逻辑，而不必过多关注底层数据库操作。JPA支持自定义类型映射，可以通过@Converter注解实现。"Y" : "N";} }Entity;"Y" : "N";} }Id;"Y" : "N";} }Convert;
[增删改查] 最规范的 JPA 一对多/多对一 CRUD 示例
IT小村
04-04 8033
一、前言 1、多对一，一对多，都是一样的，反过来了而已。 2、之前写过一篇不使用主外键关系的多表 CRUD： [增删改查] 最简单的 JPA 一对多/多对一 CRUD 设计 虽可以帮助新手快速使用 JPA，但是这样是不严谨的，特别是记录的删除，有了主外键关系就不会让你随意删除了。 3、其实，规范使用 JPA，还是很简单的。 二、代码 talk is cheap show me th...
java中基于Jpa的单向多对一的CRUD功能实现以及代码的抽取简化
weixin_30847271的博客
03-06 112
首先配置好persistence.xml <?xml version="1.0" encoding="UTF-8"?> <persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0"> <persistence-unit name="myjpa" transact...
JPA实现CURD
起舞的日子
04-06 2562
话说： 生活中离不开吃喝玩乐，代码世界自然离不开CURD。到现在为止，我也觉得CURD蛮好的，很多东西不都是建立在基础之上的么。 目录 1.创建JPA工程 2.基本注解解释 3.实现CURD 4.总结 开发工具：Eclipse 难度系数：★★☆☆☆ 建议用时：1H 1.创建JPA工程 Eclipse==》new Project ==&gt;new JPA Proje...
前端向后端进发之----Springboot JPA增删改查
moqiuqin的博客
07-24 740
写在前面 如题，这里只是个人的学习理解过程，不是专业的后端，一些概念知识难免说的不对，请自行斟酌。写完这篇争取在写一遍mybatis (。＿ 。） ✎＿。 这里不截图相关的代码了，不太好弄，只是介绍一些要用到的概念，要结合demo来看，是前后分离的，前端用vue，demo地址点这里，demo里有些是使用原生sql，主要是为了学习，其实springboot jpa都能实现，另外jpa还是有很多东西要学的，这里都只是入门而已。 在了解了jpa的概念之后，突然觉得一个好的框架真的能省下来不少麻烦事，这也是一个框架
Springboot增删改查MySQL
06-26
增删改查操作通常涉及到数据库表中的数据，因此我们需要创建一个Java实体类来映射数据库表。例如，如果有一个名为`User`的表，我们可以创建一个`User`类，包含与表字段相对应的属性和getter/setter方法。 ```java...
spring3 + hibernate3 实现用户的增删改查
10-05
在Spring中，创建一个Service接口（如`UserService.java`）来声明增删改查的方法，并实现该接口（如`UserServiceImpl.java`）。Service层是业务逻辑的处理中心，它调用DAO（数据访问对象）来与数据库交互。DAO接口...
Spring Boot入门(08)：如何用Spring Boot和MyBatis实现高效MySQL增删改查操作？
热门推荐
**My Coding Family**
08-24 1万+
Spring Boot是一款非常流行的Java开发框架，MyBatis是一款高效的数据库操作框架，二者结合可以实现快速、高效的MySQL增删改查操作。本文将介绍如何通过Spring Boot和MyBatis搭建一个简单的MySQL增删改查示例，涉及基本的CRUD操作、事务管理和数据分页等内容，有助于Java开发者快速掌握这两个框架的用法，提高开发效率和代码质量。
jpa的自定义CURD
07-26
jpa的自定义CURD,简单易懂。
Jpa的创建和增删改查的代码
07-27
就是JPA的代码
spring boot项目中使用Jpa对mySql数据库进行CURD操作
09-07
本资源使用jpa对数据库进行操作，无需使用一句sql语言就可以实现对数据库的增删改查操作，方便使用，对于spring boot初学者很有帮助！
Spring JPA CURD
console_log_LGA的博客
11-01 316
1 概述 Spring Data JPA是一个框架，对 Java Persistence API 进行再次封装。 Java Persistence API 是Java EE中的规范，它的实现产品有最有名的如Hibernate、Eclipse Link等，都是ORM框架。而ORM的本质是对JDBC进行了封装。ORM可以让程序员以OO的思维来操作关系数据库。 使用Spring Data JPA有以下优...
【hibernate框架】一对多(多对一)双向CRUD-关于delete2
weixin_33971205的博客
02-20 92
如果没有关联关系，平常我们使用save、get、update、delete方法即可对实体对象进行增删改查，但是一旦实体对象有关联关系的时候，就不能直接使用save、get、update、delete方法了，就要进行一系列的语句拆分和组合。 牵扯到对一个实体对象做操作，是否要对关联的另外一个实体对象做操作。 这里来探讨一下删除delete“多对一”中“多...
03 JPA的CURD
仙贝儿
09-17 92
常用的API Find：根据id查询 @Test public void testFind() { //1、通过工具类获取entityManager EntityManager entityManager = JpaUtils.getEntityManagerFactory(); //2、开启事物 EntityTransaction entityTransacti...
基于注解的Hibernate JPA操作CRUD（单表、一对多和多对多）
qq_22339269的博客
11-19 544
0.maven引入相关依赖资源 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http:
JPA 的 基本CURD
wt122694的博客
07-25 536
  1. persist()保存对象，相当于 Hibernate中的save()方法,但是不能有ID 2. remove() 删除，不能删除游离态对象 3. find() 查询，相当于Hibernate中的get(),立即查询 4. getReference()查询，相当于Hibernate中的load(),懒加载         5.setXXX(...) 更新 6. me...
spring boot+jpa写一个一对多的增删改查
03-20
好的，以下是 Spring Boot JPA 实现一对多增删改查的示例代码： 1. 创建实体类 ``` @Entity public class Parent { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

IT小村

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值