Hibernate学习笔记(2)

最新推荐文章于 2024-06-04 09:07:32 发布
最新推荐文章于 2024-06-04 09:07:32 发布
阅读量833 收藏 2
点赞数
分类专栏： Hibernate 文章标签： hibernate class insert c table session
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaojianfengye1/article/details/7980499
版权

1.   映射关联关系

1.1映射的种类

以客户(Customer)和订单(Order)为例子。

客户       订单

1-1         一对一单向

1-1         一对一双向

1-n         一对多单向

n-1         多对一单向

1-n         一对多双向[和多对一双向一样]

n-m        多对多单向[可以分解为一对多]

n-m        多对多双向

1.2映射多对一[单向]关联关系

属于n-1单向模式。即多个订单订单单向关联客户。建表时，订单表要引用客户表的id作为外键。

 

理解例子中的多对一单向关联关系：

多个订单[多方]对应一个客户[一方]，可以从订单自身获取该订单的客户信息（即订单知道自己属于哪个客户），但从客户上获取不到自身的订单信息（即客户不知道自己有哪些订单）。

 

实体类：

publicclass Customer {

//客户[一方]，多对一单向，找不到订单

      private Integer id; //ID

      private String name;//客户名字

}

publicclass Order {

//订单[多方]，多对一单向，可以找到客户

      private Integer id; //ID

      private String oderNum;//订单编号

      private Customer customer;//客户

}

映射文件：

一方：

      <class name="Customer"table="CUSTOMERS">

           <id name="id"column="ID" type="integer">

                 <generator class="native"/>

           </id>

           <property name="name"column="NAME" type="string"/>

      </class>

多方：

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

           <id name="id"column="ID" type="integer">

                 <generator class="native"/>

           </id>

           <property name="orderNum"column="ORDERNUM" type="string"/>

           <!-- 多对一映射

           name：多方域对象customer属性名

           class：多方域对象属性customer的类型

           column：多方域对象对应的表orders的外键 -->

           <many-to-one name="customer"class="Customer" column="CID"/>   

      </class>

保存客户和订单：

           Customerc1 = new Customer("张三");

           Ordero1 = new Order("N001");

           Ordero2 = new Order("N002");

           //设置多对一单向关联

           o1.setCustomer(c1);

           o2.setCustomer(c1);

           /*

            * 先保存订单再保存客户,

            * 结果:执行5条sql语句，3条insert,2条update

           session.save(o1);

           session.save(o2);

           session.save(c1);*/

           /*  先保存客户再保存订单,

            * 结果:只执行3条insert语句

            * 结论:保存多对一单向关联对象时，先保存一方再保存多方

            * 效率会高点。

            */

           session.save(c1);

           session.save(o1);

           session.save(o2);

查询订单：

/*

            * 当订单单向关联客户时，查询订单时

            * 会将订单关联的客户一起查询出来

            * 即o1.getCustomer()不为空

            */

           Ordero1 =(Order) session.get(Order.class, 1); //查询id为1的订单

保存订单时级联保存关联的客户：

           Customerc1 = new Customer("张三");

           Ordero1 = new Order("N001");

           Ordero2 = new Order("N002");

           //设置多对一单向关联

           o1.setCustomer(c1);

           o2.setCustomer(c1);

                 /*

            *保存订单时级联保存客户

            * 需在Order.hbm.xml中的many-to-one节点配置

            * cascade="save-update"属性，如果没有设置该属性

            * 又没有手动执行session.save(c1)则出错(TransientObjectException)。因为订单

            * 和客户是多对一单向关联关系，订单表引用了客户表的

            * id作为外键，没有执行session.save(c1)即客户表没有记录

            * 此时订单是保存不了的。

            */

session.save(o1);

           session.save(o2);

<!-- 多对一映射

           name：多方域对象customer属性名

           class：多方域对象属性customer的类型

           column：多方域对象对应的表orders的外键

           cascade：多方域对象所关联的一切对象都会同步保存和更新-->

           <many-to-one name="customer"class="Customer" column="CID" cascade="save-update"/>

* 小结：

 * 1.多对一单向关联时，保存时先保存一方再保存多方,效率较高；

 * 2.查询多方时，会自动将其关联的一方查询出来；

 * 3.当在多方的配置文件中配置了cascade="save-update"属性时，

 * 保存或更新多方时，会级联保存或更新其关联的一方。

1.3映射一对多[双向]关联关系

没有多对一双向的说法，因为它和一对多双向是同一个意思，但是有多对一单向。

 

理解例子中的一对多双向关联关系：

一个客户[一方]可以对应多个订单[多方]，每个订单对应一个客户，即可以从客户自身获取其订单信息（即客户知道自己有哪些订单），也可以从订单自身获取该订单的客户信息（即订单知道自己属于哪个客户）。

 

实体类：

publicclass Customer {

//客户[一方]，一对多双向，可以找到订单

      private Integer id; //ID

      private String name;//客户名字

      private Set<Order> orders = newHashSet<Order>();//多个订单

}

publicclass Order {

//订单[多方]，一对多双向，可以找到客户

      private Integer id; //ID

      private String orderNum;//订单编号

      private Customer customer;//客户

}

映射文件：

多方：

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

           <id name="id"column="ID" type="integer">

                 <generator class="native"/>

           </id>

           <property name="orderNum"column="ORDERNUM" type="string"/>

           <!-- 多对一映射

           name：多方域对象customer属性名

           class：多方域对象属性customer的类型

           column：多方域对象对应的表orders的外键

           <many-to-one name="customer"class="Customer" column="CID"/>

 

一方：

<class name="Customer" table="CUSTOMERS">

           <id name="id"column="ID" type="integer">

                 <generator class="native"/>

           </id>

           <property name="name"column="NAME" type="string"/>

           <!-- 一对多双向[一方]

           Set<Order>orders = new HashSet<Order>()

           name:一方的关联属性orders,是一个set集合

           table:多方域对象对应的表名

           column:多方域对象对应表的外键

           class:多方域对象的类名 -->

           <set name="orders"table="ORDERS" >

                 <key column="CID"/>

                 <one-to-many class="Order"/>

           </set>

      </class>

 

保存客户和订单：

           Customerc1 = new Customer("张三");

           Ordero1 = new Order("N001");

           Ordero2 = new Order("N002");

           //设置一对多双向关联

           c1.getOrders().add(o1);

           c1.getOrders().add(o2);

           o1.setCustomer(c1);

           o2.setCustomer(c1);

           /*先保存订单再保存客户

           7条sql，3条insert，4条update

           session.save(o1);

           session.save(o2);

           session.save(c1);

            */

           /*先保存客户再保存订单

           5条sql，3条insert，2条update

            效率较高，优先选择保存一方

           */

           session.save(c1);

           session.save(o1);

           session.save(o2);

 

查询客户或订单：

/*

           查询id为1的客户，会将其级联的订单查出来

           Customerc1 =(Customer) session.get(Customer.class, 1);

           Set<Order>orders = c1.getOrders();

           for(Order order : orders) {

                 System.out.println(order.getOrderNum());

           }*/

           /*

            * 查询id为1的订单,会将其级联的客户查出来

            */

           Ordero1 =(Order) session.get(Order.class, 1);

           System.out.println(o1.getCustomer().getName());

级联保存客户或订单：

           Customerc1 = new Customer("张三");

           Ordero1 = new Order("N001");

           Ordero2 = new Order("N002");

           //设置一对多双向关联

           c1.getOrders().add(o1);

           c1.getOrders().add(o2);

           o1.setCustomer(c1);

           o2.setCustomer(c1);

 

           /*

            *保存订单时级联保存客户

            * 需在Order.hbm.xml中的many-to-one节点配置

            * cascade="save-update"属性

           session.save(o1);

           session.save(o2);

           */

           /*

            *保存客户时级联保存订单

            * 需在Customer.hbm.xml中的set节点配置

            * cascade="save-update"属性

            */

           session.save(c1);

更新客户和订单：

有三种方式：

1.手工更新session.update(c1)和sesison.update(o1)

2.session.update(c1)要在Order.hbm.xml中配置属性cascade="save-update"

3.不使用任何session.update()语句，直接更新，原理是原因session一级缓存有快照的功能(快照只适合于更新操作).

           Customerc1 = (Customer) session.get(Customer.class, 1); //查询id为1的客户

           Ordero4 = (Order) session.get(Order.class, 4);

           c1.getOrders().add(o4);//客户变化了

           o4.setCustomer(c1);//订单变化了

           /*方式一：手工更新，同时调用update方法

           session.update(c1);

           session.update(o4);*/

           //方式二：级联更新，调用update，同时传入一方对象，并在该方配置文件设置cascade="save-update"属性

//        session.update(c1);

//        session.update(o4);

//        方式三：使用session的快照功能，不调用任何update方法

           t.commit();

           session.close();

当在双向关联时，应该在一方使用inverse=”true”属性，由多方来负责管理维护双向关系，这样可以减少update语句，如果是多方管理话，有且只有在多方发生引用变化时，hibernate才负责做update操作；如果是多方管理话，多方没有发生引用变化时，即使是一方发生变化，那么hibernate依然不负责update操作；如果单向操作，不要使用inverse属性。

* 小结：

 * 1.一对多双向关联时，保存时先保存一方再保存多方,效率较高；

 * 2.不管查询哪方都会将其级联的一方查询出来，因为是双向关联;

 * 3.当双方都配置了cascade="save-update"属性时，可以级联保存(即保存一方时另一方自动保存)

 *4.session有快照功能，当关联发生变化时，可自动更新数据库数据，与cascade="save-update"属性是否设置无关

 */

1.4映射一对一[双向]关联关系

实体类：

publicclass Person {

//人，一对一双向一方，可以找到身份证

      private Integer id;

      private String name;

      private Card card;

}

 

publicclass Card {

//身份证，一对一双向一方，可以找到人

      private Integer id;

      private String cardNO; //身份证号码

      private String location;

      private Person person;

}

映射文件：

有外键一方，即Person.hbm.xml:

<!-- 在一对一双向中，有外键一方用many-to-one标签加上unique="true"属性表示name:Person类中card属性名

                 class:card属性的类型

                 column:Person类所对应的表的外键

                 unique:对外键加上唯一约束，true表示唯一，false表示不唯一

            -->

           <many-to-one name="card"class="Card"  column="CID"unique="true"/>

无外键一方，即Card.hbm.xml:

           <!--  在一对一外键双向关联中，无外健一方使用one-to-one标签

               name:Card类的person属性

               class:Card类的person属性类型

               property-ref:Card类在对方的关联属性，即card属性-->

           <one-to-one name="person"class="Person" property-ref="card"/>

1.5映射多对多[双向]关联关系

多对多双向关联可以拆分为多对一单向关联，同过一个中间表(middle),middle表有两个字段，如：tid，sid，分别引用老师表和学生表的id作为外键。而tid和sid有是联合主键。

此时在这种关联状态下，如果由双方管理关联关系，middle会出现主键冲突，所以只能由其中一方来管理。如让老师来管理，则在学生的映射文件中设置数据inverse=“true”。叫由对方管理关联关系。

 

实体类：

publicclass Student {

//学生，多对多双向的多方，可以找到老师

      private Integer id;

      private String name;

private Set<Teacher>teacherSet = newHashSet<Teacher>(); //多个老师

}

publicclass Teacher {

//老师，多对多双向的多方，可以找到学生

      private Integer id;

      private String name;

private Set<Student>studentSet = newHashSet<Student>();//多个学生

}

映射文件：

Student.hbm.xml:

           <!-- 在多对多双向关联中，多方使用set标签和many-to-many标签

                name:Student的集合属性

                table:中间表名

                key-column:中间表引用Student表的外键

                class:Student类对应的另一个多方

                many-to-many-column:中间表引用Teacher表的外键

           -->

           <set name="teacherSet"table="MIDDLES" inverse="true">

                 <key column="SID"/>

                 <many-to-many

                      class="Teacher" column="TID"/>

           </set>

Teacher.hbm.xml:

                      <!-- 在多对多双向关联中，多方使用set标签和many-to-many标签

                name:Teacher类的集合属性

                table:中间表

                key-column:中间表引用Teacher表的外健

                class:Teacher类对应的另一个多方

                many-to-many-column:中间表引用Student表的外健

                inverse="false"表示双向关联由Teacher来管理

           -->

           <set name="studentSet"

                 table="MIDDLES"

                 cascade="delete">

                 <key column="TID"/>

                 <many-to-many

                      class="Student" column="SID"/>

           </set>

 

1.6继承映射关系(垂直关系)

有三种方案：

A每个类对应[一]张表

比较节约空间，但要有区分字段。使用<subclass>配置,每个类都要加上区分值

discriminator-value=xxx。

B每个类对应[每]张表，每张表独立，无外健关联

使用<union-subclass>配置

C每个类对应[每]张表，子类对应的表通过外健关联(推荐)

使用<joined-subclass>配置

 

实体类：

publicclass Employee {

      private Integer id;

      private String name;

}

publicclass HourEmployee extends Employee {

      private Double rate;

}

publicclass SalaryEmployee extends Employee {

      private Double salary;

}

方案一：

配置文件：

<class name="Employee" table="EMPLOYEES"discriminator-value="E">

           <id name="id"column="ID" type="integer">

                 <generator class="native"/>

           </id>

           <!-- 区分字段，只能id后面 -->

           <discriminator  column="ETYPE"type="string"/>

           <property name="name"column="NAME" type="string"/>

           <!-- 配置子类 discriminator-value:区分字段的值 -->

           <subclass name="HourEmployee"discriminator-value="HE">

                 <property name="rate"column="RATE" type="double"/>

           </subclass>

           <!-- 配置子类 -->

           <subclass name="SalaryEmployee"discriminator-value="SE">

                 <property name="salary"column="SALARY" type="double"/>

           </subclass>

      </class>

           Employeee = new Employee("员工");

           HourEmployeehe = new HourEmployee("时工", 13.5D);

           SalaryEmployeese = new SalaryEmployee("月工", 5000D);

           session.save(e);

           session.save(he);

           session.save(se);

方案二：

配置文件：

<class name="Employee" table="EMPLOYEES">

           <id name="id"column="ID" type="integer">

                 <generator class="increment"/><!-- 第二种方案，id生成策略不能用native，因为要保持三张表id的连续性 -->

           </id>

           <property name="name"column="NAME" type="string"/>

           <union-subclass name="HourEmployee"table="HOUREMPLOYEES">

                 <property name="rate"column="RATE" type="double"/>

           </union-subclass>

           <union-subclass name="SalaryEmployee"table="SALARYEMPLOYEES">

                 <property name="salary"column="SALARY" type="double"/>

           </union-subclass>

      </class>

方案三：

配置文件：

<class name="Employee" table="EMPLOYEES">

           <id name="id"column="ID" type="integer">

                 <generator class="native"/>

           </id>

           <property name="name"column="NAME" type="string"/>

           <joined-subclass name="HourEmployee"table="HOUREMPLOYEES">

                 <key column="HID"/><!-- 主/外键 -->

                 <property name="rate"column="RATE" type="double"/>

           </joined-subclass>

           <joined-subclass name="SalaryEmployee"table="SALARYEMPLOYEES">

                 <key column="SID"/>    

                 <property name="salary"column="SALARY" type="double"/>

           </joined-subclass>

      </class>

1.7组件映射

publicclass Customer {

//一对多双向 一方

      private Integer id;

      private String name;

      private Address address; //客户地址,组件

      private Set<Order> orderSet = newHashSet<Order>();

}

Customer.hbm.xml文件：

           <!-- 组件 映射address属性-->

           <component name="address"class="Address">

                 <property name="province"column="PROVINCE" type="string"/>

                 <property name="city"column="CITY" type="string"/>

                 <property name="area"column="AREA" type="string"/>

           </component>

 

xiaojianfengye1
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate 学习笔记2
06-03
经典资料＋个人心得，希望大家能喜欢
hibernate学习笔记1
08-08
【hibernate学习笔记1】 一、理解Hibernate Hibernate是一个流行的Java对象关系映射（ORM）框架，它的主要目的是简化数据库操作，通过将Java对象与数据库表进行映射，使得开发者能够以面向对象的方式处理数据，而...
struts and hibernate学习笔记
04-22
在这些学习笔记中，我们可以期待以下主题的深入探讨： 1. **Struts2基础**：包括Struts2的架构、配置文件详解、Action类的创建、结果类型配置、Interceptor的使用以及如何整合Struts2与Spring。 2. **Struts2实战*...
Hibernate学习笔记和资料
11-15
hibernate概述,hibernate入门Demo,hibernate配置文件详解(全局配置,实体类映射配置),配置实体规则,核心API详解(Configuration,sessionFactory,session,Transaction),hibernate中的对象状态以及刷新能缓存机制 ...
深入探索Stage #2：属性中的XSS注入技术
最新发布
weixin_43822401的博客
06-04 647
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8834
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3283
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 4415
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1548
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
清除浮动的五种方法
weixin_52212950的博客
02-22 2489
为什么要清除浮动？因为往往浮动后的子元素因为脱离了标准流，不能自动撑起父元素的高度，所以会对后续布局产生影响，对此清除浮动不如理解为清除浮动产生的影响更为合理。 例如：我们设置了两个盒子如图所示，粉色为父盒子，只有宽度没有高度，蓝色盒子有宽有高，粉色盒子的高由蓝盒子的高度撑开。 但是给蓝色的子盒子设置了左浮动后，脱离了标准流，无法再撑开粉盒子，可以看到粉盒子高度变成了0； 清除浮动有五种方法： 直接设置父元素的高度 额外标签法 单伪元素法 双伪元素法 ove.
HTML实现学习网站首页
做技术，坚持才是最重要的，一时的热情只是暂时的进步
02-20 4002
项目访问 reset.css /* http://meyerweb.com/eric/tools/css/reset/ v2.0 | 20110126 License: none (public domain) */ html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del
C语言经典小游戏之----推箱子
嵌入式技术开发
02-25 4587
在进行推箱子的实验中，可以使用对应的API函数来改变对应箱子的颜色，也需要根据，人在移动的过程中，可以通过方向键，并改变对应的颜色，从而实现控制人物的目的。 代码实现如下： #include<stdio.h> #include<stdlib.h> #include<string.h> #include<windows.h> #include<conio.h> int x = 0, y = 0; //存储当前使用的...
关于Dubbo的mock=true降级无法调用降级类ServiceMock的解决方案
weixin_45754452的博客
02-25 1347
问题 消费者使用mock=“true”，想调用TestServiceMock进行服务降级无法调用 原因 我的项目结构如下，首先要知道服务降级代码应该是谁执行的，服务降级是服务消费者也就是controller包处对应的服务执行的，因为我只是测试dubbo怎么使用，所以并没有分多模块，但完全可以把一个包理解为一个模块，再看下面配置文件 为什么可以把一个包当成一个模块呢，因为我把配置文件的scan改成controller包然后启动一个服务器，即消费者，如果把scan改成service则可以启动服务提供者服务器
Vue---Vue基础
前端与计算机相关知识的分享，博主的qq523235674
02-25 1399
一.Vue概述 二.Vue的基本使用 2.1Vue.js之hello world 基本实例 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <title>Document</title> </.
如此优秀的JS轮播图，写完老师都沉默了
陈新科的博客
02-17 5885
雷迪森安的乡亲们，欢迎来到老实人的前端课堂，今天我们来写个骚气磅礴的轮播图吧，内容太干，建议收藏起来慢慢看，最后我还会教大家如何免费部署上线哦~ 正片 小轮播图滑动滚播，好不好看你说了算。 结构就两行 <div id="main"> <h1>something</h1> <div class="content"> <p>You can press <kbd>▲</kbd> <kbd&
TCP/IP网络编程---Linux系统下的TCP套接字编程
xxyneymar的博客
02-21 4237
目录 第一章 理解网络编程和套接字 1.1 网络编程和套接字概要 1.2 基于Linux的文件操作 1.2.1 底层文件访问和文件描述符 1.2.2 打开文件 1.2.3 关闭文件 1.2.4 将数据写入文件 1.2.5 读取文件中的数据 第二章 套接字类型与协议设置 2.1 套接字协议及其数据传输特性 2.1.1 关于协议 2.1.2 创建套接字 第三章 地址族与数据序列 3.1 分配给套接字的IP地址与端口号 3.1.1 网络地址 3.1.2 用于区分套接字的端口号 3
CSS -- 移动端适配技术学习
秋天，黄叶坠地，凉风有信。
02-20 1537
CSS中常用的计量单位，em，rem，px的区别，vwvh，vmin，vmax 的使用，移动端适配中使用到的技术，媒体查询CSS和JS的实现方法，Flex弹性布局，flexibleJS的介绍，rem + viewPort 缩放的技术
Docker整理篇（网络与数据卷）
weixin_43118617的博客
02-23 1315
docker网络与数据卷操作和基础命令
Hibernate学习笔记：李勇教程实践
"传智播客_hibernate李勇笔记"是一个不错的学习资源，它引导初学者快速入门Hibernate，理解其基本原理和操作方式，为进一步的数据库编程打下坚实基础。通过不断的实践和学习，你可以掌握更多Hibernate的高级特性和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值