复合主键

一、复合主键映射

       复合主键映射需要在映射配置文件中使用<composite-id>标签，该标签是指将一个类指定为相应的复合主键，它的name属性需要指定类文件中定义的属性值，并在该标签中添加<key-property>子标签。

       Note：想要使用复合映射必须要将复合主键放到一个类中，也就是讲复合主键属性和其它属性分到两个类中，并将复合主键的类实现接口Serializable，该接口隶属于java.io。

       复合主键的映射关系的主键是由多个列复合而成的，对应到数据表中相当的简单，如下图：

  1、类文件

       这里就拿上图的表来作为示例，在表中有两个字段年限和持续时间组合成为表的主键，所以分成的新类分别命名为FiscalYearPeriod和FiscalYearPeriodPK，其中FiscalYearPeriodPK类封装表的主键属性，FiscalYearPeriod类封装其它属性以及FiscalYearPeriodPK类。

   1.1 FiscalYearPeriod.java

      类中封装有基本的属性，并把FiscalYearPeriodPK类作为属性封装到类中，并在配置文件中配置相应的映射，如下代码：

1. package com.src.hibernate;  
2.   
3. import java.sql.Date;  
4.   
5. public class FiscalYearPeriod {  
6.       
7.     //时间主键  
8.     private FiscalYearPeriodPK fiscalYearPeriodPK;  
9.     public FiscalYearPeriodPK getFiscalYearPeriodPK() {  
10.         return fiscalYearPeriodPK;  
11.     }  
12.     public void setFiscalYearPeriodPK(FiscalYearPeriodPK fiscalYearPeriodPK) {  
13.         this.fiscalYearPeriodPK = fiscalYearPeriodPK;  
14.     }  
15.       
16.     //开始日期  
17.     private Date beginDate;  
18.     public Date getBeginDate() {  
19.         return beginDate;  
20.     }  
21.     public void setBeginDate(Date beginDate) {  
22.         this.beginDate = beginDate;  
23.     }  
24.       
25.     //结束日期  
26.     private Date endDate;  
27.     public Date getEndDate() {  
28.         return endDate;  
29.     }  
30.     public void setEndDate(Date endDate) {  
31.         this.endDate = endDate;  
32.     }  
33.       
34.     //阶段时间  
35.     private String periodSts;  
36.     public String getPeriodSts() {  
37.         return periodSts;  
38.     }  
39.     public void setPeriodSts(String periodSts) {  
40.         this.periodSts = periodSts;  
41.     }  
42. }  

   1.2 FiscalYearPeriodPK.java

      封装主键属性，该类是从FiscalYearPeriod类中分离出来的，包含了基本的主键属性，并且需要实现接口Serializable，该类是要映射到配置文件中<composite-id>标签中要指定该类，代码如下：

1. package com.src.hibernate;  
2.   
3. import java.io.Serializable;  
4.   
5. public class FiscalYearPeriodPK implements Serializable {  
6.       
7.     //年限  
8.     private int fiscalYear;  
9.     public int getFiscalYear() {  
10.         return fiscalYear;  
11.     }  
12.     public void setFiscalYear(int fiscalYear) {  
13.         this.fiscalYear = fiscalYear;  
14.     }  
15.   
16.     //持续时间  
17.     private int fiscalPeriod;  
18.     public int getFiscalPeriod() {  
19.         return fiscalPeriod;  
20.     }  
21.   
22.     public void setFiscalPeriod(int fiscalPeriod) {  
23.         this.fiscalPeriod = fiscalPeriod;  
24.     }  
25.       
26. }  

  2、配置文件

这里有个疑问两个类都是哪个需要添加映射文件？因为会使用<composite-id>标签，所以只需要为FiscalYearPeriod类添加映射即可，在该映射文件中添加对应复合主键标签，并在标签中添加对应的主键属性，如下代码：

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC   
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.     <class name="com.src.hibernate.FiscalYearPeriod" table="t_fiscal_year_period_pk">  
7.         <composite-id name="fiscalYearPeriodPK">  
8.             <key-property name="fiscalYear"></key-property>  
9.             <key-property name="fiscalPeriod"></key-property>  
10.         </composite-id>  
11.         <property name="beginDate" type="date"/>  
12.         <property name="endDate" type="date"/>  
13.         <property name="periodSts"/>  
14.     </class>  
15. </hibernate-mapping>  

      将上面的文件生成对应的数据库表，生成的sql语句如下：

1. drop table if exists t_fiscal_year_period_pk  
2. create table t_fiscal_year_period_pk (fiscalYear integer not null, fiscalPeriod integer not null, beginDate date, endDate date, periodSts varchar(255), primary key (fiscalYear, fiscalPeriod))  

     对应的表结构如下图：

  3、数据操作

        相应的映射文件配置好后，相应的数据操作就变得很简单了，首先从写入数据开始，向数据库中写入数据时会同时把两个类写入到数据库中，所以此时这两个类都必须转化为Transient状态，所以在保存时需要首先将FiscalYearPeriod对象首先保存到数据库中，然后它会自动关联复合属性，将信息保存到数据库中。

  3.1 写入操作

      写入的操作方法和以前的写入方法相同，需要定义两个对象，然后保存相应的对象信息到数据库中，代码如下：

1. public void testSave1(){  
2.     //声明会话对象  
3.     Session session=null;  
4.       
5.     try{  
6.         //获取会话对象  
7.         session=HibernateUtils.getSession();  
8.         //开启会话  
9.         session.beginTransaction();  
10.         //创建复合对象  
11.         FiscalYearPeriodPK fiscalyearperiodpk=new FiscalYearPeriodPK();  
12.         fiscalyearperiodpk.setFiscalPeriod(2014);  
13.         fiscalyearperiodpk.setFiscalYear(2012);  
14.           
15.         //创建对象  
16.         FiscalYearPeriod fiscalyearperiod=new FiscalYearPeriod();  
17.         fiscalyearperiod.setFiscalYearPeriodPK(fiscalyearperiodpk);  
18.           
19.         session.save(fiscalyearperiod);  
20.         //提交会话  
21.         session.getTransaction().commit();  
22.     }catch(Exception e){  
23.         e.printStackTrace();  
24.         session.getTransaction().rollback();  
25.     }finally{  
26.         HibernateUtils.closeSession(session);  
27.     }  
28. }  

      执行相应的测试方法，生成的SQL语句如下：

1. Hibernate: insert into t_fiscal_year_period_pk (beginDate, endDate, periodSts, fiscalYear, fiscalPeriod) values (?, ?, ?, ?, ?)  

     相应的数据库视图：

  3.2 加载操作

      相应的加载方法会和以前不同，因为在该表中主键是复合属性，所以需要创建一个类。在加载数据时需要创建主键对象，此时的主键就是一个对象，更需要为对象的属性赋值，这样才能获取对象，代码如下：

1. public void testLoad1(){  
2.     //声明会话对象  
3.     Session session=null;  
4.       
5.     try{  
6.         //获取会话对象  
7.         session=HibernateUtils.getSession();  
8.         //开启会话  
9.         session.beginTransaction();  
10.         //创建复合对象  
11.         FiscalYearPeriodPK fiscalyearperiodpk=new FiscalYearPeriodPK();  
12.         fiscalyearperiodpk.setFiscalPeriod(2014);  
13.         fiscalyearperiodpk.setFiscalYear(2012);  
14.           
15.         FiscalYearPeriod fiscalyearperiod=(FiscalYearPeriod)session.load(FiscalYearPeriod.class,fiscalyearperiodpk);  
16.         System.out.println("开始日期： "+fiscalyearperiod.getBeginDate());   
17.         //提交会话  
18.         session.getTransaction().commit();  
19.     }catch(Exception e){  
20.         e.printStackTrace();  
21.         session.getTransaction().rollback();  
22.     }finally{  
23.         HibernateUtils.closeSession(session);  
24.     }  
25. }  

      生成的结果，如下：

1. Hibernate: select fiscalyear0_.fiscalYear as fiscalYear0_0_, fiscalyear0_.fiscalPeriod as fiscalPe2_0_0_, fiscalyear0_.beginDate as beginDate0_0_, fiscalyear0_.endDate as endDate0_0_, fiscalyear0_.periodSts as periodSts0_0_ from t_fiscal_year_period_pk fiscalyear0_ where fiscalyear0_.fiscalYear=? and fiscalyear0_.fiscalPeriod=?  
2. 开始日期： 2013-10-12  

结语

      复合主键的使用其实很简单，但是需要注意对象需要被拆分，主键自己需要一个类并且该类需要实现java.io.Serializable接口，其它的属性再重新生成新类，并且类的属性中要有主键类的对象，相应的只需要一个配置文件，在映射文件中使用<composite-id>指明主键，并指明主键的属性。