springdatajpa处理表间关系

最新推荐文章于 2020-12-07 18:03:37 发布
最新推荐文章于 2020-12-07 18:03:37 发布
阅读量401 收藏 2
点赞数
分类专栏： springdatajpa 文章标签： springdatajpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43216437/article/details/110498097
版权

springdatajpa处理表间关系

表间关系

一对一：一对多的特殊情况

一对多：
一的一方：主表，
多的一方：从表，
外键：需要从表上新建一列作为主键，它的取值来源于主表的主键(一的一端)

多对多：
中间表：中间表中最少应该由两个字段组成，这两个字作为外键指向两张表的主键,又组成了联合主键
在这里插入图片描述

实体类的关系

包含关系：可以通过包含关系描述表间关系
继承关系

分析步骤

1、明确表关系
2、确定表关系(描述 外键|中间表)
3、编写实体类，在实体类中描述表关系(包含关系)
4、配置映射关系

案例分析

一对多关系和多对一双向关系

分析案例：
1、明确表关系：一对多关系
2、确定表关系(描述 外键中间表) 主表：用户表 从表：订单表 在从表上添加外键
3、编写实体类：在实体类中描述表关系(包含关系)；用户：在用户实体类中包含一个订单的集合；订单：在订单实体中包含一个用户的对象
4、配置映射关系：使用jpa注解配置一对多映射关系(难点)

  • person.java

//配置用户和订单之间一对多的关系
/*
* 使用注解的形式配置多表关系
* 1、声明关系
* @OneToMany(targetEntity = Orders.class)
* targetEntity:对方对象的字节码
* 2、配置外键(中间表)
* @JoinColumn(name = “person_id”,referencedColumnName = “person_id”)
* name:外键字段名称
* referencedColumnName：参照的主表的主键字段名称
*
* 在用户实体类上(主表一的一方)添加了外键配置，所以对于客户而言，也具备了维护外键的作用
* */

@Entity
@Data
@Table(name = "person")
public class Person {
    @Id
    @Column(name = "person_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer personId;
    @Basic
    @Column(name = "name")
    private String name;
    @Basic
    @Column(name = "gender")
    private Integer gender;
    @Basic
    @Column(name = "person_addr")
    private String personAddr;
    @Basic
    @Column(name = "birthday")
    private Date birthday;
    //配置用户和订单之间一对多的关系
    /*
    * 使用注解的形式配置多表关系
    * 1、声明关系
    *  @OneToMany(targetEntity = Orders.class)
    *  targetEntity:对方对象的字节码
    * 2、配置外键(中间表)
    * @JoinColumn(name = "person_id",referencedColumnName = "person_id")
    * name:外键字段名称
    * referencedColumnName：参照的主表的主键字段名称
    *
    * 在用户实体类上(主表一的一方)添加了外键配置，所以对于客户而言，也具备了维护外键的作用
    * */
    @OneToMany(targetEntity = Orders.class)
    @JoinColumn(name = "person_id",referencedColumnName = "person_id")
    private Set<Orders> orders=new HashSet<>();
}
  • orders.java

一定要把从表的主键给删除掉(一点要删除掉，不然会报Repeated column in mapping for entity: com.jpa.model.Orders column: person_id (should be mapped with insert=“false” update=“false”)的错误)

//配置orders和person之间多对一的关系
/*
*使用注解的形式配置多对一
* 1、声明表关系
* @ManyToOne(targetEntity =Person.class)
* targetEntity:对方对象的字节码
* 2、配置外键(多对多使用中间表来配置)
* 配置到了多的一方，就在多的一方维护外键
* */

@Entity
@Data
@Table(name = "orders")
public class Orders {
    @Id
    @Column(name = "order_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer orderId;
//    @Basic
//    @Column(name = "person_id")
//    private Integer personId;
    @Basic
    @Column(name = "total_price")
    private Double totalPrice;
    @Basic
    @Column(name = "address")
    private String address;
    //配置orders和person之间多对一的关系
    /*
    *使用注解的形式配置多对一
    * 1、声明表关系
    *   @ManyToOne(targetEntity =Person.class)
    *   targetEntity:对方对象的字节码
    * 2、配置外键(多对多使用中间表来配置)
    *   配置到了多的一方，就在多的一方维护外键
    * */
    @ManyToOne(targetEntity =Person.class)
    @JoinColumn(name = "person_id",referencedColumnName = "person_id")
    private Person person;
}
  • 测试类

先保存一的一端在保存多的一端

//保存一个客户一个联系人
    /*
    * 效果：用户和订单作为独立的数据保存到数据库中
    * 订单的外键为空
    * 原因是实体类中没有配置关系
    * */
    @Test
    @Transactional
    @Rollback(value = false)
    public void testAdd(){
        //创建一个用户和一个订单
        Person person = new Person();
        person.setName("张豆豆");
        person.setPersonAddr("河南");
        person.setBirthday(new Date());
        person.setGender(0);
        Orders orders = new Orders();

        orders.setAddress("天水");
        orders.setTotalPrice(548.0);
        //将用户表和订单表联系起来( //将球员加到球队)
        //从用户的角度看，发送两条insert语句，发送一条更新语句更新数据库(更新外键)
        //由于我们配置了用户到订单的关系，用户可以对主键进行维护
        person.getOrders().add(orders);
        
        //放弃主键维护的方式进行关联(配置订单到用户的关系[多对一的关系])
        orders.setPerson(person);//这种方式级联不起作用

        personDao.save(person);
        ordersDao.save(orders);
    }

测试一对多查询和多对一查询

测试一对多查询和多对一查询必须是单向关联的绝对不能多向关联

  • person 对orders 一对多 person表作为主表，orders表作为从表
  • Person.java
@Data
@Entity
@Table(name = "person")
public class Person {
    @Id
    @Column(name = "person_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer personId;
    @Basic
    @Column(name = "name")
    private String name;
    @Basic
    @Column(name = "gender")
    private Integer gender;
    @Basic
    @Column(name = "person_addr")
    private String personAddr;
    @Basic
    @Column(name = "birthday")
    private Date birthday;
    //配置用户和订单之间一对多的关系
    /*
    * 使用注解的形式配置多表关系
    * 1、声明关系
    *  @OneToMany(targetEntity = Orders.class)
    *  targetEntity:对方对象的字节码
    * 2、配置外键(中间表)
    * @JoinColumn(name = "person_id",referencedColumnName = "person_id")
    * name:外键字段名称
    * referencedColumnName：参照的主表的主键字段名称
    *
    * 在用户实体类上(主表一的一方)添加了外键配置，所以对于客户而言，也具备了维护外键的作用
    * */
    @OneToMany(targetEntity = Orders.class,fetch = FetchType.EAGER)
    @JoinColumn(name = "person_id",referencedColumnName = "person_id")
    private Set<Orders> orders=new HashSet<>();
}

fetch = FetchType.EAGER一定要加上急加载

  • 测试代码
 @Test
    public void testgetOrder(){
        Person person = personDao.findOne(1);
        System.out.println(person);
        Set<Orders> ordersSet = person.getOrders();
        ordersSet.forEach(orders -> System.out.println(orders));
    }
  • Orders.java
@Data
@Entity
@Table(name = "orders")
public class Orders {
    @Id
    @Column(name = "order_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer orderId;
//    @Basic
//    @Column(name = "person_id")
//    private Integer personId;
    @Basic
    @Column(name = "total_price")
    private Double totalPrice;
    @Basic
    @Column(name = "address")
    private String address;
    //配置orders和person之间多对一的关系
    /*
    *使用注解的形式配置多对一
    * 1、声明表关系
    *   @ManyToOne(targetEntity =Person.class)
    *   targetEntity:对方对象的字节码
    * 2、配置外键(多对多使用中间表来配置)
    *   配置到了多的一方，就在多的一方维护外键
    * */
    @ManyToOne(targetEntity =Person.class,fetch = FetchType.EAGER)
    @JoinColumn(name = "person_id",referencedColumnName = "person_id")
    private Person person;
}
  • 示例代码
 @Test
    public void testgetOrder(){
        Orders orders = ordersDao.findOne(7);
        System.out.println(orders.getPerson());
    }

一对多删除的说明和级联的引入

级联是对主表也就是一的一端来说的，所以相关的配置也在一的一端

  • 删除说明
    在这里插入图片描述

级联：操作一个对象的同时操作其他的关联对象；级联有级联添加和级联删除
级联添加：比如添加一个用户的同时添加一个订单
级联删除：比如删除用户的同时，在从表中删除该用户的所有订单

级联操作：
需要区分操作主体
需要在操作主体的实体类上，添加级联属性(需要添加到多表映射关系的注解上)
casecade(配置级联)

  • 级联添加
  • Person.java
@Data
@Entity
@Table(name = "person")
public class Person {
    @Id
    @Column(name = "person_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer personId;
    @Basic
    @Column(name = "name")
    private String name;
    @Basic
    @Column(name = "gender")
    private Integer gender;
    @Basic
    @Column(name = "person_addr")
    private String personAddr;
    @Basic
    @Column(name = "birthday")
    private Date birthday;
    //配置用户和订单之间一对多的关系
    /*
    * 使用注解的形式配置多表关系
    * 1、声明关系
    *  @OneToMany(targetEntity = Orders.class)
    *  targetEntity:对方对象的字节码
    * 2、配置外键(中间表)
    * @JoinColumn(name = "person_id",referencedColumnName = "person_id")
    * name:外键字段名称
    * referencedColumnName：参照的主表的主键字段名称
    *
    * 在用户实体类上(主表一的一方)添加了外键配置，所以对于客户而言，也具备了维护外键的作用
    * */
    @OneToMany(targetEntity = Orders.class,fetch = FetchType.EAGER,cascade =CascadeType.ALL)
    @JoinColumn(name = "person_id",referencedColumnName = "person_id")
    private Set<Orders> orders=new HashSet<>();
}
  • Orders.java
@Data
@Entity
@Table(name = "orders")
public class Orders {
    @Id
    @Column(name = "order_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer orderId;
//    @Basic
//    @Column(name = "person_id")
//    private Integer personId;
    @Basic
    @Column(name = "total_price")
    private Double totalPrice;
    @Basic
    @Column(name = "address")
    private String address;
    //配置orders和person之间多对一的关系
    /*
    *使用注解的形式配置多对一
    * 1、声明表关系
    *   @ManyToOne(targetEntity =Person.class)
    *   targetEntity:对方对象的字节码
    * 2、配置外键(多对多使用中间表来配置)
    *   配置到了多的一方，就在多的一方维护外键
    * */
    @ManyToOne(targetEntity =Person.class,fetch = FetchType.EAGER)
    @JoinColumn(name = "person_id",referencedColumnName = "person_id")
    private Person person;
}
  • 级联添加测试类
/*
    * 级联添加：保存一个用户的同时，保存用户的订单
    * */
    @Test
    @Transactional
    @Rollback(false)
    public void testCasecade(){
        Person person = new Person();
        person.setName("石破天");
        person.setGender(1);
        person.setBirthday(new Date());
        person.setPersonAddr("侠客岛");

        Orders orders = new Orders();
        orders.setAddress("中原");
        orders.setTotalPrice(56.25);
        person.getOrders().add(orders);//必须使用这种主键维护的方式级联添加才起作用

        personDao.save(person);
    }
  • 级联删除测试类
/*
     * 级联删除：删除一个用户的同时，删除用户的订单
     * */
    @Test
    @Transactional
    @Rollback(false)
    public void testCasecadeDelete(){
        Person person = personDao.findOne(3);
        personDao.delete(person);
    }

CasecadeType all ：所有
MERGE ：更新
PERSIST ：保存
REMOVE ：删除

多对多关系

  • 分析
    在这里插入图片描述

Person.java

@ManyToMany(targetEntity = Role.class,fetch = FetchType.EAGER)
@JoinTable(name = “person_role”,
joinColumns = {@JoinColumn(name = “person_id”,referencedColumnName = “person_id”)},
inverseJoinColumns = {@JoinColumn(name = “role_id”,referencedColumnName = “role_id”)})

@Data
@Entity
@Table(name = "person")
public class Person {
    @Id
    @Column(name = "person_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer personId;
    @Basic
    @Column(name = "name")
    private String name;
    @Basic
    @Column(name = "gender")
    private Integer gender;
    @Basic
    @Column(name = "person_addr")
    private String personAddr;
    @Basic
    @Column(name = "birthday")
    private Date birthday;
    //配置和角色多对多关系
    /*
    *1、声明表关系的配置
    * targetEntity:对方对象的字节码
    * 2、配置中间表
    * joinColumns：当前对象在中间表中的外键
    * inverseJoinColumns：对方对象在中间表中的外键
    * */
    @ManyToMany(targetEntity = Role.class,fetch = FetchType.EAGER)
    @JoinTable(name = "person_role",
            joinColumns = {@JoinColumn(name = "person_id",referencedColumnName = "person_id")},
            inverseJoinColumns = {@JoinColumn(name = "role_id",referencedColumnName = "role_id")})
    private Set<Role> roles=new HashSet<>();
}

Role.java

@Data
@Entity
@Table(name = "role")
public class Role {
    @Id
    @Column(name = "role_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int roleId;
    @Basic
    @Column(name = "role_name")
    private String roleName;
    @Basic
    @Column(name = "role_desp")
    private String roleDesp;

    @ManyToMany(targetEntity = Person.class,fetch = FetchType.EAGER)
    @JoinTable(name = "person_role",
    joinColumns = {@JoinColumn(name = "role_id",referencedColumnName = "role_id")},
    inverseJoinColumns = {@JoinColumn(name = "person_id",referencedColumnName = "person_id")}
    )
    private Set<Person> persons=new HashSet<>();
}

测试类

 //保存一个用户 一个角色
    @Test
    @Transactional
    @Rollback(false)
    public void test(){
        Person person = new Person();
        person.setName("王尔德");
        person.setGender(1);
        person.setPersonAddr("北京");
        person.setBirthday(new Date());

        Role role = new Role();
        role.setRoleName("java程序员");
        role.setRoleDesp("写java程序的");
        //配置用户到角色的关系,可以对中间表中的数据进行维护(只能配置一个，配置用户到角色或者角色到用户)
        person.getRoles().add(role);

        personDao.save(person);
        roleDao.save(role);
    }

通过用户查询角色

  • 测试类
 @Test
    public void testSelect(){
        Person person = personDao.findOne(1);
        System.out.println(person);
    }
极乐码农
关注
专栏目录
jpa 定义中间表实体_Spring Data JPA实体详解
weixin_28704675的博客
12-24 1192
1. Spring Data JPA实体概述JPA提供了一种简单高效的方式来管理Java对象(POJO)到关系数据库的映射，此类Java对象称为JPA实体或简称实体。实体通常与底层数据库中的单个关系表相关联，每个实体的实例表示数据库表格中的某一行。2.Spring Data JPA实体管理器2.1 实体管理器概述实体管理器(EntityManager)用于管理系统中的实体，它是实体与数据库之间的...
十五、（1）Spring Data JPA 表间关系
weixin_45611944的博客
05-30 147
spring data jpa 表间关系
SpringData JPA中表的关联关系
u014627099的博客
05-03 635
这篇博客是闲着没事，自己随便写着玩的。。只简单列举一下实体类在不同关联关系中的写法。 首先是单向多对一，两个实体类，分别是Order和Customer： package com.sunsy.jpatest.entity; import javax.persistence.Column; import javax.persistence.Entity; imp...
SpringDataJPA---多表关系
qq_43404873的博客
12-07 357
多表设计 1.1 表之间关系的划分 数据库中多表之间存在着三种关系，如图所示。 从图可以看出，系统设计的三种实体关系分别为：多对多、一对多和一对一关系。注意：一对多关系可以看为两种： 即一对多，多对一。所以说四种更精确。 一对多: 一的一方：主表 多的一方：从表 外键：需要在从表上新建一列作为外键，它的取值来源于主表的主键 多对多: 中间表: 中间表最少应该由两个字段组成，这两个字段作为外键指向两张表的主键，同时这两个字段又组成了联合主键。 实体类中的关系 包含关系：可以通过实体类中的包含关
SpringDataJpa创建中间表
songziyuan_的博客
07-12 1599
//fetch=FetchType.EAGER 关闭懒加载 相当于hibernate中的lazy=false //joinColumns 配置中间表的主列 //inverseJoinColumns=@JoinColumn(name="t_roleId") 创建中间表的副列 @ManyToMany(fetch=FetchType.EAGER) @JoinTable(name="t1_user_permission",joinColumns=@JoinColumn(name="t_userId"), .
Spring Data JPA的优点和难点.pdf
12-05
Spring Data JPA是Spring生态中的一个强大ORM框架，它极大地提高了Java开发者在处理数据库操作时的效率。Spring Data JPA的主要优点在于其高度的开发效率、成熟的语法结构以及与Spring框架的紧密集成。 1. **开发...
spring注解+spring data jpa文档+JPA文档.rar
04-05
Spring框架的核心特性包括依赖注入（DI）和面向切面编程（AOP），并且它还提供了对数据库操作的支持，这主要通过Spring Data JPA和Java Persistence API（JPA）实现。 Spring注解是Spring框架中的一大特色，它极大...
Spring Data JPA 实现多表关联查询的示例代码
08-27
总结来说，Spring Data JPA提供了灵活的方式处理多表关联查询。通过自定义Repository接口和结果类，我们可以方便地进行复杂的数据检索，同时保持代码的整洁性和可维护性。这使得开发者可以更专注于业务逻辑，而不是...
Spring Data Jpa实现自定义repository转DTO
08-18
它提供了许多有用的功能，例如自动生成数据库表、自动处理关系数据库、支持 JPQL 等。在实际开发中，我们经常需要将数据库查询结果转换为 DTO 对象，以便于业务逻辑处理和数据传输。在本文中，我们将详细介绍如何...
Spring Data JPA 笔记
04-16
1. **实体（Entities）**：在Spring Data JPA中，实体是数据库表的映射。通过在类上添加`@Entity`注解，我们可以声明一个Java类为数据库表的代表。`@Id`注解用于标识主键字段。 2. **Repository**：Repository是...
hibernate jar包_Hibernate 和JPA 和springData
weixin_39921224的博客
11-29 144
学习主题：Hibernate学习目标： 1 掌握Spring整合Hibernate 2 掌握Hibernate的CURD 3 掌握HQL语句对应视频: http://www.itbaizhan.cn/course/id/85.html对应文档:无对应作业1. Spring Data课程中的技术介绍(1) 什么是Hibernate？对象关系映射:实现思想: 将关系数据库中表的数据映射成为对象,以对...
jpa分页查询_JPA、Hibernate、Spring Data JPA 的关系，你懂吗？
weixin_39553272的博客
11-26 66
作者： java思维导图来源：https://my.oschina.net/u/3080373/blog/1828589什么是JPA？全称Java Persistence API，可以通过注解或者XML描述【对象-关系表】之间的映射关系，并将实体对象持久化到数据库中。为我们提供了：1)ORM映射元数据：JPA支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久...
springData一对多,多对多的关系
qq_40959641的博客
01-31 507
@OneToMany: 作用：建立一对多的关系映射 属性： targetEntityClass：指定多的多方的类的字节码 mappedBy：指定从表实体类中引用主表对象的名称。 cascade：指定要使用的级联操作 fetch：指定是否采用延迟加载 orphanRemoval：是否使用孤儿删除 @ManyToOne 作用：建立多对一的关系 属性： targetEntityClass：指定一的一方实...
Spring Data Jpa 多表之间的关系和操作多表的步骤（一对多）
恶魔盒子
07-20 793
Spring Data Jpa 多表之间的关系和操作多表的步骤 表关系 一对一 一对多： 一的一方：主表 多的一方：从表 外键：需要再从表上新建一列作为外键，他的取值来源于主表的主键 多对多 中间表：中间表中最少应该由两个字段组成，这两个字段做为外键指向两张表的主键，又组成了联合主键 实体类中的关系 4. 包含关系：可以通过实体类中的包含关系描述表关系 5. 继承关系 分析步骤 6. 明确表关系 7. 确定表关系（描述 外键 | 中间表） 8. 编写实体类，再实体类中描述表关系（包含关系） 9. 配置
jpa中的表关系以及多表CRUD操作
woshisunxinyuan的博客
09-19 2703
一对多的关系映射 第一步 明确两张表的关系 一个客户可以对应多个联系人 多个联系人可以属于同一个客户 第二步 在数据库中建立两张表的关系 使用外键。 在联系人表中添加一列，这一列的值来源于 客户表的主键，添加的这列 是外键。 第三步 在实体类中建立两个实体间的关系 从表： 多对一的关系映射：多个联系人对应一个客户 所以，从表实体包含主表的对象引用 private Customer customer...
Spring Data JPA中多对多表的操作（4）
weixin_42030357的博客
06-30 2326
1.对于数据库中表的建立 查看文章：SSM中多表的关系和建立 2.实体类的操作 2.1为《一》的客户的实体类添加的注解为： * 放弃外键维护权 * mappedBy：对方配置关系的属性名称\ * cascade : 配置级联（可以配置到设置多表的映射关系的注解上） * CascadeType.all : 所有操作 ...
jpa配置多对多关系(中间表)
chenyidong521的博客
04-03 2万+
两个实体tb_user,tb_role 现在我们再tb_user或者tb_role中任意一个里面进行维护关系，多对对的情况下我们需要创建一个中间表来完成这个关系的映射，我们再tb_user中添加注解@ManyToMany然后再添加一个注解@JoinTable因为我们是要创建中间表所以要使用这个注解。JoinTable注解中我们添加如下例子中的内容，joinColumns当前表中的字段在中间表中的...
Spring Data JPA多表操作(5)
weixin_39248420的博客
12-01 831
Spring Data JPA多表操作(5) 数据库中多表之间的关系 多对多 一对多 一对一 数据库设计示例 实体示例 客户：指的是一家公司，我们记为A。 联系人：指的是A公司中的员工。 在不考虑兼职的情况下，公司和员工的关系即为一对多。 表设计示例 实体类关系设计 客户（公司）类（一） @Entity//表示当前类是一个实体类 @Table(name="cst_custom...
用Spring boot jpa update modify delete 数据和事务管理的那些坑
热门推荐
hanghangde的博客
11-20 2万+
有好多文章介绍了Spring boot 博客已经很多了比如说: http://blog.csdn.net/linzhiqiang0316/article/details/52639265 http://blog.csdn.net/linzhiqiang0316/article/details/52638039 http://blog.didispace.com/springbootmultid
Spring Data JPA 连表查询：接口方式实现示例
"本文将介绍如何使用Spring Data JPA实现多表关联查询，重点在于第二种方式，即通过创建结果集接口来处理连表查询的结果。这种方法对于理解和掌握Spring Data JPA的高级用法非常有帮助。我们将通过一个一对一映射的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值