8.hibernate映射(一對多)

一對多也是分為兩種：

  • 單向一對多
  • 雙向一對多

先來看一下公用的實體類

classes實體類

    package entity;
    
    import java.util.Set;
    
    public class Classes {
        private int id;
        private String className;
        private Set<Student> student;
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getClassName() {
            return className;
        }
        public void setClassName(String className) {
            this.className = className;
        }
        public Set<Student> getStudent() {
            return student;
        }
        public void setStudent(Set<Student> student) {
            this.student = student;
        }
    }

student實體類（單向的時候沒有class這個屬性）

    package entity;
    
    public class Student {
        private int id;
        private String name;
        private Classes classes;
        
        
        public Classes getClasses() {
            return classes;
        }
        public void setClasses(Classes classes) {
            this.classes = classes;
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }

單向一對多

classes.hbm.xml

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="entity">
        <class name="Classes" dynamic-update="true" >
            <id name="id">
                <generator class="native"/>
            </id>
            <property name="className" />
            <set name="student" cascade="delete">
                <!-- 這里的column是指數據庫中student表中會添加外鍵classid，關聯classes表的主鍵 -->
                <key column="classid"></key>
                <one-to-many class="Student" />
            </set>
        </class>    
    </hibernate-mapping>

student.hbm.xml

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping  package="entity">
        <class name="Student" dynamic-update="true">
            <id name="id">
                <generator class="native"/>
            </id>
            <property name="name" />
        </class>    
    </hibernate-mapping>

單元測試：

    package entity;
    
    import java.util.ArrayList;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    import org.hibernate.classic.Session;
    
    import junit.framework.TestCase;
    import util.hibernateUtil;
    
    /**
     * 單向一對多（項目名稱寫錯了，應該是一對多）
     * 測試目的：
     * 1. 新增數據，是否會級聯保存？什么時候發出sql語句？
     * 2. 查詢數據，會不會級聯查詢？
     * 3. 刪除數據，會不會級聯刪除？
     * @author arkulo
     *
     */
    
    public class testManytoone extends TestCase {
        // 新增數據
        public void test1() {
            Session session = null;
    
            try {
                session = hibernateUtil.getSession();
                session.beginTransaction();
    
                Student st1 = new Student();
                st1.setName("張三");
                Student st2 = new Student();
                st2.setName("李四");
                Student st3 = new Student();
                st3.setName("王五");
    
                // 這里必須先保存三個student，否則它們沒有ID，最后會拋異常
                // 這是sql執行的順序
                // Hibernate: insert into Student (name) values (?)
                // Hibernate: insert into Student (name) values (?)
                // Hibernate: insert into Student (name) values (?)
                // Hibernate: insert into Classes (className) values (?)
                // Hibernate: update Student set classid=? where id=?
                // Hibernate: update Student set classid=? where id=?
                // Hibernate: update Student set classid=? where id=?
    
                session.save(st1);
                session.save(st2);
                session.save(st3);
    
    //          這屬于在one的一方維護關系
                Set<Student> set = new HashSet<Student>();
                set.add(st1);
                set.add(st2);
                set.add(st3);
    
                Classes cl = new Classes();
                cl.setClassName("一年級三班");
                cl.setStudent(set);
    
                session.save(cl);
    
                session.getTransaction().commit();
            } catch (Exception e) {
                e.printStackTrace();
                session.getTransaction().rollback();
            } finally {
                hibernateUtil.closeSession(session);
            }
        }
    
        // 查詢數據
        public void test2() {
            test1();
            System.out.println("-------------------------------------------------");
            Session session = null;
    
            try {
                session = hibernateUtil.getSession();
                session.beginTransaction();
    
                // 發出兩條sql語句
                // 如果沒有緩存的情況下，這里的iterate會產生n+1問題
                Iterator st = session.createQuery("from Classes").iterate();
                while (st.hasNext()) {
                    Classes cl = (Classes) st.next();
                    System.out.println("班級：" + cl.getClassName());
                    Set<Student> students = cl.getStudent();
                    Iterator<Student> it = students.iterator();
                    while (it.hasNext()) {
                        Student s = it.next();
                        System.out.println("用戶名：" + s.getName());
                    }
                }
    
                session.getTransaction().commit();
            } catch (Exception e) {
                e.printStackTrace();
                session.getTransaction().rollback();
            } finally {
                hibernateUtil.closeSession(session);
            }
        }
    
        // 刪除數據
        public void test3() {
            test1();
            System.out.println("-------------------------------------------------");
            Session session = null;
    
            try {
                session = hibernateUtil.getSession();
                session.beginTransaction();
    
                // 再不設置級聯的情況下，刪除classes，是否會刪除student的記錄
                Classes cl = (Classes) session.get(Classes.class, 1);
                System.out.println("班級名稱:" + cl.getClassName());
                Set<Student> students = cl.getStudent();
                Iterator<Student> it = students.iterator();
                while (it.hasNext()) {
                    Student s = it.next();
                    System.out.println("學生姓名：" + s.getName());
                }
    
                System.out.println("------------------------------------------");
                // 不設置級聯關系為delete的情況下，刪除classes，會自動的把student表中的classid字段設置為null
                // 設置級聯關系為delete后，sql語句順序為下：
                // Hibernate: update Student set classid=null where classid=?
                // Hibernate: delete from Student where id=?
                // Hibernate: delete from Student where id=?
                // Hibernate: delete from Student where id=?
                // Hibernate: delete from Classes where id=?
                // 可以看出，即使設置了級聯為delete，也會先更新classid字段為null，然后在刪除student，最后刪除classes
                session.delete(cl);
    
                session.getTransaction().commit();
            } catch (Exception e) {
                e.printStackTrace();
                session.getTransaction().rollback();
            } finally {
                hibernateUtil.closeSession(session);
            }
        }
    
    }

雙向一對多

classes.hbm.xml

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="entity">
        <class name="Classes" dynamic-update="true" >
            <id name="id">
                <generator class="native"/>
            </id>
            <property name="className" />
            <set name="student" cascade="delete" inverse="true">
                <!-- 這里的column是指數據庫中student表中會添加外鍵classid，關聯classes表的主鍵 -->
                <key column="classid"></key>
                <one-to-many class="Student" />
            </set>
        </class>    
    </hibernate-mapping>

student.hbm.xml

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping  package="entity">
        <class name="Student" dynamic-update="true">
            <id name="id">
                <generator class="native"/>
            </id>
            <property name="name" />
            <many-to-one name="classes" column="classid"></many-to-one>
        </class>    
    </hibernate-mapping>

單元測試：

    package entity;
    
    import java.util.ArrayList;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    import org.hibernate.classic.Session;
    
    import junit.framework.TestCase;
    import util.hibernateUtil;
    
    /**
     * 雙向一對多（一般情況下，不推薦在one的一方維護關系）
     * 
     * 測試目的
     * 0. 使many方的設置失效，由one方維護關系
     * 1. 新增數據，是否會級聯保存？什么時候發出sql語句？
     * 2. 查詢數據，會不會級聯查詢？
     * 3. 刪除數據，會不會級聯刪除？
     * @author arkulo
     *
     */
    
    public class testManytoone extends TestCase {
        // 新增數據
        public void test1() {
            Session session = null;
    
            try {
                session = hibernateUtil.getSession();
                session.beginTransaction();
                
                Classes cl = new Classes();
                cl.setClassName("一年級三班");
                session.save(cl);
    //          這是在many端維護的關系，比較簡單，起碼不用中間還需要一個set集合
                Student st1 = new Student();
                st1.setName("張三");
                st1.setClasses(cl);
    
                session.save(st1);
    
                session.getTransaction().commit();
            } catch (Exception e) {
                e.printStackTrace();
                session.getTransaction().rollback();
            } finally {
                hibernateUtil.closeSession(session);
            }
        }
    
        // 查詢數據
        public void test2() {
            test1();
            System.out.println("-------------------------------------------------");
            Session session = null;
    
            try {
                session = hibernateUtil.getSession();
                session.beginTransaction();
    
                // 發出兩條sql語句
                // 如果沒有緩存的情況下，這里的iterate會產生n+1問題
                Iterator st = session.createQuery("from Classes").iterate();
                while (st.hasNext()) {
                    Classes cl = (Classes) st.next();
                    System.out.println("班級：" + cl.getClassName());
                    Set<Student> students = cl.getStudent();
                    Iterator<Student> it = students.iterator();
                    while (it.hasNext()) {
                        Student s = it.next();
                        System.out.println("用戶名：" + s.getName());
                    }
                }
    
                session.getTransaction().commit();
            } catch (Exception e) {
                e.printStackTrace();
                session.getTransaction().rollback();
            } finally {
                hibernateUtil.closeSession(session);
            }
        }
    
        // 刪除數據
        public void test3() {
            test1();
            System.out.println("-------------------------------------------------");
            Session session = null;
    
            try {
                session = hibernateUtil.getSession();
                session.beginTransaction();
    
                // 再不設置級聯的情況下，刪除classes，是否會刪除student的記錄
                Classes cl = (Classes) session.get(Classes.class, 1);
                System.out.println("班級名稱:" + cl.getClassName());
                Set<Student> students = cl.getStudent();
                Iterator<Student> it = students.iterator();
                while (it.hasNext()) {
                    Student s = it.next();
                    System.out.println("學生姓名：" + s.getName());
                }
    
                System.out.println("------------------------------------------");
                // 不設置級聯關系為delete的情況下，刪除classes，系統會提示外鍵關聯并拋出異常
                
    //          在student映射文件上設置級聯為delete，系統也會報錯，因為這里我們刪除的是classes
                
                // 在classes上設置級聯關系為delete后，sql語句順序為下：
    //          Hibernate: delete from Student where id=?
    //          Hibernate: delete from Classes where id=?
                // 這樣就實現了級聯刪除
                session.delete(cl);
    
                session.getTransaction().commit();
            } catch (Exception e) {
                e.printStackTrace();
                session.getTransaction().rollback();
            } finally {
                hibernateUtil.closeSession(session);
            }
        }
    
    }
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 1. Java基礎部分 基礎部分的順序：基本語法，類相關的語法，內部類的語法，繼承相關的語法，異常的語法，線程的語...
    子非魚_t_閱讀 31,779評論 18贊 399
  • 其實和多對一本質上是一樣的，也是在many的一方加一個字段作為外鍵，指向one的一方的主鍵，只是加載的時候不一樣。...
    yjaal閱讀 327評論 0贊 1
  • 一. Java基礎部分.................................................
    wy_sure閱讀 3,839評論 0贊 11
  • 再開始本次知識點之前，我們先來思考下get與load的區別。 對于Hibernate get方法，Hibernat...
    FTOLsXD閱讀 368評論 0贊 1
  • 3.4 有時候，原以為艱難的事情做起來竟然很簡單，其實是你給自己設了一道坎，把自己看的太低，把問題看的太大而已。而...
    real_x閱讀 432評論 0贊 0