hibernate集合映射（转载）

POJOs以下：

Customer类---->customer表

Order类对应---->orders表

customer(1)<----->(n)order

1. public class Customer  
2. {  
3.     private String id;  
4.     private String username;  
5.     private String password;  
6.     private Timestamp registerTime;  
7.     private int age;  
8.     private Set<Order> orders = new HashSet<Order>();  
9.  
10.     /*setter and getter method*/ 
11. } 

1. public class Order  
2. {  
3.     private String id;  
4.     private String orderNumber;  
5.     private int balance;  
6.     private Customer customer;  
7.  
8.     /*setter and getter method*/ 
9. } 

Set集合映射：

Hibernate为集合映射提供了专用的标签元素，Set集合映射，就使用<set>标签表示：

1. <?xml version="1.0" encoding="utf-8"?> 
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
3.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
4.       
5.     <hibernate-mapping> 
6.         <class name="com.suxiaolei.hibernate.pojos.Customer" table="customer"> 
7.             <!-- 主键设置 --> 
8.             <id name="id" type="string"> 
9.                 <column name="id"></column> 
10.                 <generator class="uuid"></generator> 
11.             </id> 
12.               
13.             <!-- 属性设置 --> 
14.             <property name="username" column="username" type="string"></property> 
15.             <property name="password" column="password" type="string"></property> 
16.             <property name="age" column="age" type="integer"></property> 
17.             <property name="registerTime" column="register_time" type="timestamp"></property> 
18.               
19.             <set name="orders" inverse="true" cascade="all"> 
20.                 <key column="customer_id"></key> 
21.                 <one-to-many class="com.suxiaolei.hibernate.pojos.Order"/> 
22.             </set> 
23.           
24.         </class> 
25.     </hibernate-mapping> 

<set>标签中的"name"属性表示customer对象中关系集合的属性名，"inverse"与"cascade"属性说明 （参考这里）。在数据库中表示"一对多"的关系是经过外键关联的方式实现的，"多方"经过持有"一方"的主键值来肯定关系，怎么持有"一方"的主键值？" 多方"将使用一列来存储"一方"的主键值，而后将此列做为外键列参照"一方"的主键列。因此使用Hibernate开发时须要将两表的关系列（外键列）告 诉Hibernate，<key column="customer_id"></key>就是完成这个工做的，Hibernate就能根据 "customer_id"列取出关联信息。例如：从customer表中取出一条记录后，Hibernate会根据该customer记录的主键值再从 order表中查找"custom_id"列，取出值相等的记录，而后组装到Customer对象中的set集合属性中，反之亦然。由于取出来的记录（只 是一些零碎的值，尚未组装成对象）须要存放到Set集合中，因此要告诉Hibernate在Set集合里面能放什么类型的数据。<one-to- many>这个标签就是完成这个工做的，"class"属性是指定这个这个Set集合里面元素的类型。

1. <?xml version="1.0" encoding="utf-8"?> 
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
3.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
4.       
5.     <hibernate-mapping> 
6.         <class name="com.suxiaolei.hibernate.pojos.Order" table="orders"> 
7.             <id name="id" type="string"> 
8.                 <column name="id"></column> 
9.                 <generator class="uuid"></generator> 
10.             </id> 
11.               
12.             <property name="orderNumber" column="orderNumber" type="string"></property> 
13.             <property name="balance" column="balance" type="integer"></property> 
14.               
15.             <many-to-one name="customer" class="com.suxiaolei.hibernate.pojos.Customer"> 
16.                 <column name="customer_id"></column> 
17.             </many-to-one>          
18.         </class> 
19.     </hibernate-mapping> 

<many-to-one>标签是设置"一对多"关系中的"多方"的，name指定了哪个属性是关系属性，"class"指定了关系 属性的类型（也指定了与哪个表关联）， "column"属性是指定这个关联属性是按照"customer_id"列的值，在customer表中查询得到的。

测试：

1. tx = session.beginTransaction();  
2.  
3. /*  
4.  * 建立Customer对象，并设置其属性值  
5.  */ 
6. Customer customer = new Customer();  
7. customer.setUsername("zhangsan");  
8. customer.setPassword("123456");  
9. customer.setAge(22);  
10. customer.setRegisterTime(new Timestamp(new Date().getTime()));  
11.  
12. /*  
13.  * 建立Order对象order1，并设置其属性值  
14.  */ 
15. Order order1 = new Order();  
16. order1.setOrderNumber("a1a2a3");  
17. order1.setBalance(1000);  
18. order1.setCustomer(customer);  
19.  
20. /*  
21.  * 建立Order对象order2，并设置其属性值  
22.  */ 
23. Order order2 = new Order();  
24. order2.setOrderNumber("d3d2d1");  
25. order2.setBalance(670);  
26. order2.setCustomer(customer);  
27.  
28. customer.getOrders().add(order1);  
29. customer.getOrders().add(order2);  
30.  
31. session.saveOrUpdate(customer);  
32.  
33. tx.commit(); 

查看数据库的数据：

customer表：

orders表 

能够看到数据被成功的插入到数据库中了，而且"custom_id"列（关系列）也正确赋值了。

List映射：

Hibernate为集合映射提供了专用的标签元素，List集合映射，就使用<list>标签表示：

1. <list name="orders" inverse="false" cascade="all"> 
2.     <key column="customer_id"></key> 
3.     <index column="customer_index" type="integer"></index> 
4.     <one-to-many class="com.suxiaolei.hibernate.pojos.Order"/> 
5. </list> 

List集合是有顺序的，"index"标签，是用于记录顺序，List的顺序将表如今"customer_index"列上，其他设置，与Set 集合相似。注意：List映射中"inverse"中的值不能设置为"true"，由于List集合的顺序只有customer方知道，order方不知 道List的存在。否则，"customer_index"的列值将不会被赋值。

查看数据库：

customer表：

orders表：

能够看到记录正确的插入到数据库中了，并且"custom_index"正确的表示出List的顺序。

Array（数组）映射：标签使用<array>其余与List基本一致。

Map映射：

Hibernate为集合映射提供了专用的标签元素，Map集合映射，就使用<map>标签表示：

1. <map name="orders" inverse="false" cascade="all"> 
2.     <key column="customer_id"></key> 
3.     <index column="order_key" type="string"></index> 
4.     <one-to-many class="com.suxiaolei.hibernate.pojos.Order"/> 
5. </map> 

Map映射中<index>标签，表示Map集合中的key值，记录在"order_key"列中，<one-to- many>表示Map集合中的vlaue。其余设置与上面同样。注意："inverse"不要设置成"true"由于key值是customer对 象维护的，而order不知道key的存在。

Bag映射：它是List与Set集合的结合，能够重复，可是无顺。使用List模拟Bag。设置相似Set，它也有专用标签<bag>。

总  结

在没有特殊要求下，最好使用Set集合，由于Set集合没有特殊信息须要"一方"本身维护，能够彻底交给"多方"维护，可以提升性能，若须要记录数 据的顺序可使用List和Array映射，若须要key/value形式存储数据，可使用Map映射。最后一点若集合放置的数据简单类型(原生类型、 原生类型的包装类、String、Date之类的)在集合映射配置上稍有不一样，<element>元素能够直接映射这些简单类型，其余配置与 上述配置没什么不一样。

原文连接：http://www.cnblogs.com/otomedaybreak/archive/2012/01/18/2325993.html