Hibernate（三）之映射关系

古城微笑少年丶 2022-09-21 13:02 208阅读 0赞

一、概念：  
  
关系：名词，事物之间相互作用、相互联系的状态。  
  
关联：名词：表示对象（数据库表）之间的关系；动词：将对象（数据库表）之间通过某种方式联系起来。  
  
映射：将一种形式转化为另一种形式，包括关系。  
  
级联：动词，有关系的双方中操作一方，另一方也将采取一些动作。  
  
  
  
值类型：对象不具备数据库同一性，属于一个实体实例其持久化状态被嵌入到所拥有的实体的表行中，没有标识符。  
  
实体类型：具有数据库标识符。  
  
  
二、数据库：  
  
1、关系  
  
2.1.1、一对一、一对多、多对多  
  
2.1.2、如何表示？ 外键+索引  
  
2、级联：  
  
2.2.1、级联删除  
三、面向对象语言中（Java中）：  
  
1、关系  
  
3.1.1、一对一、一对多、多对多  
  
3.1.2、如何表示？ 实例变量（对象+集合）  
  
2、级联：  
  
3.2.1、级联删除  
  
3.2.2、级联更新  
  
3.2.3、级联保存  
  
  
  
  
四、如何把数据库关系表示为面向对象中的关系：  
  
1、关联：将数据库表之间的关系转化为对象之间的关系；在Hibernate中总指实体之间的关系。  
  
2、映射：完成java对象到数据库表的双向转换。  
  
3、级联（可选）：将数据库中的级联转化为对象中的级联（两者（对象和数据库表）没关系）。  
  
4、Hibernate的表和对象的映射：  
  
1、实体类型映射：  
  
4.1.1、主键之间的映射  
  
4.1.2、类属性与表字段的映射  
  
4.1.3、组件映射  
  
4.1.4、集合映射  
  
2、实体关联关系映射：  
  
4.2.1、关联关系映射  
  
  
五、Hibernate映射示例：  
  
5.1、实现  
  
5.1.1、数据库表定义(主表)  
  
5.1.1.1、用户表  
  
  
CREATE TABLE TBL\_USER (  
UUID NUMBER(10) NOT NULL,  
NAME VARCHAR2(100),  
AGE NUMBER(10) NOT NULL,  
PROVINCE VARCHAR2(100),  
CITY VARCHAR2(100),  
STREET VARCHAR2(100),  
CONSTRAINT PK\_USER PRIMARY KEY(UUID));  
  
5.1.1.2、用户普通信息表(一个用户有一个资料)  
  
  
CREATE TABLE TBL\_USER\_GENERAL (  
UUID NUMBER(10) NOT NULL,  
REALNAME VARCHAR2(10),  
GENDER VARCHAR2(10),  
BIRTHDAY NUMBER(10),  
HEIGHT NUMBER(10),  
WEIGHT NUMBER(10) ,  
CONSTRAINT PK\_USER\_GENERAL PRIMARY KEY(UUID),  
CONSTRAINT FK\_USER\_GENERAL FOREIGN KEY(UUID)  
REFERENCES TBL\_USER(UUID));  
  
5.1.1.3、农场表(一个用户有多个农场)  
  
  
CREATE TABLE TBL\_FARM (  
UUID NUMBER(10) NOT NULL,  
NAME VARCHAR2(10),  
FK\_USER\_ID NUMBER(10),  
CONSTRAINT PK\_FARM PRIMARY KEY(UUID),  
CONSTRAINT FK\_USER\_FARM FOREIGN KEY(FK\_USER\_ID)  
REFERENCES TBL\_USER(UUID));  
  
5.1.2、对象定义  
  
5.1.2.1、用户地址Model  
  
  
package cn.javass.h3test.model;  
public class AddressModel implements java.io.Serializable \{  
private String province;//省  
private String city;//市  
private String street;//街道  
\}  
  
5.1.2.2、用户Model  
  
  
package cn.javass.h3test.model;  
import java.util.HashSet;  
import java.util.Set;  
public class UserModel implements java.io.Serializable \{  
private int uuid;  
private String name;//名称  
private int age;//年龄  
private AddressModel address;//地址  
private UserGeneralModel userGeneral;//用户普通信息  
private Set<FarmModel> farms = new HashSet<FarmModel>();//拥有的农场  
\}  
  
5.1.2.3、用户普通信息Model  
  
  
package cn.javass.h3test.model;  
public class UserGeneralModel implements java.io.Serializable \{  
private int uuid;  
private String realname;//真实姓名  
private String gender;//性别  
private String birthday;//生日  
private int weight;//体重  
private int height;//身高  
private UserModel user;//所属用户  
\}  
  
5.1.2.4、农场Model  
  
  
package cn.javass.h3test.model;  
public class FarmModel implements java.io.Serializable \{  
private int uuid;  
private String name;//农场的名称  
private UserModel user;//所属用户  
\}  
  
  
  
  
  
5.2、配置  
5.2.1、实体类型映射：  
  
5.2.1.1、主键的映射（UserModel.hbm.xml）  
  
  
<id name="uuid">  
<generator class="sequence">  
<param name="sequence">user\_uuid</param>  
</generator>  
</id>  
  
5.2.1.2、类属性与表字段的映射（UserModel.hbm.xml）  
  
  
<property name="name"/>  
  
  
  
5.2.1.3、组件映射（UserModel.hbm.xml）  
  
  
<component name="address" class="cn.javass.h3test.model.AddressModel">  
<property name="province"/>  
<property name="city"/>  
<property name="street"/>  
</component>  
  
5.2.1.4、集合映射(Set、List、Map) （都是通过外键连接的，，，默认延迟抓取）  
  
Set:  
  
  
private Set<String> farmSet = new HashSet<String>();  
  
  
  
  
<set name="farmSet" table="TBL\_FARM" >  
<key column="fk\_user\_id"/><!—该外键是tbl\_farm的-->  
<element type="string" column="name"/>  
</set>  
  
  
  
  
  
  
private List<String> farmList = new ArrayList<String>();  
  
  
  
  
<list name="farmList" table="TBL\_FARM">  
<key column="fk\_user\_id"/>  
<list-index column="uuid"></list-index>  
<element type="string" column="name"/>  
</list>  
  
  
  
  
  
  
private Map<Integer, String> farmMap = new HashMap<Integer, String>();  
  
  
  
  
<map name="farmMap" table="TBL\_FARM">  
<key column="fk\_user\_id"/>  
<map-key type="int" column="uuid"/>  
<element type="string" column="name"></element>  
</map>  
  
  
  
对于集合类型默认是延迟加载的，且只能单向导航，不能双向。  
  
  
  
  
  
5.2.2、实体关联关系映射：  
  
5.2.2.1、单向关联关系映射，不演示。  
  
5.2.2.2、双向关联关系映射  
  
  
  
  
  
  
单向  
定义：不知道另一端什么情况，获取一端另一端自动获取，因为单向，你不知道另一侧是什么。  
如 class A\{ B b;\}  
class B\{ \}  
只能从A导航到B，不能从B导航到A  
关系维护：另一端维护，如B维护  
双向  
定义：知道另一端（两个单向），从一端获取另一端，从另一端也能获取一端  
如 class A\{ B b;\}  
class B\{ A a;\}  
只能从A导航到B，也能从B导航到A  
关系维护：两端，对关联的一侧所作的改变，会立即影响到另一侧  
  
关联的多样性：  
从一侧看是多对一，从另一侧看是一对多  
另外还有一对一、多对多  
  
EJB CMP：天生双向，对关联的一侧所作的改变，会立即影响到另一侧，  
如userGeneral.set(user)，则自动调用user.setUserGeneral(userGeneral)  
Hibernate、JPA：天生单向，两侧关系的维护是不同的关联，必须手工维护  
如userGeneral.set(user)，则需要手工调用user.setUserGeneral(userGeneral)。  
  
  
  
  
  
  
  
5.2.2.3、一对一主键关系映射(非延迟抓取)  
  
配置1（UserModel.hbm.xml）  
  
  
<one-to-one name="userGeneral" cascade="all"/>  
  
配置2（UserGeneralModel.hbm.xml）  
  
  
<id name="uuid">  
<generator class="foreign">  
<param name="property">user</param>  
</generator>  
</id>  
<one-to-one name="user"  
class="cn.javass.h3test.model.UserModel"/>  
  
  
关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。  
  
  
  
  
  
测试：保存对象，只需保存user，自动级联保存用户信息Model  
  
  
UserModel user = new UserModel();  
user.setName("昵称");  
UserGeneralModel userGeneral = new UserGeneralModel();  
userGeneral.setRealname("真实姓名");  
userGeneral.setUser(user);  
user.setUserGeneral(userGeneral);  
session.save(user);  
//若没有cascade="all",这句必须  
//session.save(userGeneral);  
  
1、一对一必须手工维护双向关系。  
  
  
  
2、cascade="all"：表示保存user时自动保存userGeneral，否则还需要一条save（userGeneral）  
  
3、constrained：添加把userGeneral表的主键映射到user主键的外键约束  
  
  
  
  
  
5.2.2.4、一对多关系映射（父/子关系映射）  
  
配置1（UserModel.hbm.xml）  
  
  
<set name="farms" cascade="all">  
<key column="fk\_user\_id"/>  
<one-to-many class="cn.javass.h3test.model.FarmModel"/>  
</set>  
  
  
  
配置2（FarmModel.hbm.xml）  
  
  
<many-to-one name="user" column="fk\_user\_id"  
class="cn.javass.h3test.model.UserModel">  
  
  
测试：保存对象，只需保存user，自动级联保存用户信息Model  
  
  
  
  
UserModel user = new UserModel();  
user.setName("昵称");  
UserGeneralModel userGeneral = new UserGeneralModel();  
userGeneral.setRealname("真实姓名");  
userGeneral.setUser(user);  
user.setUserGeneral(userGeneral);  
FarmModel farm = new FarmModel();  
farm.setName("farm1");  
farm.setUser(user);  
user.getFarms().add(farm);  
//session.save(farm);//若没有cascade=all的话需要这条语句  
session.save(user);  
  
以上配置有问题：  
  
  
  
  
insert into TBL\_USER (name, age, province, city, street, uuid) values (?, ?, ?, ?, ?, ?)  
  
insert into TBL\_USER\_GENERAL (realname, gender, birthday, weight, height, uuid) values (?, ?, ?, ?, ?, ?)  
  
insert into TBL\_FARM (name, fk\_user\_id, uuid) values (?, ?, ?)  
  
update TBL\_FARM set fk\_user\_id=? where uuid=?  
  
  
  
1、持久化user(UserModel)；  
  
2、持久化user的一对一关系，即userGeneral(UserGeneralModel)；  
  
3、持久化user的一对多关系，即farms(Set<FarmModel>)；  
  
3.1、首先发现farm是TO，级联save；(因为在这可能是PO，PO的话就应该update，而不是save)；  
  
3.2、其次发现farm在farms集合中，因此需要更新外键（fk\_user\_id）,即执行“update TBL\_FARM set fk\_user\_id=? where uuid=? “。  
  
解决这个问题：  
  
  
  
告诉Hibernate应该只有一端来维护关系（外键），另一端不维护；通过指定<set>端的inverse=”true”，表示关系应该由farm端维护。即更新外键（fk\_user\_id）将由farm端维护。  
  
  
  
配置修改（UserModel.hbm.xml）  
  
  
  
  
<set name="farms" cascade="all" inverse="true">  
<key column="fk\_user\_id"/>  
<one-to-many class="cn.javass.h3test.model.FarmModel"/>  
</set>  
  
再测试：保存对象，只需保存user，自动级联保存用户信息Model  
  
  
  
  
UserModel user = new UserModel();  
user.setName("昵称");  
UserGeneralModel userGeneral = new UserGeneralModel();  
userGeneral.setRealname("真实姓名");  
userGeneral.setUser(user);  
user.setUserGeneral(userGeneral);  
  
FarmModel farm = new FarmModel();  
farm.setName("farm1");  
farm.setUser(user);  
user.getFarms().add(farm);  
  
//session.save(farm);//若没有cascade=all的话需要这条语句  
session.save(user);  
  
更新外键，需要修改FarmModel的外键并update：  
  
  
insert into TBL\_USER (name, age, province, city, street, uuid) values (?, ?, ?, ?, ?, ?)  
  
insert into TBL\_USER\_GENERAL (realname, gender, birthday, weight, height, uuid) values (?, ?, ?, ?, ?, ?)  
  
insert into TBL\_FARM (name, fk\_user\_id, uuid) values (?, ?, ?)  
  
级联删除  
  
1、当删除user时自动删除user下的farm  
  
  
  
  
user = (UserModel) session.get(UserModel.class, 1);  
session.delete(user);  
  
结果：  
  
  
  
  
  
  
Hibernate: delete from TBL\_USER\_GENERAL where uuid=?  
Hibernate: delete from TBL\_FARM where uuid=?  
Hibernate: delete from TBL\_USER where uuid=?  
  
  
  
2、删除user中的farms的一个元素  
  
  
  
  
UserModel user =  
(UserModel) session.get(UserModel.class, 118);  
FarmModel farm = (FarmModel) user.getFarms().toArray()\[user.getFarms().size() - 1\];  
user.getFarms().remove(farm);//1.必须先从集合删除  
session.delete(farm);//2.然后才能删除  
  
  
  
结果：  
  
  
  
  
Hibernate: delete from TBL\_FARM where uuid=?  
  
如果将子对象从集合中移除，实际上我们是想删除它。要实现这种要求，就必须使用cascade="all-delete-orphan"。无需再调用session.delete(farm)  
  
  
  
  
  
  
  
5.2.2.5、多对多关系映射：不用  
  
为什么不使用多对多：当添加新字段时给谁？  
  
那实际项目如何用：拆成两个一对多。  
  
  
  
  
  
  
  
  
六、涉及的SQL语句会按照下面的顺序发出执行：  
  
1、查询  
  
1、所有对实体进行插入的语句，其顺序按照对象执行Session.save()的时间顺序  
  
2、所有对实体进行更新的语句  
  
  
  
3、所有进行集合插入的语句 （实体类型）  
  
4、所有对集合元素进行删除、更新或插入的语句 （值类型）  
  
5、所有进行集合删除的语句 （实体类型）  
  
  
  
6、所有对实体进行删除的语句，其顺序按照对象执行Session.delete()的时间顺序  
  
（有一个例外是，如果对象使用native方式来生成ID（持久化标识）的话，它们一执行save就会被插入。）  
  
  
  
  
七、影响关系映射抓取的cfg配置：  
  
  
  
hibernate.max\_fetch\_depth  
  
  
为单向关联(一对一, 多对一)的外连接抓取（outer join fetch）树设置最大深度. 值为0意味着将关闭默认的外连接抓取.  
  
取值 建议在0到3之间取值  
  
hibernate.default\_batch\_fetch\_size  
  
  
为Hibernate关联的批量抓取设置默认数量.  
  
取值 建议的取值为4, 8, 和16  
  
如果你的数据库支持ANSI, Oracle或Sybase风格的外连接, 外连接抓取通常能通过限制往返数据库次数 (更多的工作交由数据库自己来完成)来提高效率. 外连接抓取允许在单个SELECTSQL语句中， 通过many-to-one, one-to-many, many-to-many和one-to-one关联获取连接对象的整个对象图.  
  
将hibernate.max\_fetch\_depth设为0能在全局 范围内禁止外连接抓取. 设为1或更高值能启用one-to-one和many-to-one外连接关联的外连接抓取, 它们通过 fetch="join"来映射.  
  
  
  
  
  
  
  
  
八、抓取策略  
1、抓取策略定义  
  
抓取策略（fetching strategy） 是指：当应用程序需要在（Hibernate实体对象图的）关联关系间进行导航的时候， Hibernate如何获取关联对象的策略。抓取策略可以在O/R映射的元数据中声明，也可以在特定的HQL 或条件查询（Criteria  
Query）中重载声明。  
  
2、Hibernate3 定义了如下几种抓取策略：  
  
连接抓取（Join fetching） - Hibernate通过 在SELECT语句使用OUTER JOIN（外连接）来 获得对象的关联实例或者关联集合。 默认非延迟加载  
集合抓取需要通过配置fetch="join"来指定。下行数据太多（冗余），IO  
  
  
  
  
//配置 fetch="join"( lazy="true"不起作用了)  
session.get(UserModel.class, 118);//是获取对象的  
Hibernate: select … from TBL\_USER usermodel0\_, TBL\_FARM farms1\_  
where usermodel0\_.uuid=farms1\_.fk\_user\_id(+) and usermodel0\_.uuid=?  
  
查询抓取（Select fetching） - 另外发送一条 SELECT 语句抓取当前对象的关联实体或集合。除非你显式的指定lazy="false"禁止延迟抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条select语句。  
  
  
  
配置 lazy=”true”默认（或者lazy="false" fetch="select"）  
session.get(UserModel.class, 118);//是获取对象的  
Hibernate: select … from TBL\_USER usermodel0\_ where usermodel0\_.uuid=?  
Hibernate: select … from TBL\_FARM farms0\_ where farms0\_.fk\_user\_id=?  
  
默认用于lazy="true"情况的集合抓取，如果lazy="false"，需要指定fetch="select"来通过查询抓取。会造成DB的CPU利用率非常高，计算密集  
  
  
  
  
  
子查询抓取（Subselect fetching） - 另外发送一条SELECT 语句抓取在前面查询到（或者抓取到）的所有实体对象的关联集合。除非你显式的指定lazy="false" 禁止延迟抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条select语句。  
当通过Query等接口查询多个实体时，如果指定fetch="subselect"则将通过子查询获取集合  
  
  
配置fetch="subselect"  
Query q = session.createQuery("from UserModel");  
System.out.println(q.list());  
Hibernate: select …… from TBL\_USER usermodel0\_  
Hibernate: select …… from TBL\_FARM farms0\_ where farms0\_.fk\_user\_id  
in (select usermodel0\_.uuid from TBL\_USER usermodel0\_)  
  
  
  
批量抓取（Batch fetching） - 对查询抓取的优化方案， 通过指定一个主键或外键列表，Hibernate使用单条SELECT语句获取一批对象实例或集合。  
  
当通过Query等接口查询多个实体时，如果指定farm的batch-size="……"则将通过使用单条SELECT语句获取一批对象实例或集合。  
  
  
  
  
Query q = session.createQuery("from UserModel");  
List<UserModel> userList = q.list(); System.out.println(userList);  
Hibernate: select … TBL\_USER usermodel0\_  
Hibernate: select … from TBL\_FARM farms0\_ where farms0\_.fk\_user\_id in (?, ?)  
  
  
  
  
  
  
  
  
  
可指定全局批量抓取策略： hibernate.default\_batch\_fetch\_size，取值：建议的取值为4, 8, 和16。  
  
如果batch-size="4"，而某个user有19个农场，Hibernate将只需要执行五次查询，分别为4、4、4、4、3。  
  
  
  
测试必须数据量足够多，，如果只有一条不行  
  
  
  
  
  
  
  
  
  
3、使用延迟属性抓取（Using lazy property fetching）  
  
属性的延迟载入要求在其代码构建时加入二进制指示指令（bytecode instrumentation），如果你的持久类代码中未含有这些指令， Hibernate将会忽略这些属性的延迟设置，仍然将其直接载入。  
  
Hibernate3对单独的属性支持延迟抓取，这项优化技术也被称为组抓取（fetch groups）。 请注意，该技术更多的属于市场特性。在实际应用中，优化行读取比优化列读取更重要。但是，仅载入类的部分属性在某些特定情况下会有用，例如在原有表中拥有几百列数据、数据模型无法改动的情况下。  
  
  
  
  
  
4、Hibernate在抓取时会lazy区分下列各种情况：  
  
立即抓取 - 当宿主被加载时，关联、集合或属性被立即抓取。  
  
Lazy collection fetching，延迟集合抓取- 直到应用程序对集合进行了一次操作时，集合才被抓取。（对集合而言这是默认行为。）  
  
Extra-lazy" collection fetching,"Extra-lazy"集合抓取 -对集合类中的每个元素而言，都是直到需要时才去访问数据库。除非绝对必要，Hibernate不会试图去把整个集合都抓取到内存里来（适用于非常大的集合）。  
  
  
// lazy="extra"  
Query q = session.createQuery("from UserModel");  
Iterator it = q.iterate(); System.out.println(((UserModel)it.next()).getFarms().size());  
//或  
List<UserModel> userList = q.list(); System.out.println(userList.get(0).getFarms().size());  
  
Hibernate: select usermodel0\_.uuid as col\_0\_0\_ from TBL\_USER usermodel0\_  
Hibernate: select … from TBL\_USER usermodel0\_ where usermodel0\_.uuid=?  
Hibernate: select count(uuid) from TBL\_FARM where fk\_user\_id =?  
//或  
Hibernate: select … from TBL\_USER usermodel0\_  
Hibernate: select count(uuid) from TBL\_FARM where fk\_user\_id =?  
  
  
  
  
  
  
  
对于调用size()、contains、isEmpty是一种优化，不读取所有级联，而是按条件生产不同的sql。  
  
Proxy fetching，代理抓取 - 对返回单值的关联而言，当其某个方法被调用，而非对其关键字进行get操作时才抓取。  
  
  
//默认 <many-to-one name="user" ……lazy="false"/>  
FarmModel farm = (FarmModel) session.get(FarmModel.class, 121);  
System.out.println(farm.getUser().getUuid());  
  
Hibernate: select … from TBL\_FARM farmmodel0\_ where farmmodel0\_.uuid=?  
Hibernate: select … from TBL\_USER usermodel0\_ where usermodel0\_.uuid=?  
118  
  
  
  
  
// <many-to-one name="user" ……lazy="proxy"/>  
FarmModel farm = (FarmModel) session.get(FarmModel.class, 121);  
System.out.println(farm.getUser().getUuid());  
  
Hibernate: select … from TBL\_FARM farmmodel0\_ where farmmodel0\_.uuid=?  
118  
  
注：如果constrained="false"或基于主键的一对一, 不可能使用代理，Hibernate会采取预先抓取！  
  
"No-proxy" fetching,非代理抓取 - 对返回单值的关联而言，当实例变量被访问的时候进行抓取。与上面的代理抓取相比，这种方法没有那么“延迟”得厉害(就算只访问标识符，也会导致关联抓取)但是更加透明，因为对应用程序来说，不再看到proxy。这种方法需要在编译期间进行字节码增强操作，因此很少需要用到。  
  
Lazy attribute fetching，属性延迟加载 - 对属性或返回单值的关联而言，当其实例变量被访问的时候进行抓取。需要编译期字节码强化，因此这一方法很少是必要的。  
  
  
  
这里有两个正交的概念：关联何时被抓取，以及被如何抓取（会采用什么样的SQL语句）。不要混淆它们！我们使用抓取来改善性能。我们使用延迟来定义一些契约，对某特定类的某个脱管的实例，知道有哪些数据是可以使用的。  
  
  
  
  
  
九、抓取优化  
  
1、集合N+1：  
  
可以使用batch-size来减少获取次数，即如batch-size=”10”，则是N/10+1。  
  
开启二级缓存。  
  
对于集合比较小且一定会用到的可采用fetch=”join”，这样只需一条语句。  
  
2、笛卡尔积问题：  
  
  
  
  
<set name="farms" cascade="all,all-delete-orphan" inverse="true" fetch="join">  
<key column="fk\_user\_id"/>  
<one-to-many class="cn.javass.h3test.model.FarmModel"/>  
</set>  
<set name="hourses" cascade="all,all-delete-orphan" inverse="true" fetch="join">  
<key column="fk\_user\_id"/>  
<one-to-many class="cn.javass.h3test.model.HourseModel"/>  
</set>  
  
如上配置产生笛卡尔积问题。  
  
  
  
select user.\*,farm.\*,hourse.\* from UserModel user, FarmModel farm, HourseModel hourse  
  
where user.uuid=farm.fk\_user.uuid(+) and  
  
user.uuid=hourse.fk\_user.uuid(+)  
  
解决方案：  
  
1、fetch=”subselect”，子查询，每个User查询一套笛卡尔积  
  
2、完全不采用关系映射。  
  
3、大集合采用批处理，按块获取集合数据  
  
4、复杂SQL太复杂太慢：找DBA优化，索引等是否有效，是否加载了过多的无用数据，拆分SQL，按需获取数据。  
  
5、按需获取1对多中的集合。  
  
6、缓存