hibernate 一对多注解开发

hibernate 注解配置一对多关系


     从hibernate 2.5开始就可以使用annotation实现实体关系的映射了,减少了配置hbm文件的繁琐,而且annotation也是一种趋势,现在的SSH2的整合都是完全可以用annotation来实现。在以前实现一对多关联的关联式都是使用hbm文件,今天我们来使用annotation试试,同样也能实现其功能。

1.数据库:oracle数据库,有person和address二张表,一对多的关系。

数据库:
[java]  view plain  copy
  1. create table person  
  2.         (  
  3.                 id number(4) not null,  
  4.                 uname varchar (20)  
  5.         );  
  6.         create table address  
  7.                 (  
  8.                         id number(4) not null,  
  9.                 address varchar(20) not null,  
  10.                 personId number(4) not null  
  11.         )  
  12.         alter table person  
  13.         add constraint primary_id parmary key(id)  
  14.         deferrable initially deferred;  


2.Person实体类:

[java]  view plain  copy
  1. "font-size:14px;">package com.zengguo.po;  
  2. import java.io.Serializable;  
  3. import java.util.HashSet;  
  4. import java.util.Set;  
  5. import javax.persistence.CascadeType;  
  6. import javax.persistence.Column;  
  7. import javax.persistence.Entity;  
  8. import javax.persistence.GeneratedValue;  
  9. import javax.persistence.Id;  
  10. import javax.persistence.JoinColumn;  
  11. import javax.persistence.OneToMany;  
  12. import javax.persistence.Table;  
  13. import org.hibernate.annotations.Fetch;  
  14. import org.hibernate.annotations.FetchMode;  
  15. import org.hibernate.annotations.GenericGenerator;  
  16. import org.hibernate.annotations.Parameter;  
  17. @SuppressWarnings(“serial”)  
  18. @Entity  
  19. @Table(name = “person”)  
  20. public class Person implements Serializable {  
  21. //oracle 序列  
  22. @Id  
  23. @GenericGenerator(name = “personGenericGenerator”, strategy = “sequence”,  
  24. parameters = { @Parameter(value = “hibernate_seq”, name = “sequence”) })  
  25. @GeneratedValue(generator=”personGenericGenerator”)  
  26. private long id;  
  27. @Column(name=”uname”)  
  28. private String uname;  
  29. @OneToMany(targetEntity=Address.class,cascade=CascadeType.ALL)  
  30. @Fetch(FetchMode.JOIN)  
  31. //updatable=false很关键,如果没有它,在级联删除的时候就会报错(反转的问题)  
  32. @JoinColumn(name=”personId”,updatable=false)  
  33. private Set
     sets = new HashSet
    ();  
  34. public Set
     getSets() {  
  35. return sets;  
  36. }  
  37. public void setSets(Set
     sets) {  
  38. this.sets = sets;  
  39. }  
  40. public Person() {  
  41. super();  
  42. }  
  43. public long getId() {  
  44. return id;  
  45. }  
  46. public void setId(long id) {  
  47. this.id = id;  
  48. }  
  49. public String getUname() {  
  50. return uname;  
  51. }  
  52. public void setUname(String uname) {  
  53. this.uname = uname;  
  54. }  
  55. }  


3.Address实体类

[java]  view plain  copy
  1. "font-size:14px;">package com.zengguo.po;  
  2. import javax.persistence.Column;  
  3. import javax.persistence.Entity;  
  4. import javax.persistence.GeneratedValue;  
  5. import javax.persistence.Id;  
  6. import javax.persistence.JoinColumn;  
  7. import javax.persistence.ManyToOne;  
  8. import javax.persistence.Table;  
  9. import org.hibernate.annotations.GenericGenerator;  
  10. import org.hibernate.annotations.Parameter;  
  11. @SuppressWarnings(“serial”)  
  12. @Entity  
  13. @Table(name = “address”)  
  14. public class Address implements java.io.Serializable {  
  15. //使用序列生成主键  
  16. @Id  
  17. @GenericGenerator(name = “addressGenericGenerator”, strategy = “sequence”,  
  18. parameters = { @Parameter(value = “hibernate_seq”, name = “sequence”) })  
  19. @GeneratedValue(generator = “addressGenericGenerator”)  
  20. private long id;  
  21. @Column(name = “address”)  
  22. private String address;  
  23. //多对一,@JoinColumn与@column类似,指定映射的数据库字段  
  24. @ManyToOne(targetEntity = Person.class)  
  25. @JoinColumn(name=”personId”,updatable=false)  
  26. private Person person;  
  27. public Address() {  
  28. super();  
  29. }  
  30. public long getId() {  
  31. return id;  
  32. }  
  33. public void setId(long id) {  
  34. this.id = id;  
  35. }  
  36. public String getAddress() {  
  37. return address;  
  38. }  
  39. public void setAddress(String address) {  
  40. this.address = address;  
  41. }  
  42. public Person getPerson() {  
  43. return person;  
  44. }  
  45. public void setPerson(Person person) {  
  46. this.person = person;  
  47. }  
  48. }  




hibernate一对多mappedBy的用法:(班级classes和学生student,一对多的关系)

[java]  view plain  copy
  1. "font-size:14px;">package oneToMany;   
  2. import java.util.Set;   
  3. import javax.persistence.*;   
  4. /*  
  5. 注意导入时,是导入:import javax.persistence.*;     
  6. 非导入org.hibernate的相关类:import org.hibernate.annotations.Entity;  
  7. */   
  8. @Entity   
  9. @Table(name="classes")   
  10. public class Classes implements Serializable {   
  11.   @Id   
  12.   @GeneratedValue(strategy=GenerationType.AUTO)   
  13.   private int id;   
  14.   private String name;   
  15.       
  16.   @OneToMany(cascade=CascadeType.ALL,mappedBy="classes")      
  17.   private Set students;   
  18. //getter,setter省略   
  19. }   
  20.   
  21.   
  22. package oneToMany;   
  23. import javax.persistence.*;   
  24. @Entity   
  25. @Table(name="student")   
  26. public class Student implements Serializable  {   
  27.   @Id   
  28.   @GeneratedValue(strategy=GenerationType.AUTO)   
  29.   private int sid;   
  30.       
  31.   private String sname;   
  32.       
  33.   //若有多个cascade,可以是:{CascadeType.PERSIST,CascadeType.MERGE}   
  34.   @ManyToOne(cascade={CascadeType.ALL})           
  35.   @JoinColumn(name="classid")     //student类中对应外键的属性:classid   
  36.   private Classes classes;   
  37. //getter,setter省略   
  38. }   
  39.   
  40.   
  41. public class TestOneToMany {   
  42. /*  
  43. CREATE TABLE    student (    --要定义外键!!!!!!!  
  44.     `sid` double NOT NULL auto_increment,  
  45.     `classid` double NULL,  
  46.     `sname` varchar(255) NOT NULL,  
  47.     PRIMARY KEY    (sid),  
  48.     INDEX par_ind (classid),  
  49.     FOREIGN KEY (classid) REFERENCES classes(id) ON DELETE CASCADE ON UPDATE CASCADE  
  50. ) ENGINE=InnoDB  
  51. */      
  52.   public static void main(String[] args) throws SQLException      
  53.   {   
  54.     try   
  55.     {   
  56.       SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();   
  57.       Session session=sf.openSession();   
  58.       Transaction tx=session.beginTransaction();           
  59. /* 
  60. 因为mappedBy是定义在classes中,即classes类不负责维护级联关系.即维护者是student.所以, 
  61. 1.要将clsses的数据,赋给student,即用student的setClasses()方法去捆定class数据; 
  62. 2.在进行数据插入/更新session.save()/session.update()时,最后操作的是student. 
  63. */  
  64.       Classes classes=new Classes();   
  65.       classes.setName("access");   
  66.           
  67.       Student st1=new Student();   
  68.       st1.setSname("jason");   
  69.       st1.setClasses(classes);   
  70.       session.save(st1);   
  71.           
  72.       Student st2=new Student();   
  73.       st2.setSname("hwj");   
  74.       st2.setClasses(classes);   
  75.       session.save(st2);   
  76.       tx.commit();  
  77. /*  
  78. 输出如下: 
  79. Hibernate: insert into classes (name) values (?) 
  80. Hibernate: insert into student (classid, sname) values (?, ?) 
  81. Hibernate: insert into student (classid, sname) values (?, ?) 
  82. */  
  83. /* 
  84. 因为一端维护关系另一端不维护关系的原因,我们必须注意避免在应用中用不维护关系的类(class)建立关系,因为这样建立的关系是不会在数据库中存储的。 
  85. 如上的代码倒过来,则插入时,student的外键值为空.如下: 
  86. */  
  87. //      Student st1=new Student();   
  88. //      st1.setSname("jason");   
  89. //      session.save(st1);   
  90. //          
  91. //      Student st2=new Student();   
  92. //      st2.setSname("hwj");   
  93. //      session.save(st2);   
  94. //          
  95. //      Set students=new HashSet();   
  96. //      students.add(st1);   
  97. //      students.add(st2);   
  98. //          
  99. //      Classes classes=new Classes();   
  100. //      classes.setName("access");   
  101. //      classes.setStudents(students);   
  102. //      session.save(classes);   
  103. /* 
  104. 输出如下: 
  105. Hibernate: insert into student (classid, sname) values (?, ?) 
  106. Hibernate: insert into student (classid, sname) values (?, ?) 
  107. Hibernate: insert into classes (name) values (?) 
  108. */  
  109.     }   
  110.     catch(HibernateException e)   
  111.     {   
  112.       e.printStackTrace();          
  113.     }   
  114.   }   
  115. }  
  116.    
  117.   

你可能感兴趣的:(hibernate)