Hibernate学习4—关联关系一对多映射2

第四节：班级学生一对多映射实现（双向）　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

查询班级的时候能够获取所有的学生；

 

在上一节的基础之上；我们在Class端也保存学生的关系；

com.cy.model.Class:

public class Class {
    private long id;
    private String name;
    private Set<Student> students = new HashSet<Student>();

    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
}

Class.hbm.xml:

<hibernate-mapping package="com.cy.model">
    <class name="Class" table="t_class">
        <id name="id" column="classId">
            <generator class="identity"></generator>
        </id>
        <property name="name" column="className"></property>
        <set name="students" cascade="save-update">
            <!-- key外键，column是对应Student表的外键classId
                 就是many-to-one中的column；
            -->
            <key column="classId"></key>
            <!-- class就是students属性，对应的集合中装的类Student -->
            <one-to-many class="com.cy.model.Student"/>
        </set>
    </class>
</hibernate-mapping>

com.cy.model.Student还和之前一样：

package com.cy.model;

public class Student {
    private long id;
    private String name;
    private Class c;

    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public Class getC() {
        return c;
    }
    public void setC(Class c) {
        this.c = c;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + "]";
    }

}

Student.hbm.xml还和之前一样：

<hibernate-mapping package="com.cy.model">
    <class name="Student" table="t_student">
        <id name="id" column="stuId">
            <generator class="identity"></generator>
        </id>
        <property name="name" column="stuName"></property>
        <many-to-one name="c" column="classId" class="com.cy.model.Class" cascade="save-update"></many-to-one>
    </class>
</hibernate-mapping>

测试代码StudentTest:

@Test
    public void testSaveClassAndStudent() {
        Class c = new Class();
        c.setName("08计本");

        Student s1 = new Student();
        s1.setName("张三");
        Student s2 = new Student();
        s2.setName("李四");

        c.getStudents().add(s1);
        c.getStudents().add(s2);

        //这里因为保存Class时，class引用了临时状态的s1、s2；会保存失败
        //必须在Class.hbm.xml中配置<set name="students" cascade="save-update"级联保存更新才可以。
        session.save(c);
    }

    /**
     * 通过班级端，查找学生
     */
    @Test
    public void getStudentsByClass() {
        Class c = (Class) session.get(Class.class, Long.valueOf(2));
        Set<Student> students = c.getStudents();

        Iterator<Student> it = students.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s);
        }

        //Student [id=1, name=李四]
        //Student [id=2, name=张三]
    }

保存成功！查询成功！

发出的sql：

第五节：inverse 属性　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

inverse属性主要是在一对多、多对一双向关系中，由一端来维护主外键关系；

 

测试代码：

@Test
    public void testAdd(){
        Class c=new Class();
        c.setName("09计本");

        Student s1=new Student();
        s1.setName("王五");

        session.save(c);
        session.save(s1);
    }

    @Test
    public void testInverse(){
        /**
         * Class和Student都是从session中获取的，都已经是持久化对象；
         * 对着两个持久化对象进行学生设置班级、班级也设置学生
         * 持久化对象设置关系，hibernate session检测到之后就会进行持久化操作（同步数据库）
         */
        Class c=(Class)session.get(Class.class, Long.valueOf(1));
        Student s=(Student)session.get(Student.class, Long.valueOf(1));

        s.setC(c);
        c.getStudents().add(s);

        /**
         * 可以看到学生设置班级、班级添加学生，两端都维护了这个关系，都维护了这个外键。
            引入inverse属性，只在某一端维护这个主外键关系。通常是在多的一端（one-to-many）设置inverse属性。
            这里就是在学生Student端添加inverse=true属性
         */
    }

1.先执行testAdd，再执行testInverse：

由于对student、class两个持久化的对象进行，互设关系的操作，hibernate session检测到之后就会进行持久化操作（同步数据库）：

确实数据库发现已经设置了外键关系，打印：

两端都来维护这个关系，发出两条sql语句，有点冗余，引入inverse：

Class.hbm.xml:

<hibernate-mapping package="com.cy.model">
    <class name="Class" table="t_class">
        <id name="id" column="classId">
            <generator class="identity"></generator>
        </id>
        <property name="name" column="className"></property>
        <set name="students" cascade="save-update" inverse="true">
            <!-- key外键，column是对应Student表的外键classId
                 就是many-to-one中的column；
            -->
            <key column="classId"></key>
            <!-- class就是students属性，对应的集合中装的类Student -->
            <one-to-many class="com.cy.model.Student"/>
        </set>
    </class>
</hibernate-mapping>

2.再次先执行testAdd，再执行testInverse：

只有一条sql了，只在多的一方来维护这个外键关系；

第六节：级联删除　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

删除班级的时候，我们把学生也删掉；

/**
     * 级联删除
     * 删除班级的时候，级联删除学生
     */
    @Test
    public void testDeleteClassCascade(){
        Class c=(Class)session.get(Class.class, Long.valueOf(1));
        session.delete(c);
    }

默认是不能级联删除的，因为删除class的时候，classId被student表外键关联；

会报错：

设置cascade=delete就可以级联删除了；

修改Class.hbm.xml配置如下：

<hibernate-mapping package="com.cy.model">
    <class name="Class" table="t_class">
        <id name="id" column="classId">
            <generator class="identity"></generator>
        </id>
        <property name="name" column="className"></property>
        <set name="students" cascade="delete" inverse="true">
            <key column="classId"></key>
            <one-to-many class="com.cy.model.Student"/>
        </set>
    </class>
</hibernate-mapping>

console：

注：级联删除是一个危险的操作，企业开发一般是不允许的；很可能导致其他业务数据的丢失。。。

第七节：一对多双向自身关联关系映射　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

例如使用在菜单上，使用节点来模拟：

com.cy.model.Node：

package com.cy.model;

import java.util.HashSet;
import java.util.Set;

public class Node {
    private long id;
    private String name;

    private Node parentNode;                            //它的父节点
    private Set<Node> childNodes = new HashSet<Node>();    //它的子节点

    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Node getParentNode() {
        return parentNode;
    }
    public void setParentNode(Node parentNode) {
        this.parentNode = parentNode;
    }
    public Set<Node> getChildNodes() {
        return childNodes;
    }
    public void setChildNodes(Set<Node> childNodes) {
        this.childNodes = childNodes;
    }

}

Node.hbm.xml:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.cy.model">
    <class name="Node" table="t_node">
        <id name="id" column="nodeId">
            <generator class="native"></generator>
        </id>
        <property name="name" column="nodeName"></property>

        <many-to-one name="parentNode" column="parentId" class="com.cy.model.Node" cascade="save-update"></many-to-one>

        <set name="childNodes" inverse="true">
            <key column="parentId"></key>
            <one-to-many class="com.cy.model.Node"/>
        </set>
    </class>
</hibernate-mapping>

将Node.hbm.xml加入hibernate.cfg.xml中mapping配置；

测试代码：

package com.cy.service;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.cy.model.Node;
import com.cy.util.HibernateUtil;

public class NodeTest {
    private SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
    private Session session;

    @Before
    public void setUp() throws Exception {
        session = sessionFactory.openSession();
        session.beginTransaction();
    }

    @After
    public void tearDown() throws Exception {
        session.getTransaction().commit();
        session.close();
    }

    @Test
    public void testSaveMenu() {
        Node node=new Node();
        node.setName("根节点");

        Node subNode1=new Node();
        subNode1.setName("子节点1");

        Node subNode2=new Node();
        subNode2.setName("子节点2");

        subNode1.setParentNode(node);
        subNode2.setParentNode(node);

        session.save(subNode1);
        session.save(subNode2);
    }
}

结果：