Hibernate复合主键映射

目 录：

创新互联公司坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站设计、网站建设、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的镇远网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

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

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

在日常开发中会遇到这样一种情况，数据库中的某张表需要多个字段列才能唯一确定一行记录，这时表需要使用复合主键。面对这样的情况Hibernate为我们提供了两种方式来解决复合主键问题。

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

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

 
 
 
 
    
  
  
  
  
  1. /*实体类，使用复合主键必须实现Serializable接口*/ 
    2. 
  
  
  
  
  2. public class People implements Serializable  
    3. 
  
  
  
  
  3. {  
    4. 
  
  
  
  
  4.     private static final long serialVersionUID = -4888836126783955019L;  
    5. 
  
  
  
  
  5.       
    6. 
  
  
  
  
  6.     private String id;  
    7. 
  
  
  
  
  7.     private String name;  
    8. 
  
  
  
  
  8.     private int age;  
    9. 
  
  
  
  
  9.       
    10. 
  
  
  
  
  10.     public People()  
    11. 
  
  
  
  
  11.     {  
    12. 
  
  
  
  
  12.           
    13. 
  
  
  
  
  13.     }  
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15.     public String getId()  
    16. 
  
  
  
  
  16.     {  
    17. 
  
  
  
  
  17.         return id;  
    18. 
  
  
  
  
  18.     }  
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20.     public void setId(String id)  
    21. 
  
  
  
  
  21.     {  
    22. 
  
  
  
  
  22.         this.id = id;  
    23. 
  
  
  
  
  23.     }  
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.     public String getName()  
    26. 
  
  
  
  
  26.     {  
    27. 
  
  
  
  
  27.         return name;  
    28. 
  
  
  
  
  28.     }  
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30.     public void setName(String name)  
    31. 
  
  
  
  
  31.     {  
    32. 
  
  
  
  
  32.         this.name = name;  
    33. 
  
  
  
  
  33.     }  
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35.     public int getAge()  
    36. 
  
  
  
  
  36.     {  
    37. 
  
  
  
  
  37.         return age;  
    38. 
  
  
  
  
  38.     }  
    39. 
  
  
  
  
  39.  
    40. 
  
  
  
  
  40.     public void setAge(int age)  
    41. 
  
  
  
  
  41.     {  
    42. 
  
  
  
  
  42.         this.age = age;  
    43. 
  
  
  
  
  43.     }  
    44. 
  
  
  
  
  44.  
    45. 
  
  
  
  
  45.     @Override 
    46. 
  
  
  
  
  46.     public int hashCode()  
    47. 
  
  
  
  
  47.     {  
    48. 
  
  
  
  
  48.         final int prime = 31;  
    49. 
  
  
  
  
  49.         int result = 1;  
    50. 
  
  
  
  
  50.         result = prime * result + ((id == null) ? 0 : id.hashCode());  
    51. 
  
  
  
  
  51.         result = prime * result + ((name == null) ? 0 : name.hashCode());  
    52. 
  
  
  
  
  52.         return result;  
    53. 
  
  
  
  
  53.     }  
    54. 
  
  
  
  
  54.  
    55. 
  
  
  
  
  55.     @Override 
    56. 
  
  
  
  
  56.     public boolean equals(Object obj)  
    57. 
  
  
  
  
  57.     {  
    58. 
  
  
  
  
  58.         if (this == obj)  
    59. 
  
  
  
  
  59.             return true;  
    60. 
  
  
  
  
  60.         if (obj == null)  
    61. 
  
  
  
  
  61.             return false;  
    62. 
  
  
  
  
  62.         if (getClass() != obj.getClass())  
    63. 
  
  
  
  
  63.             return false;  
    64. 
  
  
  
  
  64.         People other = (People) obj;  
    65. 
  
  
  
  
  65.         if (id == null)  
    66. 
  
  
  
  
  66.         {  
    67. 
  
  
  
  
  67.             if (other.id != null)  
    68. 
  
  
  
  
  68.                 return false;  
    69. 
  
  
  
  
  69.         }  
    70. 
  
  
  
  
  70.         else if (!id.equals(other.id))  
    71. 
  
  
  
  
  71.             return false;  
    72. 
  
  
  
  
  72.         if (name == null)  
    73. 
  
  
  
  
  73.         {  
    74. 
  
  
  
  
  74.             if (other.name != null)  
    75. 
  
  
  
  
  75.                 return false;  
    76. 
  
  
  
  
  76.         }  
    77. 
  
  
  
  
  77.         else if (!name.equals(other.name))  
    78. 
  
  
  
  
  78.             return false;  
    79. 
  
  
  
  
  79.         return true;  
    80. 
  
  
  
  
  80.     }  
    81. 
  
  
  
  
  81. } 
    82.

People.hbm.xml：

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.      
    6. 
  
  
  
  
  6.          
    7. 
  
  
  
  
  7.          
    8. 
  
  
  
  
  8.              
    9. 
  
  
  
  
  9.              
    10. 
  
  
  
  
  10.              
    11. 
  
  
  
  
  11.          
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.          
    14. 
  
  
  
  
  14.      
    15. 
  
  
  
  
  15.  
    16.

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

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

Object load(Class theClass,Serializable id)

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方法，只与主键属性有关，普通属性不要影响这两个方法进行判断。这个原因很简单，主键才能决定一条记录，其他属性不能决定一条记录。

保存测试：

 
 
 
 
    
  
  
  
  
  1. public class Client  
    2. 
  
  
  
  
  2. {  
    3. 
  
  
  
  
  3.     public static void main(String[] args)  
    4. 
  
  
  
  
  4.     {  
    5. 
  
  
  
  
  5.         Session session = HibernateUtil.getSessionFactory().openSession();  
    6. 
  
  
  
  
  6.         Transaction tx = null;  
    7. 
  
  
  
  
  7.           
    8. 
  
  
  
  
  8.         try 
    9. 
  
  
  
  
  9.         {  
    10. 
  
  
  
  
  10.             tx = session.beginTransaction();  
    11. 
  
  
  
  
  11.               
    12. 
  
  
  
  
  12.             People people = new People();  
    13. 
  
  
  
  
  13.             /*主键值由我们自己维护*/ 
    14. 
  
  
  
  
  14.             people.setId("123456");  
    15. 
  
  
  
  
  15.             people.setName("zhangsan");  
    16. 
  
  
  
  
  16.             people.setAge(40);  
    17. 
  
  
  
  
  17.               
    18. 
  
  
  
  
  18.             session.save(people);  
    19. 
  
  
  
  
  19.               
    20. 
  
  
  
  
  20.             tx.commit();  
    21. 
  
  
  
  
  21.         }  
    22. 
  
  
  
  
  22.         catch (Exception e)  
    23. 
  
  
  
  
  23.         {  
    24. 
  
  
  
  
  24.             if(tx != null)  
    25. 
  
  
  
  
  25.             {  
    26. 
  
  
  
  
  26.                 tx.rollback();  
    27. 
  
  
  
  
  27.             }  
    28. 
  
  
  
  
  28.               
    29. 
  
  
  
  
  29.             e.printStackTrace();  
    30. 
  
  
  
  
  30.         }  
    31. 
  
  
  
  
  31.         finally 
    32. 
  
  
  
  
  32.         {  
    33. 
  
  
  
  
  33.             session.close();  
    34. 
  
  
  
  
  34.         }  
    35. 
  
  
  
  
  35.     }  
    36. 
  
  
  
  
  36. } 
    37.

看看数据库：

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

读取数据测试：

 
 
 
 
    
  
  
  
  
  1. public class Client  
    2. 
  
  
  
  
  2. {  
    3. 
  
  
  
  
  3.     public static void main(String[] args)  
    4. 
  
  
  
  
  4.     {  
    5. 
  
  
  
  
  5.         Session session = HibernateUtil.getSessionFactory().openSession();  
    6. 
  
  
  
  
  6.         Transaction tx = null;  
    7. 
  
  
  
  
  7.           
    8. 
  
  
  
  
  8.         try 
    9. 
  
  
  
  
  9.         {  
    10. 
  
  
  
  
  10.             tx = session.beginTransaction();  
    11. 
  
  
  
  
  11.               
    12. 
  
  
  
  
  12.             /*查询复合主键对象，需要先构建主键*/ 
    13. 
  
  
  
  
  13.             People peoplePrimaryKey = new People();  
    14. 
  
  
  
  
  14.             peoplePrimaryKey.setId("123456");  
    15. 
  
  
  
  
  15.             peoplePrimaryKey.setName("zhangsan");  
    16. 
  
  
  
  
  16.               
    17. 
  
  
  
  
  17.             /*然后将构建的主键值传入get方法中获取对应的People对象*/ 
    18. 
  
  
  
  
  18.             People people = (People)session.get(People.class, peoplePrimaryKey);  
    19. 
  
  
  
  
  19.               
    20. 
  
  
  
  
  20.             System.out.println("people age is:"+people.getAge());  
    21. 
  
  
  
  
  21.               
    22. 
  
  
  
  
  22.             tx.commit();  
    23. 
  
  
  
  
  23.         }  
    24. 
  
  
  
  
  24.         catch (Exception e)  
    25. 
  
  
  
  
  25.         {  
    26. 
  
  
  
  
  26.             if(tx != null)  
    27. 
  
  
  
  
  27.             {  
    28. 
  
  
  
  
  28.                 tx.rollback();  
    29. 
  
  
  
  
  29.             }  
    30. 
  
  
  
  
  30.               
    31. 
  
  
  
  
  31.             e.printStackTrace();  
    32. 
  
  
  
  
  32.         }  
    33. 
  
  
  
  
  33.         finally 
    34. 
  
  
  
  
  34.         {  
    35. 
  
  
  
  
  35.             session.close();  
    36. 
  
  
  
  
  36.         }  
    37. 
  
  
  
  
  37.     }  
    38. 
  
  
  
  
  38. } 
    39.

控制台输出：

people age is:40

可以看到数据成功的取出了。

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

主键类：

 
 
 
 
    
  
  
  
  
  1. /*必须实现Serializable接口*/ 
    2. 
  
  
  
  
  2. public class PeoplePrimaryKey implements Serializable  
    3. 
  
  
  
  
  3. {  
    4. 
  
  
  
  
  4.     private static final long serialVersionUID = -1190986010439330142L;  
    5. 
  
  
  
  
  5.       
    6. 
  
  
  
  
  6.     /*复合主键值*/ 
    7. 
  
  
  
  
  7.     private String id;  
    8. 
  
  
  
  
  8.     private String name;  
    9. 
  
  
  
  
  9.       
    10. 
  
  
  
  
  10.     public PeoplePrimaryKey()  
    11. 
  
  
  
  
  11.     {  
    12. 
  
  
  
  
  12.           
    13. 
  
  
  
  
  13.     }  
    14. 
  
  
  
  
  14.       
    15. 
  
  
  
  
  15.     /*复合主键值的get和set方法*/ 
    16. 
  
  
  
  
  16.     public String getId()  
    17. 
  
  
  
  
  17.     {  
    18. 
  
  
  
  
  18.         return id;  
    19. 
  
  
  
  
  19.     }  
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21.     public void setId(String id)  
    22. 
  
  
  
  
  22.     {  
    23. 
  
  
  
  
  23.         this.id = id;  
    24. 
  
  
  
  
  24.     }  
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26.     public String getName()  
    27. 
  
  
  
  
  27.     {  
    28. 
  
  
  
  
  28.         return name;  
    29. 
  
  
  
  
  29.     }  
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31.     public void setName(String name)  
    32. 
  
  
  
  
  32.     {  
    33. 
  
  
  
  
  33.         this.name = name;  
    34. 
  
  
  
  
  34.     }  
    35. 
  
  
  
  
  35.  
    36. 
  
  
  
  
  36.     @Override 
    37. 
  
  
  
  
  37.     public int hashCode()  
    38. 
  
  
  
  
  38.     {  
    39. 
  
  
  
  
  39.         final int prime = 31;  
    40. 
  
  
  
  
  40.         int result = 1;  
    41. 
  
  
  
  
  41.         result = prime * result + ((id == null) ? 0 : id.hashCode());  
    42. 
  
  
  
  
  42.         result = prime * result + ((name == null) ? 0 : name.hashCode());  
    43. 
  
  
  
  
  43.         return result;  
    44. 
  
  
  
  
  44.     }  
    45. 
  
  
  
  
  45.  
    46. 
  
  
  
  
  46.     @Override 
    47. 
  
  
  
  
  47.     public boolean equals(Object obj)  
    48. 
  
  
  
  
  48.     {  
    49. 
  
  
  
  
  49.         if (this == obj)  
    50. 
  
  
  
  
  50.             return true;  
    51. 
  
  
  
  
  51.         if (obj == null)  
    52. 
  
  
  
  
  52.             return false;  
    53. 
  
  
  
  
  53.         if (getClass() != obj.getClass())  
    54. 
  
  
  
  
  54.             return false;  
    55. 
  
  
  
  
  55.         PeoplePrimaryKey other = (PeoplePrimaryKey) obj;  
    56. 
  
  
  
  
  56.         if (id == null)  
    57. 
  
  
  
  
  57.         {  
    58. 
  
  
  
  
  58.             if (other.id != null)  
    59. 
  
  
  
  
  59.                 return false;  
    60. 
  
  
  
  
  60.         }  
    61. 
  
  
  
  
  61.         else if (!id.equals(other.id))  
    62. 
  
  
  
  
  62.             return false;  
    63. 
  
  
  
  
  63.         if (name == null)  
    64. 
  
  
  
  
  64.         {  
    65. 
  
  
  
  
  65.             if (other.name != null)  
    66. 
  
  
  
  
  66.                 return false;  
    67. 
  
  
  
  
  67.         }  
    68. 
  
  
  
  
  68.         else if (!name.equals(other.name))  
    69. 
  
  
  
  
  69.             return false;  
    70. 
  
  
  
  
  70.         return true;  
    71. 
  
  
  
  
  71.     }  
    72. 
  
  
  
  
  72. } 
    73.

实体类：

 
 
 
 
    
  
  
  
  
  1. public class People  
    2. 
  
  
  
  
  2. {  
    3. 
  
  
  
  
  3.     /*持有主键类的一个引用，使用该引用作为这个类的OID*/ 
    4. 
  
  
  
  
  4.     private PeoplePrimaryKey peoplePrimaryKey;  
    5. 
  
  
  
  
  5.     private int age;  
    6. 
  
  
  
  
  6.       
    7. 
  
  
  
  
  7.     public People()  
    8. 
  
  
  
  
  8.     {  
    9. 
  
  
  
  
  9.           
    10. 
  
  
  
  
  10.     }  
    11. 
  
  
  
  
  11.       
    12. 
  
  
  
  
  12.     public PeoplePrimaryKey getPeoplePrimaryKey()  
    13. 
  
  
  
  
  13.     {  
    14. 
  
  
  
  
  14.         return peoplePrimaryKey;  
    15. 
  
  
  
  
  15.     }  
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.     public void setPeoplePrimaryKey(PeoplePrimaryKey peoplePrimaryKey)  
    18. 
  
  
  
  
  18.     {  
    19. 
  
  
  
  
  19.         this.peoplePrimaryKey = peoplePrimaryKey;  
    20. 
  
  
  
  
  20.     }  
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.     public int getAge()  
    23. 
  
  
  
  
  23.     {  
    24. 
  
  
  
  
  24.         return age;  
    25. 
  
  
  
  
  25.     }  
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27.     public void setAge(int age)  
    28. 
  
  
  
  
  28.     {  
    29. 
  
  
  
  
  29.         this.age = age;  
    30. 
  
  
  
  
  30.     }  
    31. 
  
  
  
  
  31. } 
    32.

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

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.      
    6. 
  
  
  
  
  6.          
    7. 
  
  
  
  
  7.          
    8. 
  
  
  
  
  8.          
    9. 
  
  
  
  
  9.              
    10. 
  
  
  
  
  10.              
    11. 
  
  
  
  
  11.              
    12. 
  
  
  
  
  12.          
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.          
    15. 
  
  
  
  
  15.      
    16. 
  
  
  
  
  16.  
    17.

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

分享题目：Hibernate复合主键映射
当前路径：http://www.csdahua.cn/qtweb/news14/516614.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

虚拟主机知识

分类信息网

成都定制网站　　 　绵阳服务器托管　　 　成都网站建设　　 　营山母婴护理　　 　成都网站建设　　 　成都移动机房　　 　西部信息机房　　 　绵阳电信机房　　 　成都网站推广公司　　 　四川瑞杰　　 　企业网站建设公司　　 　香港虚拟主机　　 　温江网站设计　　 　成都网站改版　　 　四川电信机房托管　　 　资阳发电机　　 　外贸营销网站建设　　 　工程造价　　 　腾讯免备案主机　　 　IDC机房托管