SSH：Hibernate框架（Hibernate复合主键映射）

 所谓复合主键就是在一张数据库表中，主键有两个或者多个，在日常开发中会遇到这样一种情况，数据库中的某张表需要多个字段列才能唯一确定一行记录，这时表需要使用复合主键。这是我们以前在hibernate配置中没有遇到过的情况。面对这样的情况Hibernate为我们提供了两种方式来解决复合主键问题，下面让我们来看一下这两种情况：

 

1：将复合主键对应的属性与实体其他普通属性放在一起

2：将主键属性提取到一个主键类中，实体类只需包含主键类的一个引用

 

 下面我们就具体来看一下：

 

方式一：将复合主键对应的属性与实体其他普通属性放在一起

例如实体类People中"id"和"name"属性对应复合主键：

 

[java]  view plain copy print ?

1. /*实体类，使用复合主键必须实现Serializable接口*/  
2. public class People implements Serializable  
3. {  
4.     private String id;  
5.     private String name;  
6.     private int age;  
7.       
8.     public People()  
9.     { }  
10. ***************set、get方法  
11.   
12.     public int hashCode()  
13.     {  
14.         final int prime = 31;  
15.         int result = 1;  
16.         result = prime * result + ((id == null) ? 0 : id.hashCode());  
17.         result = prime * result + ((name == null) ? 0 : name.hashCode());  
18.         return result;  
19.     }  
20.   
21.     @Override  
22.     public boolean equals(Object obj)  
23.     {  
24.         if (this == obj)  
25.             return true;  
26.         if (obj == null)  
27.             return false;  
28.         if (getClass() != obj.getClass())  
29.             return false;  
30.         People other = (People) obj;  
31.         if (id == null)  
32.         {  
33.             if (other.id != null)  
34.                 return false;  
35.         }  
36.         else if (!id.equals(other.id))  
37.             return false;  
38.         if (name == null)  
39.         {  
40.             if (other.name != null)  
41.                 return false;  
42.         }  
43.         else if (!name.equals(other.name))  
44.             return false;  
45.         return true;  
46.     }  
47. }  

 

People.hbm.xml：

[html]  view plain copy print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
3.   
4. <hibernate-mapping>  
5.     <class name="com.suxiaolei.hibernate.pojos.People" table="people">  
6.         <!-- 复合主键使用composite-id标签 -->  
7.         <composite-id>  
8.             <!-- key-property标签表示哪一些属性对应复合主键 -->  
9.             <key-property name="id" column="id" type="string"></key-property>  
10.             <key-property name="name" column="name" type="string"></key-property>  
11.         </composite-id>  
12.   
13.         <property name="age" column="age" type="integer"></property>  
14.     </class>  
15. </hibernate-mapping>  

Hibernate中使用复合主键时需要注意一些规则：

1. 使用复合主键的实体类必须实现Serializable接口。必须实现Serializable接口的原因很简单，我们查找数据的时候是根据主键查找的。打开Hibernate的帮助文档我们可以找到get与load方法的声明形式如下：

[java]  view plain copy print ?

1. Object load(Class theClass,Serializable id)  
2.   
3. Object get(Class theClass,Serializable id)  

       当 我们查找复合主键类的对象时，需要传递主键值给get()或load()方法的id参数，而id参数只能接收一个实现了Serializable接口的对 象。而复合主键类的主键不是一个属性可以表示的，所以只能先new出复合主键类的实例（例如：new People()），然后使用主键属性的set方法将主键值赋值给主键属性，然后将整个对象传递给get()或load()方法的id参数，实现主键值的 传递，所以复合主键的实体类必须实现Serializable接口。

 

2. 使 用复合主键的实体类必须重写equals和hashCode方法。必须重写equals和hashCode方法也很好理解。这两个方法使用于判断两个对象 (两条记录)是否相等的。为什么要判断两个对象是否相等呢？因为数据库中的任意两条记录中的主键值是不能相同的，所以我们在程序中只要确保了两个对象的主 键值不同就可以防止主键约束违例的错误出现。也许这里你会奇怪为什么不使用复合主键的实体类不重写这两个方法也没有主键违例的情况出现，这是因为使用单一 主键方式，主键值是Hibernate来维护的，它会确保主键不会重复，而复合主键方式，主键值是编程人员自己维护的，所以必须重写equals和hashCode方法用于判断两个对象的主键是否相同。

 

3. 重写的equals和hashCode方法，只与主键属性有关，普通属性不要影响这两个方法进行判断。这个原因很简单，主键才能决定一条记录，其他属性不能决定一条记录。

 

保存测试：

            

[java]  view plain copy print ?

1. tx = session.beginTransaction();  
2.               
3.             People people = new People();  
4.             /*主键值由我们自己维护*/  
5.             people.setId("123456");  
6.             people.setName("zhangsan");  
7.             people.setAge(40);  
8.             session.save(people);  
9.   
10. tx.commit();  

      

看看数据库：

数据被正确的插入到数据库中了。

 

读取数据测试：

      

[java]  view plain copy print ?

1. tx = session.beginTransaction();  
2.            /*查询复合主键对象，需要先构建主键*/  
3.            People peoplePrimaryKey = new People();  
4.            peoplePrimaryKey.setId("123456");  
5.            peoplePrimaryKey.setName("zhangsan");  
6.              
7.            /*然后将构建的主键值传入get方法中获取对应的People对象*/  
8.            People people = (People)session.get(People.class, peoplePrimaryKey);  
9.            System.out.println("people age is:"+people.getAge());  
10.            tx.commit();  

控制台输出：people age is:40，以看到数据成功的取出了。

 

方式二：将主键属性提取到一个主键类中，实体类只需包含主键类的一个引用。

主键类：

[java]  view plain copy print ?

1. /*必须实现Serializable接口*/  
2. public class PeoplePrimaryKey implements Serializable  
3. {  
4.     /*复合主键值*/  
5.     private String id;  
6.     private String name;  
7.       
8.     public PeoplePrimaryKey()  
9.     {}  
10.       
11.     /*复合主键值的get和set方法在此省略*/   
12.   
13.    
14.   
15.  @Override  
16.     public int hashCode()  
17.     {  
18.         final int prime = 31;  
19.         int result = 1;  
20.         result = prime * result + ((id == null) ? 0 : id.hashCode());  
21.         result = prime * result + ((name == null) ? 0 : name.hashCode());  
22.         return result;  
23.     }  
24.   
25.     @Override  
26.     public boolean equals(Object obj)  
27.     {  
28.         if (this == obj)  
29.             return true;  
30.         if (obj == null)  
31.             return false;  
32.         if (getClass() != obj.getClass())  
33.             return false;  
34.         PeoplePrimaryKey other = (PeoplePrimaryKey) obj;  
35.         if (id == null)  
36.         {  
37.             if (other.id != null)  
38.                 return false;  
39.         }  
40.         else if (!id.equals(other.id))  
41.             return false;  
42.         if (name == null)  
43.         {  
44.             if (other.name != null)  
45.                 return false;  
46.         }  
47.         else if (!name.equals(other.name))  
48.             return false;  
49.         return true;  
50.     }  
51. }  

实体类：

[java]  view plain copy print ?

1. public class People  
2. {  
3.     /*持有主键类的一个引用，使用该引用作为这个类的OID*/  
4.     private PeoplePrimaryKey peoplePrimaryKey;  
5.     private int age;  
6.       
7.     public People()  
8.     {}  
9.     ***************************set/get方法省略  
10.   
11. }  

 

People.hbm.xml文件稍有一点变动：

[html]  view plain copy print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
3.   
4. <hibernate-mapping>  
5.     <class name="com.suxiaolei.hibernate.pojos.People" table="people">  
6.         <!-- 复合主键使用composite-id标签 -->  
7.         <!--  
8.         name - 指定了复合主键对应哪一个属性  
9.         class - 指定了复合主键属性的类型  
10.         -->  
11.         <composite-id name="peoplePrimaryKey" class="com.suxiaolei.hibernate.pojos.PeoplePrimaryKey">  
12.             <!-- key-property指定了复合主键由哪些属性组成 -->  
13.             <key-property name="id" column="id" type="string"></key-property>  
14.             <key-property name="name" column="name" type="string"></key-property>  
15.         </composite-id>  
16.   
17.         <property name="age" column="age" type="integer"></property>  
18.     </class>  
19. </hibernate-mapping>  

       场景测试与方式一大同小异这里不再举例了。主键类为什么实现Serializable接口和为什么重写equals和hashCode方法上面已经解释的很清楚了。

 

3.联合主键的映射规则

1） 类中的每个主键属性都对应到数据表中的每个主键列。Hibernate要求具有联合主键的实体类实现Serializable接口，并且重写hashCode与equals方法，重写这两个方法的原因在于Hibernate要根据数据库的联合主键来判断某两行记录是否是一样的，如果一样那么就认为是同一个对象，如果不一样，那么就认为是不同的对象。这反映到程序领域中就是根据hashCode与equals方法来判断某两个对象是否能够放到诸如Set这样的集合当中。联合主键的实体类实现Serializable接口的原因在于使用get或load方法的时候需要先构建出来该实体的对象，并且将查询依据（联合主键）设置进去，然后作为get或load方法的第二个参数传进去即可。

2） 将主键所对应属性提取出一个类（称之为主键类），并且主键类需要实现Serializable接口，重写equals方法与hashCode方法，原因与上面一样。