hibernate一对多关联映射（二）－－－双向关联

1.新建工程项目hibernate_one2many_2,在该项目下添加hibernate所需的Jar包和数据库mysql驱动Jar包。

2.编写工具类HibernateUtils和ExportDB,代码如下：

    HibernateUtils.java

1. package com.i51pro.hibernate;
3. import org.hibernate.Session;
4. import org.hibernate.SessionFactory;
5. import org.hibernate.cfg.Configuration;
7. public class HibernateUtils {
9.     private static SessionFactory sessionFactory;
10.     static {
11.         try {
12.             Configuration cfg = new Configuration().configure();
13.             sessionFactory = cfg.buildSessionFactory();
14.         } catch (Exception e) {
15.             e.printStackTrace();
16.         }
17.     }
19.     public static SessionFactory getSessionFactory() {
20.         return sessionFactory;
21.     }
23.     public static Session getSession() {
24.         return sessionFactory.openSession();
25.     }
27.     public static void closeSession(Session session) {
28.         if (session != null) {
29.             if (session.isOpen()) {
30.                 session.close();
31.             }
32.         }
33.     }
34. }

    ExportDB.java

1. package com.i51pro.hibernate;
3. import org.hibernate.cfg.Configuration;
4. import org.hibernate.tool.hbm2ddl.SchemaExport;
6. public class ExportDB {
8.     /**
9.      * @param args
10.      */
11.     public static void main(String[] args) {
12.         Configuration cfg = new Configuration().configure();
13.         
14.         SchemaExport export = new SchemaExport(cfg);
15.         export.create(true, true);
16.     }
17. }

 

3.编写实体类和映射文件，代码如下：

    Student.java

 

1. package com.i51pro.hibernate;
3. public class Student {
5.     private int id;
6.     
7.     private String name;
9.     private Classes classes;
10.     
11.     public int getId() {
12.         return id;
13.     }
15.     public void setId(int id) {
16.         this.id = id;
17.     }
19.     public String getName() {
20.         return name;
21.     }
23.     public void setName(String name) {
24.         this.name = name;
25.     }
27.     public Classes getClasses() {
28.         return classes;
29.     }
31.     public void setClasses(Classes classes) {
32.         this.classes = classes;
33.     }
34. }

     Classes.java

1. package com.i51pro.hibernate;
3. import java.util.Set;
5. public class Classes {
7.     private int id;
8.     
9.     private String name;
10.     
11.     private Set students;
13.     public int getId() {
14.         return id;
15.     }
17.     public void setId(int id) {
18.         this.id = id;
19.     }
21.     public String getName() {
22.         return name;
23.     }
25.     public void setName(String name) {
26.         this.name = name;
27.     }
29.     public Set getStudents() {
30.         return students;
31.     }
33.     public void setStudents(Set students) {
34.         this.students = students;
35.     }
36. }

    Student.hbm.xml

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.i51pro.hibernate.Student" table="t_student">
7.         <id name="id">
8.             <generator class="native"/>
9.         </id>
10.         <property name="name" />
11.         <many-to-one name="classes" column="classesid" />
12.     </class>
13. </hibernate-mapping>

    Classes.hbm.xml

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.i51pro.hibernate.Classes" table="t_classes">
7.         <id name="id">
8.             <generator class="native" />
9.         </id>
10.         <property name="name"/>
11.         <set name="students" inverse="true" cascade="all">
12.             <key column="classesid" />
13.             <one-to-many class="com.i51pro.hibernate.Student"/>
14.         </set>
15.     </class>
16. </hibernate-mapping>

4.编写hibernate映射文件，代码如下：

1. <!DOCTYPE hibernate-configuration PUBLIC
2.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
3.     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
5. <hibernate-configuration>
6.     <session-factory>
7.         <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate_one2many_2</property>
8.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
9.         <property name="hibernate.connection.username">root</property>
10.         <property name="hibernate.connection.password">admin</property>
11.         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
12.         <property name="hibernate.show_sql">true</property>
13.         
14.         <mapping resource="com/i51pro/hibernate/Student.hbm.xml"/>
15.         <mapping resource="com/i51pro/hibernate/Classes.hbm.xml"/>
16.     </session-factory>
17. </hibernate-configuration>

4.在工程项目hibernate_one2many_2下，建立SourceFolder,命名为test,在该包下编写测试类One2ManyTest，进行单元测试，代码如下：

1. package com.i51pro.hibernate;
3. import java.util.HashSet;
4. import java.util.Iterator;
5. import java.util.Set;
8. import org.hibernate.Session;
9. import org.hibernate.Transaction;
11. import junit.framework.TestCase;
13. public class One2ManyTest extends TestCase {
15.     public void testSave1() {
16.         Session session = null;
17.         try {
18.             session = HibernateUtils.getSession();
19.             Transaction tx = session.beginTransaction();
20.             
21.             Student student1 = new Student();
22.             student1.setName("学生1");
23.             session.save(student1);
24.             
25.             Student student2 = new Student();
26.             student2.setName("学生2");
27.             session.save(student2);
28.             
29.             Set students = new HashSet();
30.             students.add(student1);
31.             students.add(student2);
32.             
33.             Classes classes = new Classes();
34.             classes.setName("JAVA学习小组");
35.             classes.setStudents(students);
36.             
37.             //可以保存 
38.             session.save(classes);
39.             
40.             session.getTransaction().commit();
41.         }catch(Exception e) {
42.             e.printStackTrace();
43.             session.getTransaction().rollback();
44.         }finally {
45.             HibernateUtils.closeSession(session);                           
46.         }
47.     }
48.     
49.     public void testSave2() {
50.         Session session = null;
51.         try {
52.             session = HibernateUtils.getSession();
53.             Transaction tx = session.beginTransaction();
54.             
55.             Classes classes = new Classes();
56.             classes.setName("JAVA研发小组");
57.             session.save(classes);
58.             
59.             Student student1 = new Student();
60.             student1.setName("程序员1");
61.             student1.setClasses(classes);
62.             session.save(student1);
63.             
64.             Student student2 = new Student();
65.             student2.setName("程序员2");
66.             student2.setClasses(classes);
67.             session.save(student2);
68.             
69.             session.getTransaction().commit();
70.         }catch(Exception e) {
71.             e.printStackTrace();
72.             session.getTransaction().rollback();
73.         }finally {
74.             HibernateUtils.closeSession(session);                           
75.         }
76.     }
77.     
78.     public void testSave3() {
79.         Session session = null;
80.         try {
81.             session = HibernateUtils.getSession();
82.             Transaction tx = session.beginTransaction();
83.             
84.             Classes classes = new Classes();
85.             classes.setName("JAVA研发开小组");
86.             
87.             Student student1 = new Student();
88.             student1.setName("程序员1");
89.             student1.setClasses(classes);
90.             
91.             Student student2 = new Student();
92.             student2.setName("程序员2");
93.             student2.setClasses(classes);
94.             
95.             Set students = new HashSet();
96.             students.add(student1);
97.             students.add(student2);
98.             
99.             classes.setStudents(students);
100.             
101.             //可以正确保存
102.             session.save(classes);
103.             
104.             session.getTransaction().commit();
105.         }catch(Exception e) {
106.             e.printStackTrace();
107.             session.getTransaction().rollback();
108.         }finally {
109.             HibernateUtils.closeSession(session);                           
110.         }
111.     }
112.     
113.     public void testLoad1() {
114.         Session session = null;
115.         try {
116.             session = HibernateUtils.getSession();
117.             session.beginTransaction();
118.             
119.             Classes classes = (Classes)session.load(Classes.class, 2);
120.             System.out.println("classes.name=" + classes.getName());
121.             Set students = classes.getStudents();
122.             for (Iterator iter=students.iterator(); iter.hasNext();) {
123.                 Student student = (Student)iter.next();
124.                 System.out.println("student.name=" + student.getName());
125.             }
126.             session.getTransaction().commit();
127.         }catch(Exception e) {
128.             e.printStackTrace();
129.             session.getTransaction().rollback();
130.         }finally {
131.             HibernateUtils.closeSession(session);
132.         }
133.     }       
134.     
135.     public void testLoad2() {
136.         Session session = null;
137.         try {
138.             session = HibernateUtils.getSession();
139.             session.beginTransaction();
140.             
141.             Student student = (Student)session.load(Student.class, 1);
142.             System.out.println("student.name=" + student.getName());
143.             System.out.println("student.classes.name=" + student.getClasses().getName());
144.             session.getTransaction().commit();
145.         }catch(Exception e) {
146.             e.printStackTrace();
147.             session.getTransaction().rollback();
148.         }finally {
149.             HibernateUtils.closeSession(session);
150.         }
151.     }       
152. }

 

总结：hihernate一对多关联映射（双向Classes<----->Student）

一对多双向关联映射：
 * 在一一端的集合上使用<key>，在对方表中加入一个外键指向一一端
 * 在多一端采用<many-to-one>
 
注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引用字段的错误
 
如果在”一“一端维护一对多关联关系，hibernate会发出多余的udpate语句，所以我们一般在多
的一端来维护关联关系

关于inverse属性：
 inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签<set>上，
 默认inverse为false，所以我们可以从”一“一端和”多“一端维护关联关系，
 如果设置成inverse为true，则我们只能从多一端来维护关联关系
 
 注意：inverse属性，只影响数据的存储，也就是持久化
  
inverse和cascade
 * inverse是关联关系的控制方向
 * cascade操作上的连锁反应