分享web开发知识

注册/登录|最近发布|今日推荐

主页 IT知识网页技术软件开发前端开发代码编程运营维护技术分享教程案例
当前位置：首页 > 技术分享

使用注解的Hibernate one-to-many映射

发布时间：2023-09-06 01:16责任编辑：彭小芳关键词：Hibernate

One to many映射关系指的是两个实体间一个实体可以和多个实体有关联关系，但是多的这一端只能和一的这一端的一个实例有关系。它是一个1 到 n的关系。例如在任何的公司员工可以注册多个银行账户，一个银行账户只能和一个员工相关联，在这篇文章中我们将会学习怎么在Hibernate3中建立这种映射关系。

问题陈述

我们要写两个实体一个是Employee实体另一个是Account实体，这样多个银行账户就可以和一个员工关联了，但是这些账户不能被两个或以上的用户共享。

设计解决方案

这种问题可以使用两种方式解决。一种方式是在Account表中设置一个外键EMPLOYEE_ID，这一列指向Employee表的主键，这种方式没有两个账号可以和多个用户相关联，显然，为了完成这种限制，账号应该是独特的。另一种方式是建立一个连接表，比如说是叫EMPLOYEE_ACCOUNT，这个表有两列，EMP_ID作为EMPLOYEE表中主键的外键，对于ACCOUNT_ID也是这种情况。

使用外键连接

这种方式，两个实体都要负责建立关系并维护这种关系，EMPLOYEE实体应该申明的关系是one to many，Account实体应该声明的关系是many to one。首先来看一下关系设计：

EMPLOYEE实体
[java] view plain copy
  1. packagehibernate.test.oneToMany.foreignKeyAsso;
  3. importjava.io.Serializable;
  4. importjava.util.Set;
  6. importjavax.persistence.CascadeType;
  7. importjavax.persistence.Column;
  8. importjavax.persistence.Entity;
  9. importjavax.persistence.GeneratedValue;
  10. importjavax.persistence.GenerationType;
  11. importjavax.persistence.Id;
  12. importjavax.persistence.JoinColumn;
  13. importjavax.persistence.OneToMany;
  14. importjavax.persistence.Table;
  15. importjavax.persistence.UniqueConstraint;
  17. @Entity(name="ForeignKeyAssoEntity")
  18. @Table(name="Employee",uniqueConstraints={
  19. @UniqueConstraint(columnNames="ID"),
  20. @UniqueConstraint(columnNames="EMAIL")})
  21. publicclassEmployeeEntityimplementsSerializable{
  23. privatestaticfinallongserialVersionUID=-1798070786993154676L;
  25. @Id
  26. @GeneratedValue(strategy=GenerationType.IDENTITY)
  27. @Column(name="ID",unique=true,nullable=false)
  28. privateIntegeremployeeId;
  30. @Column(name="EMAIL",unique=true,nullable=false,length=100)
  31. privateStringemail;
  33. @Column(name="FIRST_NAME",unique=false,nullable=false,length=100)
  34. privateStringfirstName;
  36. @Column(name="LAST_NAME",unique=false,nullable=false,length=100)
  37. privateStringlastName;
  39. @OneToMany(cascade=CascadeType.ALL)
  40. @JoinColumn(name="EMPLOYEE_ID")
  41. privateSet<AccountEntity>accounts;
  43. publicIntegergetEmployeeId(){
  44. returnemployeeId;
  45. }
  47. publicvoidsetEmployeeId(IntegeremployeeId){
  48. this.employeeId=employeeId;
  49. }
  51. publicStringgetEmail(){
  52. returnemail;
  53. }
  55. publicvoidsetEmail(Stringemail){
  56. this.email=email;
  57. }
  59. publicStringgetFirstName(){
  60. returnfirstName;
  61. }
  63. publicvoidsetFirstName(StringfirstName){
  64. this.firstName=firstName;
  65. }
  67. publicStringgetLastName(){
  68. returnlastName;
  69. }
  71. publicvoidsetLastName(StringlastName){
  72. this.lastName=lastName;
  73. }
  75. publicSet<AccountEntity>getAccounts(){
  76. returnaccounts;
  77. }
  79. publicvoidsetAccounts(Set<AccountEntity>accounts){
  80. this.accounts=accounts;
  81. }
  82. }

Account实体
[java] view plain copy
  1. packagehibernate.test.oneToMany.foreignKeyAsso;
  3. importjava.io.Serializable;
  5. importjavax.persistence.Column;
  6. importjavax.persistence.Entity;
  7. importjavax.persistence.GeneratedValue;
  8. importjavax.persistence.GenerationType;
  9. importjavax.persistence.Id;
  10. importjavax.persistence.ManyToOne;
  11. importjavax.persistence.Table;
  12. importjavax.persistence.UniqueConstraint;
  14. @Entity(name="ForeignKeyAssoAccountEntity")
  15. @Table(name="ACCOUNT",uniqueConstraints={
  16. @UniqueConstraint(columnNames="ID")})
  17. publicclassAccountEntityimplementsSerializable
  18. {
  20. privatestaticfinallongserialVersionUID=-6790693372846798580L;
  22. @Id
  23. @GeneratedValue(strategy=GenerationType.IDENTITY)
  24. @Column(name="ID",unique=true,nullable=false)
  25. privateIntegeraccountId;
  27. @Column(name="ACC_NUMBER",unique=true,nullable=false,length=100)
  28. privateStringaccountNumber;
  30. @ManyToOne
  31. privateEmployeeEntityemployee;
  33. publicIntegergetAccountId(){
  34. returnaccountId;
  35. }
  37. publicvoidsetAccountId(IntegeraccountId){
  38. this.accountId=accountId;
  39. }
  41. publicStringgetAccountNumber(){
  42. returnaccountNumber;
  43. }
  45. publicvoidsetAccountNumber(StringaccountNumber){
  46. this.accountNumber=accountNumber;
  47. }
  49. publicEmployeeEntitygetEmployee(){
  50. returnemployee;
  51. }
  53. publicvoidsetEmployee(EmployeeEntityemployee){
  54. this.employee=employee;
  55. }
  56. }

测试代码
[java] view plain copy
  1. packagehibernate.test.oneToMany;
  3. importhibernate.test.HibernateUtil;
  4. importhibernate.test.oneToMany.foreignKeyAsso.AccountEntity;
  5. importhibernate.test.oneToMany.foreignKeyAsso.EmployeeEntity;
  7. importjava.util.HashSet;
  8. importjava.util.Set;
  10. importorg.hibernate.Session;
  12. publicclassTestForeignKeyAssociation
  13. {
  15. publicstaticvoidmain(String[]args)
  16. {
  17. Sessionsession=HibernateUtil.getSessionFactory().openSession();
  18. session.beginTransaction();
  20. AccountEntityaccount1=newAccountEntity();
  21. account1.setAccountNumber("Accountdetail1");
  23. AccountEntityaccount2=newAccountEntity();
  24. account2.setAccountNumber("Accountdetail2");
  26. AccountEntityaccount3=newAccountEntity();
  27. account3.setAccountNumber("Accountdetail3");
  29. //AddnewEmployeeobject
  30. EmployeeEntityfirstEmployee=newEmployeeEntity();
  31. firstEmployee.setEmail("demo-user-first@mail.com");
  32. firstEmployee.setFirstName("demo-one");
  33. firstEmployee.setLastName("user-one");
  35. EmployeeEntitysecondEmployee=newEmployeeEntity();
  36. secondEmployee.setEmail("demo-user-second@mail.com");
  37. secondEmployee.setFirstName("demo-two");
  38. secondEmployee.setLastName("user-two");
  40. Set<AccountEntity>accountsOfFirstEmployee=newHashSet<AccountEntity>();
  41. accountsOfFirstEmployee.add(account1);
  42. accountsOfFirstEmployee.add(account2);
  44. Set<AccountEntity>accountsOfSecondEmployee=newHashSet<AccountEntity>();
  45. accountsOfSecondEmployee.add(account3);
  47. firstEmployee.setAccounts(accountsOfFirstEmployee);
  48. secondEmployee.setAccounts(accountsOfSecondEmployee);
  49. //SaveEmployee
  50. session.save(firstEmployee);
  51. session.save(secondEmployee);
  53. session.getTransaction().commit();
  54. HibernateUtil.shutdown();
  55. }
  56. }
  57. Output:
  59. Hibernate:insertintoEmployee(EMAIL,FIRST_NAME,LAST_NAME)values(?,?,?)
  60. Hibernate:insertintoACCOUNT(ACC_NUMBER,employee_ID)values(?,?)
  61. Hibernate:insertintoACCOUNT(ACC_NUMBER,employee_ID)values(?,?)
  62. Hibernate:insertintoEmployee(EMAIL,FIRST_NAME,LAST_NAME)values(?,?,?)
  63. Hibernate:insertintoACCOUNT(ACC_NUMBER,employee_ID)values(?,?)
  64. Hibernate:updateACCOUNTsetEMPLOYEE_ID=?whereID=?
  65. Hibernate:updateACCOUNTsetEMPLOYEE_ID=?whereID=?
  66. Hibernate:updateACCOUNTsetEMPLOYEE_ID=?whereID=?

使用关联表

这种方式使用关联表存储两个实体间的关系@JoinTable注解是用来建立这种关系的，先来看一下数据库模式

EMPLOYEE实体
[java] view plain copy
  1. packagehibernate.test.oneToMany.joinTable;
  3. importjava.io.Serializable;
  4. importjava.util.Set;
  6. importjavax.persistence.CascadeType;
  7. importjavax.persistence.Column;
  8. importjavax.persistence.Entity;
  9. importjavax.persistence.GeneratedValue;
  10. importjavax.persistence.GenerationType;
  11. importjavax.persistence.Id;
  12. importjavax.persistence.JoinColumn;
  13. importjavax.persistence.JoinTable;
  14. importjavax.persistence.OneToMany;
  15. importjavax.persistence.Table;
  16. importjavax.persistence.UniqueConstraint;
  18. @Entity(name="JoinTableEmployeeEntity")
  19. @Table(name="Employee",uniqueConstraints={
  20. @UniqueConstraint(columnNames="ID"),
  21. @UniqueConstraint(columnNames="EMAIL")})
  22. publicclassEmployeeEntityimplementsSerializable
  23. {
  24. privatestaticfinallongserialVersionUID=-1798070786993154676L;
  26. @Id
  27. @GeneratedValue(strategy=GenerationType.IDENTITY)
  28. @Column(name="ID",unique=true,nullable=false)
  29. privateIntegeremployeeId;
  31. @Column(name="EMAIL",unique=true,nullable=false,length=100)
  32. privateStringemail;
  34. @Column(name="FIRST_NAME",unique=false,nullable=false,length=100)
  35. privateStringfirstName;
  37. @Column(name="LAST_NAME",unique=false,nullable=false,length=100)
  38. privateStringlastName;
  40. @OneToMany(cascade=CascadeType.ALL)
  41. @JoinTable(name="EMPLOYEE_ACCOUNT",joinColumns={@JoinColumn(name="EMPLOYEE_ID",referencedColumnName="ID")}
  42. ,inverseJoinColumns={@JoinColumn(name="ACCOUNT_ID",referencedColumnName="ID")})
  43. privateSet<AccountEntity>accounts;
  45. publicIntegergetEmployeeId(){
  46. returnemployeeId;
  47. }
  49. publicvoidsetEmployeeId(IntegeremployeeId){
  50. this.employeeId=employeeId;
  51. }
  53. publicStringgetEmail(){
  54. returnemail;
  55. }
  57. publicvoidsetEmail(Stringemail){
  58. this.email=email;
  59. }
  61. publicStringgetFirstName(){
  62. returnfirstName;
  63. }
  65. publicvoidsetFirstName(StringfirstName){
  66. this.firstName=firstName;
  67. }
  69. publicStringgetLastName(){
  70. returnlastName;
  71. }
  73. publicvoidsetLastName(StringlastName){
  74. this.lastName=lastName;
  75. }
  77. publicSet<AccountEntity>getAccounts(){
  78. returnaccounts;
  79. }
  81. publicvoidsetAccounts(Set<AccountEntity>accounts){
  82. this.accounts=accounts;
  83. }
  84. }

Account实体
[java] view plain copy
  1. packagehibernate.test.oneToMany.joinTable;
  3. importjava.io.Serializable;
  5. importjavax.persistence.Column;
  6. importjavax.persistence.Entity;
  7. importjavax.persistence.GeneratedValue;
  8. importjavax.persistence.GenerationType;
  9. importjavax.persistence.Id;
  10. importjavax.persistence.Table;
  11. importjavax.persistence.UniqueConstraint;
  13. @Entity(name="JoinTableAccountEntity")
  14. @Table(name="ACCOUNT",uniqueConstraints={
  15. @UniqueConstraint(columnNames="ID")})
  16. publicclassAccountEntityimplementsSerializable
  17. {
  19. privatestaticfinallongserialVersionUID=-6790693372846798580L;
  21. @Id
  22. @GeneratedValue(strategy=GenerationType.IDENTITY)
  23. @Column(name="ID",unique=true,nullable=false)
  24. privateIntegeraccountId;
  26. @Column(name="ACC_NUMBER",unique=true,nullable=false,length=100)
  27. privateStringaccountNumber;
  29. publicIntegergetAccountId(){
  30. returnaccountId;
  31. }
  33. publicvoidsetAccountId(IntegeraccountId){
  34. this.accountId=accountId;
  35. }
  37. publicStringgetAccountNumber(){
  38. returnaccountNumber;
  39. }
  41. publicvoidsetAccountNumber(StringaccountNumber){
  42. this.accountNumber=accountNumber;
  43. }
  44. }

在配置文件中配置实体，我们已经有了两个在运行时的实体，我们必须在配置文件中增加他们。请注意只有一个集合实体可以在配置文件中配置，否则会有意外的情况发生
[java] view plain copy
  1. <?xmlversion="1.0"encoding="utf-8"?>
  2. <!DOCTYPEhibernate-configurationPUBLIC
  3. "-//Hibernate/HibernateConfigurationDTD3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6. <session-factory>
  7. <propertyname="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  8. <propertyname="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatetest</property>
  9. <propertyname="hibernate.connection.password">XXXXXX</property>
  10. <propertyname="hibernate.connection.username">root</property>
  11. <propertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  12. <propertyname="show_sql">true</property>
  13. <propertyname="hbm2ddl.auto">create</property>
  14. <mappingclas="hibernate.test.oneToMany.foreignKeyAsso.AccountEntity"></mapping>
  15. <mappingclas="hibernate.test.oneToMany.foreignKeyAsso.EmployeeEntity"></mapping>
  16. </session-factory>
  17. </hibernate-configuration>

测试代码：
[java] view plain copy
    1. packagehibernate.test.oneToMany;
    3. importhibernate.test.HibernateUtil;
    4. importhibernate.test.oneToMany.joinTable.AccountEntity;
    5. importhibernate.test.oneToMany.joinTable.EmployeeEntity;
    7. importjava.util.HashSet;
    8. importjava.util.Set;
    10. importorg.hibernate.Session;
    12. publicclassTestJoinTable
    13. {
    14. publicstaticvoidmain(String[]args)
    15. {
    16. Sessionsession=HibernateUtil.getSessionFactory().openSession();
    17. session.beginTransaction();
    19. AccountEntityaccount1=newAccountEntity();
    20. account1.setAccountNumber("123-345-65454");
    22. AccountEntityaccount2=newAccountEntity();
    23. account2.setAccountNumber("123-345-6542222");
    25. //AddnewEmployeeobject
    26. EmployeeEntityemp=newEmployeeEntity();
    27. emp.setEmail("demo-user@mail.com");
    28. emp.setFirstName("demo");
    29. emp.setLastName("user");
    31. Set<AccountEntity>accounts=newHashSet<AccountEntity>();
    32. accounts.add(account1);
    33. accounts.add(account2);
    35. emp.setAccounts(accounts);
    36. //SaveEmployee
    37. session.save(emp);

知识推荐

我的编程学习网——分享web前端后端开发技术知识。 垃圾信息处理邮箱 tousu563@163.com 网站地图
icp备案号 闽ICP备2023006418号-8 不良信息举报平台 互联网安全管理备案 Copyright 2023 www.wodecom.cn All Rights Reserved