JPA学习——2.关系维护

最新推荐文章于 2022-12-04 20:29:59 发布
最新推荐文章于 2022-12-04 20:29:59 发布
阅读量397 收藏 1
点赞数 1
分类专栏： 框架技术 文章标签： jpa hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33905217/article/details/107555831
版权

如何表示实体之间的关系，我们需要使用一对一、一对多、多对一、多对多的注解进行关系维护和声明

1.双向一对一

person类（1）

@Entity
@Table(name = "PERSONS")
public class Person {
    private Integer id;
    private String name;
    private Card card;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    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;
    }
    @JoinColumn(name = "card_id")
    @OneToOne
    public Card getCard() {
        return card;
    }

    public void setCard(Card card) {
        this.card = card;
    }
}

Card类（1）

@Entity
@Table(name = "CARD")
public class Card {
    private Integer id;
    private String number;
    private Person person;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    @OneToOne(mappedBy = "card")
    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}

测试

public class MyTest {
    private EntityManagerFactory entityManagerFactory;

    @Before
    public void before(){
        entityManagerFactory = Persistence.createEntityManagerFactory("myPersistenceUnit");
    }
    @After
    public void after(){
        entityManagerFactory.close();
    }

    @Test
    public void test(){
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        entityManager.getTransaction().begin();

        Person person = new Person();
        person.setName("张三");

        Card card = new Card();
        card.setNumber("123");

        person.setCard(card);
        card.setPerson(person);

        entityManager.persist(card);
        entityManager.persist(person);

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

结果：

先插入card再插入person，对应的DML：

  1.  insert card
  2. insert person

先插入person 再插入card，对应的DML：

  1.  insert person
  2. insert card
  3. update person

2.单向一对多

customer类（1）

@Entity
@Table(name="CUSTOMER")
public class Customer {
    private Integer id;
    private String name;
    private String tele;
    private Set<Order> orders;

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    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;
    }
    @Column(name="tele",length = 13)
    public String getTele() {
        return tele;
    }

    public void setTele(String tele) {
        this.tele = tele;
    }

    @JoinColumn(name = "cus_id")
    @OneToMany
    public Set<Order> getOrders() {
        return orders;
    }

    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
}

ordner类（n）

@Entity
@Table(name="ORDERS")
public class Order {
    private Integer id;
    private String content;

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

}

测试

public class MyTest {
    private EntityManagerFactory entityManagerFactory;

    @Before
    public void before(){
        entityManagerFactory = Persistence.createEntityManagerFactory("myPersistenceUnit");
    }
    @After
    public void after(){
        entityManagerFactory.close();
    }

    @Test
    public void test(){
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        entityManager.getTransaction().begin();

        Customer customer = new Customer();
        customer.setName("张三");
        customer.setTele("12314568");

        Order order1 = new Order();
        order1.setContent("AAAA");
        Order order2 = new Order();
        order2.setContent("BBBB");

        Set<Order> orders = new HashSet<>();
        orders.add(order1);
        orders.add(order2);

        customer.setOrders(orders);

        entityManager.persist(customer);
        entityManager.persist(order1);
        entityManager.persist(order2);

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

结果：

先插入客户再插入订单，对应的DML：

  1.  insert客户
  2. insert订单1
  3. insert订单2
  4. update订单1
  5. update订单2

先插入订单再插入客户，对应的DML：

  1. insert订单1
  2. insert订单2
  3. insert客户
  4. update订单1
  5. update订单2

如果设置了级联会先插入客户

3.单向多对一

customer类（1）

@Entity
@Table(name="CUSTOMER")
public class Customer {
    private Integer id;
    private String name;
    private String tele;

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    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;
    }
    @Column(name="tele",length = 13)
    public String getTele() {
        return tele;
    }

    public void setTele(String tele) {
        this.tele = tele;
    }

}

ordner类（n）

@Entity
@Table(name="ORDERS")
public class Order {
    private Integer id;
    private String content;
    private Customer customer;

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    //定义外键列名
    @JoinColumn(name = "cus_id")
    @ManyToOne
    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

测试

public class MyTest {
    private EntityManagerFactory entityManagerFactory;

    @Before
    public void before(){
        entityManagerFactory = Persistence.createEntityManagerFactory("myPersistenceUnit");
    }
    @After
    public void after(){
        entityManagerFactory.close();
    }

    @Test
    public void test(){
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        entityManager.getTransaction().begin();

        Customer customer = new Customer();
        customer.setName("张三");
        customer.setTele("12314568");

        Order order1 = new Order();
        order1.setContent("AAAA");
        order1.setCustomer(customer);
        Order order2 = new Order();
        order2.setContent("BBBB");
        order2.setCustomer(customer);

        entityManager.persist(order1);
        entityManager.persist(order2);
        entityManager.persist(customer);


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

结果：

先插入客户再插入订单，对应的DML：

  1.  insert客户
  2. insert订单1
  3. insert订单2

先插入订单再插入客户，对应的DML：

  1. insert订单1
  2. insert订单2
  3. insert客户
  4. update订单1
  5. update订单2

如果设置了级联会先插入客户

3.双向一对多

customer类（1）

@Entity
@Table(name="CUSTOMER")
public class Customer {
    private Integer id;
    private String name;
    private String tele;
    private Set<Order> orders;

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    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;
    }
    @Column(name="tele",length = 13)
    public String getTele() {
        return tele;
    }

    public void setTele(String tele) {
        this.tele = tele;
    }

    @JoinColumn(name = "cus_id")
    @OneToMany(cascade = CascadeType.ALL)
    public Set<Order> getOrders() {
        return orders;
    }

    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }

}

ordner类（n）

@Entity
@Table(name="ORDERS")
public class Order {
    private Integer id;
    private String content;
    private Customer customer;

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    //定义外键列名
    @JoinColumn(name = "cus_id")
    @ManyToOne
    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

测试

public class MyTest {
    private EntityManagerFactory entityManagerFactory;

    @Before
    public void before(){
        entityManagerFactory = Persistence.createEntityManagerFactory("myPersistenceUnit");
    }
    @After
    public void after(){
        entityManagerFactory.close();
    }

    @Test
    public void test(){
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        entityManager.getTransaction().begin();

        Customer customer = new Customer();
        customer.setName("张三");
        customer.setTele("12314568");

        Order order1 = new Order();
        order1.setContent("AAAA");
        Order order2 = new Order();
        order2.setContent("BBBB");

        Set<Order> orders = new HashSet<>();
        orders.add(order1);
        orders.add(order2);

        customer.setOrders(orders);

        entityManager.persist(customer);
        entityManager.persist(order1);
        entityManager.persist(order2);

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

结果：

先插入客户再插入订单，对应的DML：

  1.  insert客户
  2. insert订单1
  3. insert订单2
  4. update订单1
  5. update订单2

先插入订单再插入客户，对应的DML：

  1. insert订单1
  2. insert订单2
  3. insert客户
  4. update订单1
  5. update订单2
  6. update订单1
  7. update订单2

相比较单向多对一的客户先插，双向维护外键无论谁先插都造成多余的update语句，所以我们如果希望使用双向关联同时又可以避免不必要的sql语句，则可以让客户放弃外键维护（@OneToMany(mappedBy = "customer"，同时，删除客户的@JoinColumn(name = "cus_id")，否则会造成异常）

客户放弃外键维护后

结果：

先插入客户再插入订单，对应的DML：

  1.  insert客户
  2. insert订单1
  3. insert订单2

先插入订单再插入客户，对应的DML：

  1. insert订单1
  2. insert订单2
  3. insert客户
  4. update订单1
  5. update订单2

补充：

  • 如果不在客户一方加入@JoinColumn(name = "cus_id")，会生成一张中间表
  • 如果不在订单一方加入@JoinColumn(name = "cus_id")，订单表会根据类中的变量命生成一个外键列customer_id。然后由于客户一端设置了@JoinColumn(name = "cus_id")，orders表中会出现两个外键
  • 如果两边都不加@JoinColumn(name = "cus_id")，订单表会根据类中的变量命生成一个外键列customer_id，而客户一方会由于没有指定外键列，则默认生成一张中间表

4.多对多

student类（n）

@Entity
@Table(name="STUDENT")
public class Student {
    private Integer id;
    private String name;
    private Set<Subject> subjects;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    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;
    }

//定义中间表
    @JoinTable(
            //中间表名
            name = "student_subject",
            //外键引用
            joinColumns = {@JoinColumn(name = "stu_id",referencedColumnName = "id")},
            inverseJoinColumns = {@JoinColumn(name = "sub_id",referencedColumnName = "id")})
    @ManyToMany
    public Set<Subject> getSubjects() {
        return subjects;
    }

    public void setSubjects(Set<Subject> subjects) {
        this.subjects = subjects;
    }
}

subject类（m）

@Entity
@Table(name="SUBJECT")
public class Subject {
    private Integer id;
    private String className;
    private Set<Student> students;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    @ManyToMany(mappedBy = "subjects")
    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }
}

测试

public class MyTest {
    private EntityManagerFactory entityManagerFactory;

    @Before
    public void before(){
        entityManagerFactory = Persistence.createEntityManagerFactory("myPersistenceUnit");
    }
    @After
    public void after(){
        entityManagerFactory.close();
    }

    @Test
    public void test(){
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        entityManager.getTransaction().begin();

        Student student1 = new Student();
        student1.setName("张三");
        Student student2 = new Student();
        student1.setName("李四");

        Set<Student> students = new HashSet<>();
        students.add(student1);
        students.add(student2);

        Subject subject1 = new Subject();
        subject1.setClassName("math");
        Subject subject2 = new Subject();
        subject2.setClassName("Chinese");

        Set<Subject> subjects = new HashSet<>();
        subjects.add(subject1);
        subjects.add(subject2);

        student1.setSubjects(subjects);
        student2.setSubjects(subjects);
        subject1.setStudents(students);
        subject2.setStudents(students);

        entityManager.persist(student1);
        entityManager.persist(student2);
        entityManager.persist(subject1);
        entityManager.persist(subject2);

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

 

 

原来是肖某人
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
关系配置一对一_Jpa系列：SpringBoot Jpa 的表关系维护
weixin_32968105的博客
01-03 679
SpringBoot表关系依靠注解@OneToOne、@ManyToMany、@ManyToOne、@OneToMany来实现。注意：@OneToMany如果不加@JoinColumn,系统会自动在主从表中增加一个中间表。当数据记录较多时，会影响数据库的性能。其他三个注解情况也类似？（还没试验过）。1. @OneToOne：维护”一对一“关系@OneToOne注解维护的是表与表之间的“一对一”关系...
JPA学习（三）
钟渊博客
12-17 566
一、JPA二级缓存 首先看下面的案例（没有配置二级缓存）： @Test public void testSecondCache(){ Customer customer1 = entityManager.find(Customer.class, 3); Customer customer2 = entityManager.find(Customer.class, 3); } 使
JPA关系维护端和被维护端
08-05 767
在一对多的时候，多的一方是关系维护端，一的一方是关系被维护端。在关系被维护端里面有mappedBy 转载于:https://www.cnblogs.com/ocean010/archive/2009/08/05/1539899.html...
JPA：确定关系的归属方
最佳 Java 编程
05-15 129
使用Java Persistence API（JPA）时，通常需要在两个实体之间创建关系。 这些关系是通过使用外键在数据模型（例如数据库）中定义的，而在我们的对象模型（例如Java）中则使用注释来定义关联，以定义关联。 在对象模型中定义关系或关联时，一项常见的任务是识别关系的拥有方。 标识关系中的拥有实体很重要，因为拥有方通常是（如果不是总是）必须在@JoinColumn批注中指定的地方。 ...
11_JPA详解_JPA中的一对多延迟加载与关系维护.zip
05-06
11_JPA详解_JPA中的一对多延迟加载与关系维护.zip 11_JPA详解_JPA中的一对多延迟加载与关系维护.zip
JPA关系维护辨析
花火酱的抱枕
06-02 152
在JPA配置关系时要注意：1、谁配置了mappedBy谁就是关系被维护端，另一个是关系维护端(关系维护端一般配置@JoinColumn表示外键和optional表示外键是否可以为NULL)。2、关系护端即负责外键记录的更新，一方为被维护端即没有权力更新外键记录。...
JPA学习
zuoweichang的博客
08-26 292
1.jpa 1．ORM思想 ORM（Object-Relational Mapping） 表示对象关系映射。 操作对象就是操作表, 尽量不写sql ORM就是建立 实体类 和 数据库表 之间的关系，从而达到操作实体类就相当于操作数据库表的目的。(框架建立这样的关系,类名-表名,属性-列) 操作对象就是操作表；基于orm思想的, 能够建立了对应关系的框架；Mybaitis(半自动)/hiber...
JPA学习笔记（二）——JPA 注解
12-14
理解并熟练使用这些注解是掌握JPA的关键，它们使得开发者无需编写SQL语句，就能轻松地实现对象到数据库的映射，从而提高开发效率和代码的可维护性。在实际项目中，可以根据具体需求灵活运用这些注解来定制持久化行为...
JPA学习 —— 第十课、双向一对多关联关系
YellowStar的博客
05-07 5025
双向一对多关联关系 之前讲的都是单向的，而本文讲的是双向的（双向一对多 = 双向多对一） 什么是双向？ 我们来对比一下单向和双向 单向多对一：需要在多方创建一方的引用,如: @ManyToOne @JoinColumn(name="DEPT_ID") private Department department; 这时就可以在多方关联查询到一方的内容。 单向一对多：需要在一方创...
_Java学习材料(499篇文章)等自己整理的资料——.rar_java
09-23
这份压缩包中的"Java学习材料(499篇文章)等自己整理的资料——.rar"显然是一个精心收集的资源集合，涵盖了Java的学习路径，从基础到进阶，包括面试准备和编程规范。 首先，让我们来探讨Java的基础部分。JavaSE...
毕业设计——医院管理系统.zip
最新发布
12-31
此外，Spring Data JPA或MyBatis可以用来操作数据库，大大减轻了数据访问层的编写工作。 对于数据验证和安全，Spring Security提供了强大的支持，可以防止未授权的访问，确保系统安全。同时，前端接口的数据验证也...
Spring Boot 2.x使用篇（二）—— 访问数据库
王喆峰的博客
08-07 2959
文章目录1、搭建演示环境1.1 创建数据库与数据表1.2 创建相应的POJO2、配置数据源2.1 默认数据源2.2 配置Spring Boot绑定的Tomcat数据源2.3 配置第三方数据源3、使用JPA（Hibernate）操作数据3.1 概述3.2 开发JPA3.2.1 使用JPA接口的默认实现完成查询3.2.2 使用JPA查询语言与命名查询4、Spring Boot整合MyBatis框架4....
JPA一对一双向
weixin_34252686的博客
03-05 139
这次，我们引用一个新的数据模型：丈夫（husband） 和 妻子（wife）。前提：众所周知，在我们伟大的祖国，法律上只存在一种婚姻关系，一夫一妻制。所以，一个丈夫只能有一个妻子，一个妻子也只有一个丈夫。（大家千万别较真，我已经限定了场景，法律上只允许一夫一妻。小三不在本例研究范围内） 对于这种数据模型来说，双向一对一关系已经很明显了。我们通过丈夫应该能找到他的妻子。同样，通过妻子...
Hibernate EntityManager 指南
allway2的博客
12-04 990
EntityManager是 Java Persistence API 的一部分。它主要实现 JPA 2.0 规范定义的编程接口和生命周期规则。此外，我们可以通过使用EntityManager 中的 API 来访问持久性上下文。在本教程中，我们将了解实体管理器的配置、类型和各种 API。首先，我们需要包含 Hibernate 的依赖项： 根据我们使用的数据库，我们还必须包含驱动程序依赖项： hibernate-core和mysql-connector-java依赖项在Maven Central上可用
JPA学习（四）创建接口和实现类实现对数据的增删改查
GinChou的萌新博客
10-16 860
配置文件还是和第一章的一样，没怎么变，用的策略是create的 目录 1.创建接口以及方法 2.每个对应的dao层的实现类实现接口的方法 3.测试 大概流程是这样的： 1.创建接口以及方法 创建接口之前先将domian实现了。 实现了两个类 cat 和dog 1.cat类 @Entity @Table(name = "t_cat") public class Cat...
JPA-entityManager的基本方法
江黎
01-25 641
public class JPATest { private EntityManager entityManager; private EntityTransaction transaction; private EntityManagerFactory entityManagerFactory; @Before public void setUp()
JPA 学习（四） JPA_EntityManager系列
殇莫忆的博客
09-07 1万+
JPA_EntityManager(一) 一、Persistence 和EntityManagerFactory 1、JPA相关接口/类：Persistence Persistence  类是用于获取 EntityManagerFactory 实例。该类包含一个名为 createEntityManagerFactory 的 静态方法 。 EntityManagerFactory enti...
Spring Data JPA 之 一对一，一对多，多对多 关系映射
热门推荐
我飞故我在的专栏
06-10 7万+
&amp;amp;amp;amp;amp;amp;nbsp; 一、@OneToOne关系映射 JPA使用@OneToOne来标注一对一的关系。 实体 People ：用户。 实体 Address：家庭住址。 People 和 Address 是一对一的关系。 这里用两种方式描述JPA的一对一关系。 一种是通过外键的方式(一个实体通过外键关联到另一个实体的主键)； 另外一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

原来是肖某人

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

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

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

打赏作者

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

抵扣说明：

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

余额充值