hibernate 6 映射集合和实体关联 | hibernate 实战(第二版) 第6章映射集合和实体关联 | 笔记...

值类型的set、bag、list和map
选择集合接口：
1、使用<Set>元素映射java.util.Set。使用java.util.HashSet初始化集合。它是无序且不允许重复。
2、使用<Set>映射java.util.SortedSet。且sort属性可以设置成比较器或者用于内存的排序的自然顺序。使用
java.util.TreeSet实例初始化集合。
3、使用<list>映射java.util.List。在集合表中用一个额外的索引列保存每个元素的位置。使用java.util.ArrayList初始化。
4、使用<bag>或者<idbag>映射java.util.Collection。java没有Bag接口或者实现；然而，java.util.Collection允许包
语义。hibernate支持持久化的包。使用java.util.ArrayList初始化包集合。
5、使用<map>映射java.util.Map，保存键和值对。使用java.util.HashMap初始化属性。
6、使用<map>映射java.util.SortedMap。且sort属性可以设置为比较器或者用于内存排序的自然顺序。使用
java.util.TreeMap实例初始化该集合。
7、hibernate使用<primitve-array>和<array>支持数组。但是他们很少使用在领域模型中。因为hibernate无法
包装数组属性，没有字节码基础设施（BCI），就失去了延迟加载，以及持久化集合优化过的脏检查、基本
的便利和性能特性。





映射Set:

无序不允许重复：
类：

view plain copy to clipboard print ?

1. /**
2. * 实现String类型的set集合，非class（实体bean）集合
3. */
4. publicclassItemimplementsSerializable {
5. privateintitemId;
6. privateString itemName;
8. //不允许重复
9. privateSet<String> images =newHashSet<String>();

配置文件：

view plain copy to clipboard print ?

1. <hibernate-mappingpackage="cn.partner4java.set">
3. <classname="Item">
4. <id name="itemId">
5. <generatorclass="native"/>
6. </id>
7. <property name="itemName"type="string"/>
8. <!-- 映射了一个无序的string集合 -->
9. <set name="images"table="ITEM_IMAGES">
10. <key column="ITEM_ID"></key>
11. <element type="string"column="FILENAME"not-null="true"></element>
12. </set>
14. </class>
16. </hibernate-mapping>

插入2：

view plain copy to clipboard print ?

1. Item item =newItem();
2. item.setItemName("hello world");
3. item.getImages().add("image1");
4. item.getImages().add("image1");

hibernate 打印 sql：
Hibernate: insert into Item (itemName) values (?)
Hibernate: insert into ITEM_IMAGES (ITEM_ID, FILENAME) values (?, ?)
插入2：

view plain copy to clipboard print ?

1. Item item =newItem();
2. item.setItemName("hello world");
3. item.getImages().add("image1");
4. item.getImages().add("image2");

hibernate打印sql：
Hibernate: insert into Item (itemName) values (?)
Hibernate: insert into ITEM_IMAGES (ITEM_ID, FILENAME) values (?, ?)
Hibernate: insert into ITEM_IMAGES (ITEM_ID, FILENAME) values (?, ?)





映射bag：
有序允许重复：
类：

view plain copy to clipboard print ?

1. /**
2. * 允许重复元素的无序集合bag
3. */
4. publicclassItemimplementsSerializable {
5. privateInteger itemId;
6. privateString itemName;
7. privateCollection<String> images =newArrayList<String>();

配置文件：

view plain copy to clipboard print ?

1. <hibernate-mappingpackage="cn.partner4java.connection">
3. <classname="Item">
4. <id name="itemId"type="integer">
5. <generatorclass="native"/>
6. </id>
7. <property name="itemName"type="string"/>
8. <!-- 映射了一个无序的string集合 -->
9. <idbag name="images"table="ITEM_IMAGES">
10. <!-- 给集合加一个id -->
11. <collection-id type="integer"column="ITEM_IMAGE_ID">
12. <generatorclass="increment"></generator>
13. </collection-id>
15. <key column="ITEM_ID"></key>
16. <element type="string"column="FILENAME"not-null="true"></element>
17. </idbag>
19. </class>
21. </hibernate-mapping>

插入：

view plain copy to clipboard print ?

1. Item item =newItem();
2. item.setItemName("hello world");
3. item.getImages().add("image1");
4. item.getImages().add("image1");

hibernate打印sql：
Hibernate: insert into Item (itemName) values (?)
Hibernate: select max(ITEM_IMAGE_ID) from ITEM_IMAGES
Hibernate: insert into ITEM_IMAGES (ITEM_ID, ITEM_IMAGE_ID, FILENAME) values (?, ?, ?)
Hibernate: insert into ITEM_IMAGES (ITEM_ID, ITEM_IMAGE_ID, FILENAME) values (?, ?, ?)
注意：

view plain copy to clipboard print ?

1. <collection-id type="integer"column="ITEM_IMAGE_ID">
2. <generatorclass="increment"></generator>
3. </collection-id>

这里的generator给的类型是increment，如果mysql给的是native或者identity会报错：
org.hibernate.id.IdentifierGeneratorFactory$2 cannot be cast to java.lang.Integer
但是oracle使用native、sequence不会报错（应该是这个版本的hibernate的bug）

**删除**：
（如果没记错的话，类类型的set集合，是不会删除子集的，只默认级联一的一端）
这里是都级联删除的

view plain copy to clipboard print ?

1. Item item = (Item) session.get(Item.class,2);
2. session.delete(item);

Hibernate: select item0_.itemId as itemId0_0_, item0_.itemName as itemName0_0_ from Item item0_ where item0_.itemId=?
Hibernate: delete from ITEM_IMAGES where ITEM_ID=?
Hibernate: delete from Item where itemId=?



映射list（允许重复，有序）：

view plain copy to clipboard print ?

1. /**
2. * 映射list
3. */
4. publicclassItemimplementsSerializable {
5. privateInteger itemId;
6. privateString itemName;
7. privateList<String> images =newArrayList<String>();

配置文件：

view plain copy to clipboard print ?

1. <hibernate-mappingpackage="cn.partner4java.list">
2. <classname="Item">
3. <id name="itemId"type="integer">
4. <generatorclass="native"/>
5. </id>
6. <property name="itemName"type="string"/>
7. <list name="images"table="ITEM_IMAGES">
8. <key column="ITEM_ID"></key>
9. <!--2.X兼容方式，不在使用<index></index> -->
10. <list-index column="POSITION"></list-index>
11. <element type="string"column="FILENAME"not-null="true"></element>
12. </list>
13. </class>
14. </hibernate-mapping>

插入：

view plain copy to clipboard print ?

1. Item item =newItem();
2. item.setItemName("hello world");
3. item.getImages().add("image1");
4. item.getImages().add("image1");

hibernate打印sql：
Hibernate: insert into Item (itemName) values (?)
Hibernate: insert into ITEM_IMAGES (ITEM_ID, POSITION, FILENAME) values (?, ?, ?)
Hibernate: insert into ITEM_IMAGES (ITEM_ID, POSITION, FILENAME) values (?, ?, ?)
（POSITION记录的就是list的指针位置0、1、2...）
删除：

view plain copy to clipboard print ?

1. Item item = (Item) session.get(Item.class,2);
2. session.delete(item);

Hibernate: select item0_.itemId as itemId0_0_, item0_.itemName as itemName0_0_ from Item item0_ where item0_.itemId=?
Hibernate: delete from ITEM_IMAGES where ITEM_ID=?
Hibernate: delete from Item where itemId=?



映射map（无序，不允许重复）：
类：

view plain copy to clipboard print ?

1. /**
2. * 映射map
3. */
4. publicclassItemimplementsSerializable {
5. privateintitemId;
6. privateString itemName;
8. privateMap<String, String> images =newHashMap<String, String>();

配置文件：

view plain copy to clipboard print ?

1. <hibernate-mappingpackage="cn.partner4java.map">
2. <classname="Item">
3. <id name="itemId">
4. <generatorclass="native"/>
5. </id>
6. <property name="itemName"type="string"/>
7. <map name="images"table="ITEM_IMAGES">
8. <key column="ITEM_ID"></key>
9. <map-key type="string"column="IMAGENAME"></map-key>
10. <element type="string"column="FILENAME"not-null="true"/>
11. </map>
12. </class>
13. </hibernate-mapping>

插入：

view plain copy to clipboard print ?

1. Item item =newItem();
2. item.setItemName("hello world");
3. item.getImages().put("imagename1","filename1");
4. item.getImages().put("imagename1","filename1");

hibernate打印sql：
Hibernate: insert into Item (itemName) values (?)
Hibernate: insert into ITEM_IMAGES (ITEM_ID, IMAGENAME, FILENAME) values (?, ?, ?)




映射sortedmap，排序集合:
类：

view plain copy to clipboard print ?

1. /**
2. * 映射sortedmap，排序集合
3. */
4. publicclassItemimplementsSerializable {
5. privateintitemId;
6. privateString itemName;
8. privateSortedMap<String, String> images =newTreeMap<String, String>();

配置文件：

view plain copy to clipboard print ?

1. <hibernate-mappingpackage="cn.partner4java.sortedmap">
2. <classname="Item">
3. <id name="itemId">
4. <generatorclass="native"/>
5. </id>
6. <property name="itemName"type="string"/>
7. <!-- sort="natural"是按照string进行排序，也可实现java.util.Comparator 如：srot="cn.partner4java.MyComp"-->
8. <map name="images"table="ITEM_IMAGES"sort="natural">
9. <key column="ITEM_ID"></key>
10. <map-key type="string"column="IMAGENAME"></map-key>
11. <element type="string"column="FILENAME"not-null="true"/>
12. </map>
13. </class>
14. </hibernate-mapping>

插入：

view plain copy to clipboard print ?

1. Item item =newItem();
2. item.setItemName("hello world");
3. item.getImages().put("imagename2","filename2");
4. item.getImages().put("imagename1","filename1");

hibernate打印sql：
Hibernate: insert into Item (itemName) values (?)
Hibernate: insert into ITEM_IMAGES (ITEM_ID, IMAGENAME, FILENAME) values (?, ?, ?)
Hibernate: insert into ITEM_IMAGES (ITEM_ID, IMAGENAME, FILENAME) values (?, ?, ?)
（数据中，images1的插入顺序是按照string排序的，也就是先插入了imagename1）


order-by:

view plain copy to clipboard print ?

1. <map name="images"table="ITEM_IMAGES"order-by="">
2. <set name="images"table="ITEM_IMAGES"order-by="FILENAME asc">

order-by属性中的表达式是SQL order by 子句的一个片段，可以按集合表的任何列进行排序。



组件的集合

组件的集合被类似地映射到JDK值类型的集合。唯一的区别是用<composite-element>代替
<element>标签。

类：

view plain copy to clipboard print ?

1. /**
2. * 映射集合
3. */
4. publicclassItemimplementsSerializable {
5. privateintitemId;
6. privateString itemName;
8. privateSet<ItemImage> images =newHashSet<ItemImage>();
11. publicclassItemImageimplementsSerializable {
12. privateString imageName;
13. privateString fileName;
14. privateintsizeX;
15. privateintsizeY;

配置文件：

view plain copy to clipboard print ?

1. <hibernate-mappingpackage="cn.partner4java.composite">
3. <classname="Item">
4. <!-- 如果你不给它明确指定column="ITEM_ID"，他是不会截取大写字母添加下划线的，不知道为什么,可能是现在的版本就这样了 -->
5. <id name="itemId"column="ITEM_ID">
6. <generatorclass="native"/>
7. </id>
8. <property name="itemName"type="string"column="ITEM_NAME"/>
10. <set name="images"table="ITEM_IMAGE"order-by="IMAGE_NAME asc">
11. <!-- 是定义 ITEM_IMAGE 表，与主表关联的字段名称，和主表的id无任何关系，也就是这里可以随意写 -->
12. <key column="ITEM_ID"></key>
13. <composite-elementclass="ItemImage">
14. <property name="imageName"column="IMAGE_NAME"not-null="true"></property>
15. <property name="fileName"column="FILE_NAME"not-null="true"></property>
16. <property name="sizeX"column="SIZE_X"not-null="true"></property>
17. <property name="sizeY"column="SIZE_Y"not-null="true"></property>
18. </composite-element>
19. </set>
20. </class>
22. </hibernate-mapping>

插入：

view plain copy to clipboard print ?

1. Item item =newItem();
2. item.setItemName("hello world");
4. item.getImages().add(newItemImage("imageName","fileName",1,2));

hibernate打印sql：
Hibernate: insert into Item (ITEM_NAME) values (?)
Hibernate: insert into ITEM_IMAGE (ITEM_ID, IMAGE_NAME, FILE_NAME, SIZE_X, SIZE_Y) values (?, ?, ?, ?, ?)



用注解映射集合
基本的集合映射:

映射无序的set集合：
类：

view plain copy to clipboard print ?

1. /**
2. * 基本的集合映射(映射无序的set集合)
3. * @author partner4java
4. *
5. */
6. @Entity
7. publicclassItemimplementsSerializable {
8. @Id
9. @GeneratedValue
10. @Column(name="item_id")
11. privateintitemId;
13. @Column(name="item_name",length=100)
14. privateString itemName;
16. //hibernate annotation 包对包含值类型元素的集合映射支持非标准的注解，
17. //主要是CollectionOfElements
18. @CollectionOfElements(targetElement=java.lang.String.class)
19. //指定加入的表名，和加入表的对应列名
20. @JoinTable(name="ITEM_IMAGE",joinColumns=@JoinColumn(name="ITEM_ID"))
21. @Column(name="FILENAME",nullable=false)
22. privateSet<String> images =newHashSet<String>();

有序的list集合：

view plain copy to clipboard print ?

1. /**
2. * 有序的list集合
3. * @author partner4java
4. *
5. */
6. @Entity
7. publicclassItemimplementsSerializable {
8. @Id
9. @GeneratedValue
10. @Column(name="ITEM_ID")
11. privateInteger itemId;
13. @Column(name="ITEM_NAME",length=100)
14. privateString itemName;
16. @CollectionOfElements(targetElement=java.lang.String.class)
17. @JoinTable(name="ITEM_IMAGE",joinColumns=@JoinColumn(name="ITME_ID"))
18. //为了映射持久化list，需要添加 IndexColumn，该索引列默认基数为0
19. @IndexColumn(name="POSITION",base=1)
20. @Column(name="FILENAME")
21. privateList<String> images =newArrayList<String>();

映射持久化的映射Map:

view plain copy to clipboard print ?

1. /**
2. * 映射持久化的映射Map
3. * @author partner4java
4. *
5. */
6. @Entity
7. publicclassItemimplementsSerializable {
8. @Id
9. @GeneratedValue
10. @Column(name="ITEM_ID")
11. privateInteger itemId;
13. @Column(name="ITEM_NAME",length=100)
14. privateString itemName;
16. @CollectionOfElements
17. @JoinTable(name="ITEM_IMAGE",joinColumns=@JoinColumn(name="ITEM_ID"))
18. @MapKey(columns=@Column(name="IMAGENAME"))
19. @Column(name="FILENAME")
20. privateMap<String, String> images =newHashMap<String, String>();

排序集合:

view plain copy to clipboard print ?

1. /**
2. * 排序集合
3. * @author partner4java
4. *
5. */
6. @Entity
7. publicclassItemimplementsSerializable {
8. @Id
9. @GeneratedValue
10. @Column(name="ITEM_ID")
11. privateInteger itemId;
13. @Column(name="ITEM_NAME")
14. privateString itemName;
16. @CollectionOfElements
17. @JoinTable(name="ITEM_IMAGE",joinColumns=@JoinColumn(name="ITEM_ID"))
18. //排序
19. @Sort(type=SortType.NATURAL)
20. @Column(name="FILENAME")
21. privateSortedSet<String> images =newTreeSet<String>();

添加order by排序：

view plain copy to clipboard print ?

1. /**
2. * 添加order by排序
3. * @author partner4java
4. *
5. */
6. @Entity
7. publicclassItemimplementsSerializable {
8. @Id
9. @GeneratedValue
10. @Column(name="ITEM_ID")
11. privateInteger itemId;
13. @Column(name="ITEM_NAME")
14. privateString itemName;
16. @CollectionOfElements(targetElement=java.lang.String.class)
17. @JoinTable(name="ITEM_IMAGE",joinColumns=@JoinColumn(name="ITEM_ID"))
18. @Column(name="FILENAME")
19. //对有序列号的list类型是不起作用的
20. @OrderBy(clause="FILENAME asc")
21. privateSet<String> images =newHashSet<String>();

映射父子关系
许多开发人员在开始使用hibernate时要尝试的第一件事就是父子关系的映射。
这通常是你第一次遇到集合，也是你第一次必须思考实体和值类型之间的区别，
否则会在ORM的复杂性中迷失。


下面简要的阐述了关系映射：


多样性：
在描述和分类关联时，我们通常使用术语多样性。在我们的例子中，多样性只是两小块信息：
一个特定的Item可以有不止一个Bid吗？
一个特定的Bid可以有不止一个Item吗？

看一眼领域模型之后，就可以推断：从Bid到Item的关联是一个多对一的关联。回忆一下，关联是有方向性的，
把从Item到Bid的方向关联归为一对多的关联。
另外只有两种可能：多对多和一对一。
在对象持久化的上下文中，我们不关注多个（many）是否意味着两个或者最大五个或者没有限制：只关注大多数
关联的选择性；不特别关心是否需要关联的实例，或者关联的另一侧是否可以为空。但是，这些是影响你在关系
数据库Schema中选择完整性规则和在SQL DDL中定义约束的重要方面。




最简单的可能关联：
从Bid到Item的关联（反之亦然）是一种最简单的可能实体关联的例子。两个类中有两个属性。一个是引用的集合，另一个是单个引用。
首先，这是Bid的Java类实现：

view plain copy to clipboard print ?

1. publicclassBid{
2. ...
3. privateItem item;
4. ...
5. }

接下来是这个关联的Hibernate映射：

view plain copy to clipboard print ?

1. <class
2. name="Bid"
3. table="BID">
4. ...
5. <many-to-one
6. name="item"
7. column="ITEM_ID"
8. class="Item"
9. not-null="true"/>
10. </class>

如果拿这个与本章前面的集合映射进行比较，会发现你用一个不同的元素<one-to-many>映射了集合内容。这表明集合没有包含值类型实例，
而是包含了对实体实例的引用。现在hibernate知道如何处理共享的引用和被关联对象的生命周期（他禁用了值类型实例的所有隐式依赖的
生命周期）。hibernate也知道用给集合的表语目标实体类被映射到的表相同--<set>映射不需要table属性。
由<key>元素定义的列映射的BID表的外键列ITEM_ID，即已经在关系的另一侧映射的同一个列。
注意，表Schema并没有改变：它与之前你的映射关联的多彻一样。但是，有一点不同：not null="true"不见了。问题是现在有两个不同的单项
关联映射到同一个外键列。


哪一侧控制这个列呢？
在运行时，同一个外键值有两个不同的内存表示法：Bid的item属性和由Item保存的bids集合的一个元素。假设应用程序修改了关联，例如通过
在addBid()方法的这个片段中对货品添加出价：
bid.setItem(item);
bids.add(bid);
在这种情况下hibernate侦测到内存持久化实例的两处变化。从数据库的观点来看，只有一个值必须更新以体现这些变化：BID表的ITEM_ID列。
hibernate没有透明地侦测到引用同一个数据库列的两处变化，因为此时还没有做任何事来表明这是一个双向的关联。换句话说，已经映射了
同一个列两次，hibernate始终需要知道这一点，因为它无法自动侦测到这个重复。
在关联映射中还需要做一件事情，就是是他成为真正的双向关联映射。inverse属性告诉hibernate，集合是<many-to-one>关联在另一侧的一个镜像：
也就是inverse一侧的改变不会引起数据库的改变，另一侧的改变才会引起数据库的改变。也就是把inverse标识在被维护的一端。