【Hibernate学习笔记】10：使用many-to-many的单向/双向N-M关联

最新推荐文章于 2020-09-05 11:02:50 发布
最新推荐文章于 2020-09-05 11:02:50 发布
阅读量404 收藏 1
点赞数
分类专栏： # Hibernate 文章标签： Hibernate N-M关联 ORM S2SH
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SHU15121856/article/details/80142361
版权

上学期数据库有学过，只要是N-M关联，都要为这个关联关系单独生成一个数据库模式，即生成一张表出来。以记录哪条记录对应了哪条记录。

例如，顾客和商品之间的关联就是一个N-M关联，顾客可以购买多种商品，一种商品也可以由很多顾客购买。
这里写图片描述

单向N-M关联

在单向N-M关联中，只要一方对于另外一方是可寻的，所以体现在PO上就是一个对象组合了一个另一个对象的集合作为属性。

在映射文件中，只要在组合了对方对象集合的属性上的<set .../>内使用<many-to-many .../>元素配置即可。

例如从顾客能找到他买的全部商品，这是一种单向N-M关联。

Customer类的属性
    private Integer id;
    private String userName;
    private String password;
    private Set<Product> products;// 每个顾客组合他购买过的商品的集合
Customer.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="myPOJO">
    <class name="Customer" table="CUSTOMER">

        <id name="id" column="ID">
            <generator class="native" />
        </id>

        <property name="userName" column="USERNAME" type="string"
            not-null="true" />
        <property name="password" column="PASSWORD" type="string"
            not-null="true" />

        <!-- 用组合的set属性配置N-M关联,会自动生成一张关联关系表 -->
        <set name="products" table="CSTMR_PRDCT">
            <!-- 设置在连接表中关于本表的外键名 -->
            <key column="CUSID" />
            <!-- 设置连接表中关于另一表的外键名,需要额外指出其实现类 -->
            <many-to-many class="Product" column="PROID" />
        </set>

    </class>
</hibernate-mapping>
Product类的属性
    private Integer id;
    private String proName;
    private Double price;
Product.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="myPOJO">
    <class name="Product" table="PRODUCT">

        <id name="id" column="ID">
            <generator class="native" />
        </id>

        <property name="proName" column="PRONAME" type="string"
            not-null="true" />
        <property name="price" column="PRICE" type="double" not-null="true" />

    </class>
</hibernate-mapping>
Main.java
package myApplication;

import java.util.HashSet;
import java.util.Set;

import myPOJO.Customer;
import myPOJO.Product;
import myTools.HibernateUtils;

import org.hibernate.Session;
import org.hibernate.Transaction;

public class Main {

    public static void main(String[] args) {
        // 先分别建立这两个类的对象
        Product pro1 = new Product("子弟薯片", 6.0);
        Product pro2 = new Product("冰红茶", 3.5);
        Customer cus1 = new Customer("刘知昊", "123", null);

        // 设置关联
        Set<Product> myst = new HashSet<Product>();
        myst.add(pro1);
        myst.add(pro2);
        cus1.setProducts(myst);

        // 获取Session对象
        Session sssn = HibernateUtils.getSession();
        // 开启事务
        Transaction trnsctn = sssn.beginTransaction();
        // 依次持久化PO
        sssn.save(pro1);
        sssn.save(pro2);
        sssn.save(cus1);
        // 提交事务
        trnsctn.commit();
        // 关闭Session实例并且把ThreadLocal中的副本清除
        HibernateUtils.closeSession();
    }
}
运行结果

控制台输出：

Hibernate: insert into PRODUCT (PRONAME, PRICE) values (?, ?)
Hibernate: insert into PRODUCT (PRONAME, PRICE) values (?, ?)
Hibernate: insert into CUSTOMER (USERNAME, PASSWORD) values (?, ?)
Hibernate: insert into CSTMR_PRDCT (CUSID, PROID) values (?, ?)
Hibernate: insert into CSTMR_PRDCT (CUSID, PROID) values (?, ?)

数据库中生成：
这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

双向N-M关联

前面学过，只要是双向关联，体现在OO层面上就是两边都要组合对方为属性。

在双向1-1关联中是直接组合对方的对象；在双向N-M关联中组合的是对方的对象的引用所组成的集合的上转型set。

另外，两边需要镜像地配置<set .../>元素以及其内的<many-to-many .../>元素。

Customer类的属性
    private Integer id;
    private String userName;
    private String password;
    private Set<Product> products;// 组合对方的集合
Customer.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="myPOJO">
    <class name="Customer" table="CUSTOMER">

        <!-- 指定saveOrUpdate为null时插入,非null时更新 -->
        <id name="id" column="ID" unsaved-value="null">
            <generator class="native" />
        </id>

        <property name="userName" column="USERNAME" type="string"
            not-null="true" />
        <property name="password" column="PASSWORD" type="string"
            not-null="true" />

        <!-- 用组合的set属性配置N-M关联,会自动生成一张关联关系表 -->
        <set name="products" table="CSTMR_PRDCT" cascade="all">
            <!-- 设置在连接表中关于本表的外键名 -->
            <key column="CUSID"/>
            <!-- 设置连接表中关于另一表的外键名,需要额外指出其实现类 -->
            <many-to-many class="Product" column="PROID"/>
        </set>

    </class>
</hibernate-mapping>
Product类的属性

增设对方对象的set集合。

    private Integer id;
    private String proName;
    private Double price;
    private Set<Customer> cus;// 组合对方的集合
Product.hbm.xml

镜像地配置N-M关联。

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="myPOJO">
    <class name="Product" table="PRODUCT">

        <!-- 指定saveOrUpdate为null时插入,非null时更新 -->
        <id name="id" column="ID" unsaved-value="null">
            <generator class="native" />
        </id>

        <property name="proName" column="PRONAME" type="string"
            not-null="true" />
        <property name="price" column="PRICE" type="double" not-null="true" />

        <!-- 用组合的set属性配置N-M关联,会自动生成一张关联关系表 -->
        <set name="cus" table="CSTMR_PRDCT" cascade="all">
            <!-- 设置在连接表中关于本表的外键名 -->
            <key column="PROID"/>
            <!-- 设置连接表中关于另一表的外键名,需要额外指出其实现类 -->
            <many-to-many class="Customer" column="CUSID"/>
        </set>

    </class>
</hibernate-mapping>
Main.java

如果将注释部分打开，会因为Hibernate的这两种PO共同维护了N-M关联表，而造成重复插入，会报主键冲突的错误。

在网上找了很久都没有解决的办法，所以干脆将一边的set集设定为null，这样就不会对共同维护的N-M关联表造成重复insert，毕竟目的只是将他们存入数据库中，在OO层面上不是很好看，但存到数据库里完全没问题。

package myApplication;

import java.util.HashSet;
import java.util.Set;

import myPOJO.Customer;
import myPOJO.Product;
import myTools.HibernateUtils;

import org.hibernate.Session;
import org.hibernate.Transaction;

public class Main {

    public static void main(String[] args) {
        // 先分别建立这两个类的对象
        Product pro1 = new Product("子弟薯片", 6.0, null);
        Product pro2 = new Product("冰红茶", 3.5, null);
        Customer cus1 = new Customer("刘知昊", "123", null);

        // 获取Session对象
        Session sssn = HibernateUtils.getSession();
        // 开启事务
        Transaction trnsctn = sssn.beginTransaction();

        // Set<Customer> st_pro1 = new HashSet<Customer>();
        // st_pro1.add(cus1);
        // pro1.setCus(st_pro1);

        sssn.save(pro1);

        // Set<Customer> st_pro2 = new HashSet<Customer>();
        // st_pro2.add(cus1);
        // pro2.setCus(st_pro2);

        sssn.save(pro2);

        Set<Product> st_cus1 = new HashSet<Product>();
        st_cus1.add(pro1);
        st_cus1.add(pro2);
        cus1.setProducts(st_cus1);

        sssn.save(cus1);

        // 提交事务
        trnsctn.commit();
        // 关闭Session实例并且把ThreadLocal中的副本清除
        HibernateUtils.closeSession();
    }
}
运行结果

控制台输出：

Hibernate: insert into PRODUCT (PRONAME, PRICE) values (?, ?)
Hibernate: insert into PRODUCT (PRONAME, PRICE) values (?, ?)
Hibernate: insert into CUSTOMER (USERNAME, PASSWORD) values (?, ?)
Hibernate: insert into CSTMR_PRDCT (CUSID, PROID) values (?, ?)
Hibernate: insert into CSTMR_PRDCT (CUSID, PROID) values (?, ?)

数据库内生成：
这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述
相比单向N-M关联，双向N-M关联只在OOP层面多做了文章，在数据库层面上还是完全一样的结构。

大桔骑士v
关注
专栏目录
Hibernate：one-to-many（一对多）关联映射详解
SirouW的博客
09-04 3061
对one-to-many关联映射进行论述
Hibernate：简述many-to-one的特例（one-to-one唯一外键关联）
SirouW的博客
09-04 436
对one-to-one唯一外键关联进行分析。由于这种many-to-one的特例与many-to-one和one-to-one都有许多类似的地方，论述的内容可能不会十分详细，大多以参考这两种关系为主
hibernate5_ManyToMany多对多单向维护
01-08
hibernate5_ManyToMany多对多单向维护 hibernate5_ManyToMany多对多单向维护
hibernate many-to-many(单向和双向)--->(annotation和xml文件两种形式)
颢喆的专栏
07-30 1296
In this example you will learn how to map many-to-many relationship using Hibernate Annotations. Consider the following relationship between Student and Course entity. According to the relation
Hibernate ----- hibernate如何实现单向n:m、双向n:m
qq_36098284的博客
04-30 182
Hibernate  ----- hibernate如何实现n:m1.单向的多对多创建两个实体类，role中有一个set的集合，但是function中只有普通的4个属性。相应的配置文件如下：function.hbm.xmltest测试结果：2.双向多对多表的结构不会变化，但是指向是双向上面单项的多对多的代码不变，并在此基础上添加在function中添加一个set属性改变映射文件进行测试数据库:输出...
Hibernate学习总结：ManyToMany单向关联
【小喵】的博客
04-17 658
说明： 一、一个老师可以教许多学生，并且一个学生可以有许多老师。 二、本次使用的Hibernate版本是hibernate-release-4.3.11.Final. 先写Annotation版本： 实体类： Teacher.java： package com.buaa.hibernate.bean; import java.util.HashSet; impor
Hibernate中的Entity类之间的ManyToMany关联
成长的足迹
05-31 2635
Hibernate中的Entity类之间的ManyToMany关联，必须在数据库模式中有一个中间连接表，其中的外键作为两个实体表之间的桥梁；而实体表中没有外键。 1. ManyToMany单向关联 任选一个实体类作为owning side，设置关联如下： @Entity(name = "Person") public static class Person { @Id @G
《Hibernate学习笔记九》：多对一和一对多的关联关系
wojiushimogui的博客
05-06 1696
《Hibernate学习笔记九》：多对一和一对多的单向关联关系前面介绍了一对一的关联关系在Hibernate应该如何来实现，这篇博文就来介绍下多对一和一对多的关联关系。多对一和一对多的关联关系在我们的生活中也比较常见，例如，在我们学生时代，一个班级可以有多个学生，而一个学生只能属于一个班级，这就是一个多对一(一对多)的例子；还有在我们的工作中，一个工作小组可以有多个用户，而一个用户只能属于一个小组，
Hibernate学习笔记之ORM实体间关系“OneToOne”详解
qq_27606119的博客
08-10 1891
我们知道ORM是对象—关系映射的意思，是沟通对象和底层关系数据库之间的桥梁，可以简单的将对象和关系数据库中的表对应起来，在关系数据库中，不同的表之间存在不同的关系，比如一对一，一对多，多对多等，那怎样用Java语言在上层对底层关系进行实现呢，我们本文来详细讲述一下。
JPA 系列教程6-单向多对多
菜鸟教程
12-12 249
JPA中的@ManyToMany @ManyToMany注释表示模型类是多对多关系的一端。 @JoinTable 描述了多对多关系的数据表关系。 name 属性指定中间表名称 joinColumns 定义中间表与Teacher 表的外键关系 inverseJoinColumns属性定义了中间表与另外一端(Student)的外键关系 单向多对多表的ddl语句 CREATE TABL...
Hibernate关系映射（六）多对多单向关联@ManyToMany Annotation方式
MurcielagoAN的专栏
03-09 4816
本篇介绍多对多的单向关联，多对多的处理方式是，有一张中间表，中间表保存两个多方之间的关系。首先来看实际应用场景：在之前开发的系统中，应用了基于角色的控制访问，也就是RBAC模型，一个用户可能存在多种角色，一种角色也可能有多个用户，所以用户和角色之间是一个多对多的关系。实体：用户（User），具有如下属性：Id，名称（name），角色列表（roles）；实体：角色（Role），具有如下属性：Id，名称
（6）ManyToMany单向、双向：@JoinTable
FixedStar 的博客
11-12 7745
一、manytomany单向 单向是指类层面，在下面例子中老师类可以知道要教哪些学生，学生不知被哪些老师教 **需要用到连接表**@JoinTable(name="t_s", joinColumns={@JoinColumn(name="teacher_id")},inverseJoinColumns={@JoinColumn(name="student_id")} )
hibernate关系映射--单向多对多@ManyToMany
路在路上的博客
08-23 2652
1.单向多对多关联必须使用连接表，它和有链接表的单向一对多很相似 2.主要代码@ManyToMany(cascade={CascadeType.ALL}) @JoinTable(name="T_JC_test1_tese2",joinColumns=@JoinColumn(name="test1ID"),inverseJoinColumns=@JoinColumn(name="test2ID"
Hibernate中manytomany实例二（多对多单向）
张波的技术积累
05-26 2656
<br />1：User类：<br />public class User {<br />  <br /> private int id;<br /> private String name;<br /> private Set roles;<br /> <br /> public Set getRoles() {<br />  return roles;<br /> }<br /> public void setRoles(Set roles) {<br />  this.roles = roles;<b
Hibernate之多对多单向关联（ManyToMany）
qq30211478的博客
08-30 690
（一）基于注解的配置方式： 关联表名:主表表名+_下划线+从表表名, 关联到主表的外键名:主表名+_下划线+主表中的主键列名. 关联到从表的外键名:主表中用于关联的属性名+_下划线+从表的主键列名. 以上规则对于双向一对多关联同样有效. @Entity public class Store { @ManyToMany public Set getImplantedIn(
Hibernate：many-to-many（多对多）关联映射详解
SirouW的博客
09-05 1565
多对多关联映射的实现和使用
hibernate annotation方式配置实体关联关系，解决关联外键数据不存在时抛出异常的问题
Happy in Code
07-08 7886
 使用hibernate 注解配置实体类的关联关系，在many-to-one,one-to-one关联中，一边引用自另一边的属性，如果属性值为某某的数据在数据库不存在了，hibernate默认会抛出异常。解决此问题，加上如下注解就可以了：@NotFound(action=NotFoundAction.IGNORE)，意思是找不到引用的外键数据时忽略，NotFound默认是exception
Hibernate框架学习笔记：从入门到高级
而在一对一主键关联映射中，笔记分单向和双向两种情况进行了深入分析，讲解了<one-to-one>标签的用法，并给出了相关的存储和加载数据的测试。 最后，笔记提到了一对一唯一外键关联映射，这同样涉及<one-to-one>标签...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值