hibernate 一对多，多对一，一对一，多对多 映射

最新推荐文章于 2020-05-14 16:54:25 发布
最新推荐文章于 2020-05-14 16:54:25 发布
阅读量336 收藏 1
点赞数 2
分类专栏： JavaWeb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34763699/article/details/53514948
版权

1.多对一映射  many-to-one

单向多对一映射（以customer--order为例）

一个customer可以有多个order，一个order只能对应一个customer

实体类中Order中存放一个Customer的对象

customer.hbm.xml映射文件

<hibernate-mapping>
	<class table="CUSTOMERS" name="com.atguigu.hibernate.entities.n21.Customer">
		<id name="customerId" type="java.lang.Integer">
			<column name="CUSTOMER_ID"/>
			<generator class="native"/>
		</id>
		<property name="customerName" type="java.lang.String">
			<column name="CUSTOMER_NAME"/>
		</property>
	</class>
</hibernate-mapping>
order.hbm.xml文件 

<hibernate-mapping package="com.atguigu.hibernate.entities.n21">
	<class table="ORDERS" name="Order">
		<id name="orderId" type="java.lang.Integer">
			<column name="ORDER_ID"/>
			<generator class="native"/>
		</id>
		<property name="orderName" type="java.lang.String">
			<column name="ORDER_NAME"/>
		</property>
<!-- 映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系 
		name: 多这一端关联的一那一端的属性的名字 
		class: 一那一端的属性对应的类名 
		column: 一那一端在多的一端对应的数据表中的外键的名字 -->
		<many-to-one class="Customer" name="customer" column="CUSTOMER_ID"/>
	</class>
</hibernate-mapping>


注意点：

1.1 插入语句

如果先插入一的一端（customer），再插入多的一端（order）：发送三条insert语句：插入customer,order1,order2。（推荐）
如果先插入多的一端（order），再插入一的一端（customer）：先发送三条insert语句，插入order1，order2，customer，再发送两条update语句。

1.2 查询语句

（1）如果先查询多的一端的对象，默认情况下只查询了多的一端的对象，没有查询关联的一的一端的对象
（2）如果需要使用到关联的对象，才会发送sql语句，
（3）由order查询customer，若session被关闭，默认情况下会发生LazyInitializationException异常
（4）取得order对象时，默认情况下，其customer是一个代理对象

1.3 删除语句

在不设定级联关系的情况下，且1这一端的对象有n这一端的对象在引用，不能直接删除1这一端的对象

2.一对多映射one-to-many

双向一对多映射（以customer--order为例）


实体类中：
Customer中放入一个Order的set  
private Set<Order> orders = new HashSet<>();
（1.声明集合类型时，需使用接口类型。因为hibernate获取集合类型时，返回的是hibernate的一个内置的集合类型
  2.需要对set进行初始化，防止空指针异常）

Order中存放一个Customer的对象


customer.hbm.xml

<hibernate-mapping package="com.atguigu.hibernate.entities.n21.both">
    
    <class name="Customer" table="CUSTOMERS">
    
        <id name="customerId" type="java.lang.Integer">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
    
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" />
        </property>
        
        <!-- 映射 1 对多的那个集合属性 -->
        <!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->
        <!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->
        <!-- cascade 设定级联操作. 开发时不建议设定该属性. 建议使用手工的方式来处理 -->
        <!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->
        <set name="orders" table="ORDERS" order-by="ORDER_NAME DESC">  <!--一般添加 inverse="true"-->
        	<!-- 执行多的表中的外键列的名字 -->
        	<key column="CUSTOMER_ID"></key>
        	<!-- 指定映射类型 -->
        	<one-to-many class="Order"/>
        </set>
        
    </class>
    
</hibernate-mapping>


order.hbm.xml 跟之前的多对一一样 

<hibernate-mapping package="com.atguigu.hibernate.entities.n21.both">

    <class name="Order" table="ORDERS">

        <id name="orderId" type="java.lang.Integer">
            <column name="ORDER_ID" />
            <generator class="native" />
        </id>
        
        <property name="orderName" type="java.lang.String">
            <column name="ORDER_NAME" />
        </property>
        
		<!-- 
			映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系 
			name: 多这一端关联的一那一端的属性的名字
			class: 一那一端的属性对应的类名
			column: 一那一端在多的一端对应的数据表中的外键的名字
		-->
		<many-to-one name="customer" class="Customer" column="CUSTOMER_ID"></many-to-one>

    </class>
</hibernate-mapping>


注意点：

1.插入语句 insert

先插入customer，再插入order：3条insert，两条update
（因为一的一端和多的一端都维护关联关系，所以会多出两条update）
先插入order，再插入customer：3条insert，四条update
优化方案：
hibernate中通过inverse属性决定由哪一方来维护表和表之间的关系。inverse=false为主动方，inverse=true为被动方。由主动方负责维护
在没有设置inverse=true情况下，两边都负责维护关联关系
在1-n关系中，由n方负责维护有助于性能的改善
<set name="orders" table="ORDERS" inverse="true">变量名，数据库表名
<key column="CUSTOMER_ID"></key>外键的列名
<one-to-many class="Order"/>类名
<set>

2.查询语句
对n的一端的集合使用延迟加载，返回多的一端的集合是Hibernate内置的集合类型该类型具有延时加载和存放代理对象的功能
可能会抛出懒加载异常 


3.一对一映射  one-to-one

3.1基于外键的一对一映射

一端使用many-to-one,一端使用 one-to-one

以  department--manager为例

Department实体类中放一个Manager对象

Manager实体类中放一个Department对象


department.hbm.xml

<hibernate-mapping>

    <class name="com.atguigu.hibernate.one2one.foreign.Department" table="DEPARTMENTS">

        <id name="deptId" type="java.lang.Integer">
            <column name="DEPT_ID" />
            <generator class="native" />
        </id>
        
        <property name="deptName" type="java.lang.String">
            <column name="DEPT_NAME" />
        </property>
		
		<!-- 使用 many-to-one 的方式来映射 1-1 关联关系  需在外键上加上唯一约束-->
		<many-to-one name="mgr" class="com.atguigu.hibernate.one2one.foreign.Manager" 
			column="MGR_ID" unique="true"></many-to-one>	        
			        
    </class>
</hibernate-mapping>

manager.hbm.xml 

<hibernate-mapping>

    <class name="com.atguigu.hibernate.one2one.foreign.Manager" table="MANAGERS">
        
        <id name="mgrId" type="java.lang.Integer">
            <column name="MGR_ID" />
            <generator class="native" />
        </id>
        
        <property name="mgrName" type="java.lang.String">
            <column name="MGR_NAME" />
        </property>
        
        <!-- 映射 1-1 的关联关系: 在对应的数据表中已经有外键了, 当前持久化类使用 one-to-one 进行映射 -->
        <!-- 
        	没有外键的一端需要使用one-to-one元素，该元素使用 property-ref 属性指定使用被关联实体主键以外的字段作为关联字段
         -->
        <one-to-one name="dept" 
        	class="com.atguigu.hibernate.one2one.foreign.Department"
        	property-ref="mgr"></one-to-one>
        
    </class>
    
</hibernate-mapping>

（1）保存操作 
建议先保存manager，再保存department。可以减少一条update语句
（2）查询操作
在查询没有外键的对象时，使用的是左外连接，一并查询出其关联对象，并进行初始化

3.2基于主键的一对一映射

department.hbm.xml 

<hibernate-mapping package="com.atguigu.hibernate.one2one.primary">

    <class name="Department" table="DEPARTMENTS">

        <id name="deptId" type="java.lang.Integer">
            <column name="DEPT_ID" />
            <!-- 使用外键的方式来生成当前的主键 -->
            <generator class="foreign">
            	<!-- property 属性指定使用当前持久化类的哪一个属性的主键作为外键 -->
            	<param name="property">mgr</param>
            </generator>
        </id>
        
        <property name="deptName" type="java.lang.String">
            <column name="DEPT_NAME" />
        </property>
		
		<!--  
		采用 foreign 主键生成器策略的一端增加 one-to-one 元素映射关联属性,
		其 one-to-one 节点还应增加 constrained=true 属性, 以使当前的主键上添加外键约束
		-->
		<one-to-one name="mgr" class="Manager" constrained="true"></one-to-one>
					        
    </class>
</hibernate-mapping>

manager.hbm.xml 

<hibernate-mapping>

    <class name="com.atguigu.hibernate.one2one.primary.Manager" table="MANAGERS">
        
        <id name="mgrId" type="java.lang.Integer">
            <column name="MGR_ID" />
            <generator class="native" />
        </id>
        
        <property name="mgrName" type="java.lang.String">
            <column name="MGR_NAME" />
        </property>
        
        <one-to-one name="dept" 
        	class="com.atguigu.hibernate.one2one.primary.Department"></one-to-one>
        
    </class>
    
</hibernate-mapping>


先插入哪一个都不会有多余的update


4.多对多映射

many-to-many

做法：使用一张中间表

以catagory--item  为例

实体类：

Category中放一个item的Set，Item中放一个Category 的Set

Category.hbm.xml

<hibernate-mapping package="com.atguigu.hibernate.n2n">

    <class name="Category" table="CATEGORIES">
    
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
    
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        
        <!-- table: 指定中间表 -->
        <set name="items" table="CATEGORIES_ITEMS">
            <key>
                <column name="C_ID" />
            </key>
            <!-- 使用 many-to-many 指定多对多的关联关系. column 执行 Set 集合中的持久化类在中间表的外键列的名称  -->
            <many-to-many class="Item" column="I_ID"></many-to-many>
        </set>
        
    </class>
</hibernate-mapping>

item.hbm.xml 

<hibernate-mapping>

    <class name="com.atguigu.hibernate.n2n.Item" table="ITEMS">
        
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        
        <set name="categories" table="CATEGORIES_ITEMS" inverse="true">
        	<key column="I_ID"></key>
        	<many-to-many class="com.atguigu.hibernate.n2n.Category" column="C_ID"></many-to-many>
        </set>
        
    </class>
</hibernate-mapping>
注意：

1.表名相同  2.列名交叉对应  3.一方放弃维护中间表，避免主键冲突

单向多对多时，实体类中去掉一个set，并去掉对应的映射即可（inverse="false"）














极光舞者
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate一对多关联映射学习小结
08-29
主要介绍了hibernate一对多关联映射学习小结,需要的朋友可以参考下
Hibernate的多对一
Julyraining的博客
12-04 303
之前一直很迷惑，Hibernate的多对一和数据库表的多对一有什么关系？答案居然是没有关系。 Hibernate的多对一主要是为了便于管理数据库，主要是CIDR操作。 而数据库的多对一则是为了维持数据库的参照完整性。 两者之间没有直接的关系。 比如建立一个数据库，有文章、分类两个表 文章（文章编号，分类编号、文章内容） 分类（分类编号、分类名称） 文章表的分类编号属性参照分类
Hibernate+MYSQL中一对多、多对多的关联关系映射的使用以及关联关系中的级联
bruceluo_的博客
11-03 252
一对多关联关系映射 一对多映射关系是由“多"的一方指向”一“的一方。在表示”多“的一方数据表中增加一个外键，来指向”一“的一方的数据表，”一“的一方作为主表，而"多”的一方作为从表。 下面以客户和订单的关联关系来讲解。 首先是建立一个实体类Customer，其中包括客户属性id和name,Set集合orders是订单集合，表示一个客户有多个订单。 package cn.bruceluo....
hibernate一对多实例
u011004598的专栏
11-23 114
在Customer和Order的一对多例子中： Order.hbm.xml配置文件中的Order类的orderNumber属性为值类型，而customer属性为实体类型，实体类型具有单独的OID many-to-one元素的属性(在这个例子里是Order.hbm.xml配置文件里用到many-to-one)： name:设定待映射的持久化类的属性名，此处为Order类的customer...
《精通Hibernate》学习(5)——映射一对多关联关系
OOM
01-04 1624
在域模型中，类和类之间最普通的关系就是关联关系。在UML语言中，关联是有方向的。以客户（Customer）和订单（Order）的关系为例，一个客户可以发出多个订单，而一个订单只能属于一个客户。 从Order到Customer的关联是多对一关联，这意味着每个Order对象都会引用一个Customer对象，因此在Order类中应该定义一个Customer类型的属性，来引用所关联的Customer对象
（八）Hibernate的一对多关联关系
weixin_34318326的博客
08-09 58
一、概述 例如，以客户(Customer)和订单(Order)为例，一个客户能有多个订单，一个订单只能有一个客户。 从Customer到Order是一对多关联，在java类中的面向对象设计应该一个Customer对象包含多个Order对象，因此应该定义一个集合，来包含所有的Order对象。 从Order到Customer是多对一关联，在java类中设计每个Order对象需要...
Hibernate的一对多关联关系（单向和双向）
Alan_Xiang的博客
12-04 5264
在领域模型中，类与类之间最普遍的关系就是关联关系。在 UML 中，关联是有方向的。以 Customer 和 Order 为例：一个用户能发出多个订单, 而一个订单只能属于一个客户。从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联。 　　单向n-1的关联关系　　单向 n-1 关联只需从 n 的一端可以访问 1 的一端。 　　域模型：从
Hibernate之一对多（多对一）
aa8102980的博客
01-02 82
一、双向关联级联保存客户订单 1、搭建环境，项目结构如下 2、代码及配置如下(数据库里订单表不能用order，因为order是数据库关键字)（客户外键cid和订单表外键cid要在配置中写一致） package com.hjp.onetomany; import java.util.HashSet; import java.util.Set; /** *...
hibernate-1对多-customer和order-demo基于注解
weixin_45030728的博客
05-14 151
一个顾客，可以有多个订单 order package cn.hgu.domain; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinCo
hibernate(一对多，多对一映射)操作
07-18
hibernate基于 一对多、多对一映射写的一个增加，查询，删除，修改的demo，内附数据库脚本
hibernate一对多，多对一，一对多双向关联
03-22
NULL 博文链接：https://huihai.iteye.com/blog/901171
hibernate多对一、一对一、一对多、多对多映射的理解（经典）
07-25
hibernate中对实体类映射文件的理解（多对一、一对一、一对多、多对多），文章给出了实例类图、数据表结构、相关测试以及说明。
JSP开发之hibernate之单向多对一关联的实例
01-08
和单向一对多不同的是：一对多是在意的一方的一方定义set集合，在映射文件中 ：单向多对一，简单很多在多的一方定义一的一方类的实例，在映射文件中： 持久化类 column=外键的类名>  Java代码:  Grade...
Hibernate一对多映射配置详解
04-18
Hibernate一对多映射配置详解，很值得借鉴
hibernate 多对一映射
11-20
hibernate 多对一映射 适合初学者
电信塔施工方案.doc
04-27
5G通信行业、网络优化、通信工程建设资料。
29-【智慧城市与政府治理分会场】10亿大数据助推都市治理-30页.pdf
04-27
29-【智慧城市与政府治理分会场】10亿大数据助推都市治理-30页.pdf
ABB IRC5 Compact 机器人产品手册
最新发布
04-27
ABB IRC5 Compact 机器人产品手册
LTE容量优化高负荷小区优化指导书.docx
04-27
5G通信行业、网络优化、通信工程建设资料
hibernate映射一对一 一对多 多对多
09-07
在Hibernate中，对于一对一、一对多和多对多的关系，我们可以通过以下方式进行映射。 一对一关系：在Hibernate中，可以通过主键关联和外键关联来实现一对一关系的映射。主键关联是指两个实体之间的关联通过主键来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值