JPA关系

最新推荐文章于 2022-10-26 14:50:00 发布
最新推荐文章于 2022-10-26 14:50:00 发布
阅读量138 收藏 1
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45988641/article/details/103553604
版权

JPA关系

一、单向一对多

  • 性能非常差,不建议使用
  • 如果要使用，建议使用双向的多对一、一对多
  • 默认是懒加载

（一）代码配置

  • 必需使用接口声明
  • 可以使用List(有序允许重复)或者Set，必需把它new出来
  • 一定要指定外键(否则会出现中间表)
@OneToMany
@JoinColumn(name = "dir_id")
private List<Product> products = new ArrayList<>();

（二）保存代码

public void testSave() throws Exception{
    //准备多方
    Product p1 = new Product();
    p1.setName("西游记");
    Product p2 = new Product();
    p2.setName("东游记");
    //准备一方
    ProductDir dir = new ProductDir();
    dir.setName("游记");
    //建立关系
    dir.getProducts().add(p1);
    dir.getProducts().add(p2);

    EntityManager entityManager = JPAUtil.createEntityManager();
    entityManager.getTransaction().begin();
    /**
    * 3条SQL是最合理的
    * 先保存一方，再保存多方 -> 5条
    * 先保存多方，再保存一方 -> 5条
    * 原因：外键是由一方来处理，一方处理必须发出额外的update语句
    */
    entityManager.persist(p1);
    entityManager.persist(p2);
    entityManager.persist(dir);

    entityManager.getTransaction().commit();
    entityManager.close();
}

（三）判断集合是否有值

public void testFind2() throws Exception{
    EntityManager entityManager = JPAUtil.createEntityManager();
    //获取一方
    ProductDir dir = entityManager.find(ProductDir.class, 1L);
    //判断:一方有没有对应的多方，集合需要判断长度
    if(dir.getProducts().size() > 0){
        System.out.println("有货！！！！");
    }
    entityManager.close();
}

二、集合映射

  • Hibernate提供的类:实现延迟加载的关键类
  • org.hibernate.collection.internal.PersistentSet 实现了java.util.Set接口
  • org.hibernate.collection.internal.PersistentBag 实现了java.util.List接口
public void test() throws Exception {
  EntityManager entityManager = JPAUtils.getEntityManager();
  // 拿到一方的数据
  ProductDirSet dir = entityManager.find(ProductDirSet.class, 1L);
  // 打印产品类别
  System.out.println(dir);//class org.hibernate.collection.internal.PersistentList
  System.out.println(dir.getProducts().getClass());
   
  entityManager.close();
}

选择：set一般用在多对多,也有一对多

​ list一般只是用在组合关系（使用List接口的时候可以配置@Order进行排序）

三、双向多对一(双向一对多)

  • 双向配置的表结构和单向是完全一样的
  • 尽量使用多方来维护关系(性能好)
  • 外键在哪边,哪边就是多方(也方便维护)
@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue
    private Long id;
    /*多个员工属于一个部门*/
    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;

@Entity
@Table(name = "department")
public class Department {
    @Id
    @GeneratedValue
    private Long id;
    /*一个部门有多个员工
     *确定外键关连的名称叫:department_id
     *      保证维护关系的列是同一列
     *  mappedBy = "department" :映射的关系交给Employee类中的department的属性去维护
     *                    		Department类放弃了关系维护
    */
    @OneToMany(mappedBy = "department")
    private List<Employee> employees = new ArrayList<>();

四、级联

  • 级联很危险,不要随便使用
  • 组合关系(单据)必需使用级联
  • 要使用就是使用最强级联: cascade = CascadeType.ALL,orphanRemoval = true
cascade : 级联
     *      CascadeType.PERSIST -> 保存
     *      CascadeType.MERGE -> 修改
     *      CascadeType.REMOVE -> 删除
     *      CascadeType.ALL -> 包含级联增删改
     *      orphanRemoval : 孤儿删除（可以从一方删除解除关系）

1.级联保存

@OneToMany(mappedBy = "department",cascade = CascadeType.PERSIST)
private List<Employee> employees = new ArrayList<>();

2.级联删除：删除一方，然后级联删除多方

@OneToMany(mappedBy = "department",cascade = CascadeType.REMOVE)
private List<Employee> employees = new ArrayList<>();

3.先获取一方,在删除一个多方

@OneToMany(mappedBy = "department",cascade = CascadeType.REMOVE,orphanRemoval = true)
   // @JoinColumn(name = "department_id")
    private List<Employee> employees = new ArrayList<>();

4.先获取一方,在删除所有多方

@OneToMany(mappedBy = "department",cascade = CascadeType.ALL,orphanRemoval = true)
   // @JoinColumn(name = "department_id")
    private List<Employee> employees = new ArrayList<>();

五、单向多对多

（一）代码配置

/*
 * 这里默认是延时加载(集合都是懒加载)
 * @JoinTable:指的是关连(中间)表
 *       name:中间表的名称
 *       joinColumns:当前类(表)对应的外键名称
 *       inverseJoinColumns:关连的类(表)对应的外键名称
 */
@ManyToMany
@JoinTable(name = "t_user_role",
           joinColumns = @JoinColumn(name = "user_id"),
           inverseJoinColumns = @JoinColumn(name = "role_id")
          )
private List<Role> roles = new ArrayList<>();

（二）保存代码

public void testSave() throws Exception{
    EntityManager entityManager = JPAUtil.createEntityManager();
    //准备2个用户
    User u1 = new User();
    u1.setName("无忌孩儿");
    User u2 = new User();
    u2.setName("三丰");
    //准备三个角色
    Role r1 = new Role();
    r1.setName("少林");
    Role r2 = new Role();
    r2.setName("武当");
    Role r3 = new Role();
    r3.setName("明教");
    //建立关系
    // 无忌 -> 武当，明教
    u1.getRoles().add(r2);
    u1.getRoles().add(r3);
    // 三丰 -> 少林,武当,明教
    u2.getRoles().add(r1);
    u2.getRoles().add(r2);
    u2.getRoles().add(r3);
	/*执行10条SQL*/
    EntityManager entityManager = JPAUtil.createEntityManager();
    entityManager.getTransaction().begin();
    //再保存用户
    entityManager.persist(u1);
    entityManager.persist(u2);
    //先保存角色
    entityManager.persist(r1);
    entityManager.persist(r2);
    entityManager.persist(r3);

    entityManager.getTransaction().commit();
    entityManager.close();
}

六、双向多对多

  • 一定要自己去控制中间表的表名与列名
  • 正常操作都没有问题(尽量不要使用级联)
  • 双向保证表名列名是一致的

（一）代码配置

@Entity
@Table(name = "t_user")
public class User {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    /*用户找到角色*/
    @ManyToMany
    @JoinTable(name = "t_user_role",
            joinColumns = @JoinColumn(name = "user_id"),
            inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private List<Role> roles = new ArrayList<>();



@Entity
@Table(name = "t_role")
public class Role {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    /*角色找到用户*/
    @ManyToMany
    @JoinTable(name = "t_user_role",
        joinColumns = @JoinColumn(name = "role_id"),
            inverseJoinColumns = @JoinColumn(name = "user_id")
    )
    private List<User> users = new ArrayList<>();

（二）级联

1.删除user1的所有包含角色(role1,role2),不能删除user1
  • 由JPA自动处理,先删除中间表,在删除user1
public void testDelete01() throws Exception{
    EntityManager entityManager = JPAUtil.createEntityManager();
    entityManager.getTransaction().begin();

    User user = entityManager.find(User.class, 1L);
    entityManager.remove(user);

    entityManager.getTransaction().commit();
    entityManager.close();
}
2.级联删除(一边配置，危险)
  • 只有一边配置了@ManyToMany(cascade = CascadeType.REMOVE)
  • 比如删除武当，只会删除跟武当相关的
3.级联删除(二边配置，非常危险)
  • 两边都配置了@ManyToMany(cascade = CascadeType.REMOVE)
  • 容易不小心就把所有数据删除

七、一对一

  • 共享主键(扩展性不强,不建议使用)
  • 唯一外键(扩展性强,建议使用)
  • 外键在哪边,哪边就是从表
@Entity
public class QQ {
  @Id
  @GeneratedValue
  private Long id;
  private String number;
  // 一对一,一个qq号码对应一个qq空间
  @OneToOne(mappedBy="qq")
  private QQZone zone;
｝


@Entity
public class QQZone {
  @Id
  @GeneratedValue
  private Long id;
  private String name;
  // 一对一,一个qq空间输入一个qq号码
  // 默认值optional = true表示qq_id可以为空;反之。。。
  @OneToOne(optional = false)
  // unique=true确保了一对一关系
  @JoinColumn(name = "qq_id", unique = true)
  private QQ qq;
｝

八、关系总结

  • 单向多对一、一对多、双向多对一（一对多）表结构完成一样
  • 单向一对多性能差(不用)
  • 声明的时候都用接口
  • 集合先new出来(以免以后代码麻烦)
  • JPA集合默认懒加载
  • 想要性能好先一后多
  • 先配置单向(业务需要再配置双向)
  • 不要在toString()打印关连对象，互相调用容易内存溢出
EstherLty
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JPA常用关系实现例子
07-02
JPA常用关系实现例子:一对一，一对多，多对一，多对多关系实现代码。
jpa的实体映射关系7种
02-23
单向一对一 双向一对一 单向一对多 双向一对多 双向多对一 单向多对多 双向多对多
Hibernate，JPA 对象关系映射之关联关系映射策略
sanmudoudizhu的博客
07-25 147
本章将指导完成学习实体间的关系。一般的关系数据库中的表之间的更有效。这里的实体类都被视为关系表(JPA的概念)，因此是实体类之间的关系如下： @ManyToOne 关系 @OneToMany 关系 @OneToOne 关系 @ManyToMany 关系 @ManyToOne 关系 多对一实体之间存在的关系，其中一个实体（列或组列）的引用与另一个实体（列或组列）包含唯一值。在关系数...
jpa-关系类型（一对一、多对一、一对多、多对多）
Laputa219的博客
05-22 1239
原文地址：https://blog.csdn.net/dm_vincent/article/details/52877296 此篇为转载，学好jpa弄清关系映射是关键，大佬总结的已经很好了，仔细阅读，受益匪浅，在此基础上简单画了一个导图，仅供参考。 以下为正文↓↓↓↓↓↓ 一、分类 根据关系中目标对象的数量，可以将关系简单分为两种。 单值映射(Single-Valued Mapping) 集合映射(Collection-Viewed Mapping) 二、单值映射 2.1 一对一(One-to-O.
JPA关联关系
Ruyi_squad的博客
08-14 242
JPA学习笔记（一） 1、idea构建Spring工程（勾选SQL中Spring Data JPA next） 2、配置application.yaml #配置数据源 spring: datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/...
JPA 简单应用 学习
爱.NET
12-09 138
这是我09年初写的，当时比较肤浅，应该会有些错误的地方，希望对大家有所帮助。 下载pdf地址：http://download.csdn.net/detail/partner4java/1995131 （无加密，可以修改） 如果ORM比较有用的话，推荐看《hibernate in action 2》--翻译的一般，但是内容很精湛。我也阅读后做了一些笔记： http://blo...
jpa映射关系详解[参照].pdf
10-19
jpa映射关系详解[参照].pdf
尚硅谷JPA视频教程
02-17
JPA视频_映射单向多对一的关联关系　· 13. JPA视频_映射单向一对多的关联关系　· 14. JPA视频_映射双向一对多的关联关系　· 15. JPA视频_映射双向一对一的关联关系　· 16. JPA视频_映射双向多对多的关联关系　...
jpa的关联关系
QQ617923457的专栏
07-15 1089
jpa中的个种关系
weixin_43404554的博客
04-17 119
java中的关系 泛型：继承关系 实现 组合 聚合 关联 依赖 jpa中的关系 组合，聚合，关联 单向一对多，单向多对一， @OneToMany(fetch = FetchType.LAZY) @JoinColumn(name = "department_id") 双向一对多/多对一:两边都要配置，但是我们为了提高性能，我们会在一遍选择放弃维权 @OneToMany(fetch = Fetch...
JPA数据关联
sinat_27674731的博客
03-21 687
JPA数据关联一对一数据关联一对多数据关联多对多数据关联 JPA不仅可以实现单表实体映射，也可以实现数据关联技术。常见的有：一对一关联、一对多关联、多对多关联。利用关联技术可以实现级联数据操作，简化代码编写。 项目源码地址： https://gitee.com/tirklee/leaspring 实例中所用工具类 package com.xiyue.leaspring.util; import javax.persistence.EntityManager; import javax.persisten
理解JPA，第二部分：JPA中的关系
华丽的痘痘
07-04 3933
     你用JAVA写的web程序非常依赖于数据之间的关系，如果你处理不好的话，结果将会变得非常糟糕。在这篇文章中，作者将向你展示，如何利用JPA的标注，在面向对象代码与关系数据之间创建一个透明的接口。最终的数据关系将会更容易管理，并且更具备可移植性。     数据对于任何一个应用程序来讲都是必不可少的，而数据之间存在的关系也具有同样的重要性。关系型数据库能够支持数据表之间的各种关系，并
Jpa之间实体关系，一对多，多对一，多对多，相关注解说明
weixin_44793245的博客
10-19 1329
JPA之间实体关系    JPA在生成数据表的时候，实体之间的主要关系主要有三种，分别是： @ManyToOne （多对一） @OneToMany （一对多关系） @OneToOne （一对一关系） @ManyToMany （多对多关系） 其中一对多是比较常用的。下面对一对多进行演示说明。 实体与实体之间一对多关系配置   有两张表，分别是banner和banner_item，两者之间的关系是一对多。 Banner.java（一对多中，“一”的
JPA的实体关系
iuhe_999的博客
04-20 338
实体之间的关系：1、@ManyToOne 多对一  （多个学生对应一个学校）      @OneToMany一对多关系（一个校长对应多位同学）      @OneToOne一对一关系（一个学生只有一个学号）     @ManyToMany多对多关系（多个人对应多个兴趣爱好）2、JPA实体管理器    主要模块：（1）模型或POJO（2）持久化Persistence.xml(3)服务就是增删改查Em...
JPA 中的一对一关系
allway2的博客
10-26 850
假设我们正在构建一个用户管理系统，我们的老板要求我们为每个用户存储一个邮寄地址。一个用户将有一个邮寄地址，一个邮寄地址将只有一个与之绑定的用户。现在，让我们想象一下，我们的员工与工作站相关联。在本文中，我们学习了在 JPA 和休眠中维护一对一关联的不同方法，以及何时使用每种方法。在本教程中，我们将了解在 JPA 中创建一对一映射的不同方法。表中主键的列的名称。是此关系的所有者，因为我们选择在其上使用联接表批注。最后，在下一个实体中请注意，我们不会在那里使用。现在，每当我们有关系时，我们将在。
JPA实体之间的关系配置
SaoLife的博客
09-22 335
单向多对一 集合排序：@OrderBy(“price DESC”) ASC升序/DESC降序 一方 @Entity @Table(name = "commoditytype") public class CommodityType { @Id @GeneratedValue private Long id; @Colum...
jpa实体关系-一对多
面朝大海，春暖花开
07-12 671
jpa实体关系-一对多 双向一对多映射 如一个Department中有多个Employeem,而一对多的关系往往是双向的 @Entity public class Employeem { @Id @GeneratedValue(strategy = GenerationType.AUTO) private int id; private Stri...
hibernate与jpa 的关系
最新发布
05-03
JPA是Java Persistence API的缩写，是Java EE 5规范中定义的一组API，它提供了一种标准的方式来在Java应用程序中管理关系型数据库。JPA提供了一种简单的方式来进行ORM编程，它是Java Persistence规范的实现。JPA实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值