hibernate中ManyToOne单向

开始hibernate的关系映射，先来个多对一单向关系映射。例子是班级和学生之间的关系。

班级的实体和映射

Classroom.java

package org.zttc.itat.model;
 
import java.util.Set;
 
public class Classroom {
    private int id;
    private String name;
    private int grade;
    //set get 方法省去
}

Classroom.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="org.zttc.itat.model">
    <class name="Classroom" table="t_cla">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="grade"/>
    </class>
</hibernate-mapping>

学生的实体和映射

Student.java

package org.zttc.itat.model;
 
public class Student {
    private int id;
    private String name;
    private String no;
    private Classroom classroom;
    //set get 方法省去
}

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="org.zttc.itat.model">
    <class name="Student" table="t_stu">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="no"/>
        <!-- many-to-one用来映射多对一，name表示对象中的属性名称 ，
        column用来表示外键的名称-->
        <many-to-one name="classroom" column="cid"/>
    </class>
</hibernate-mapping>

测试方法：

public class TestManyToOne {
    @Test
    public void testAdd01() {
    Session session = null;
        try {
        session = HibernateUtil.openSession();
        session.beginTransaction();
        //先添加1
        Classroom c = new Classroom();
        c.setGrade(2012);
        c.setName("计算机网络技术");
        session.save(c);
        Student stu1 = new Student();
        stu1.setName("猪八戒");
        stu1.setNo("001");
        stu1.setClassroom(c);
        session.save(stu1);
        Student stu2 = new Student();
        stu2.setName("孙悟空");
        stu2.setNo("002");
        stu2.setClassroom(c);
        session.save(stu2);
     
        session.getTransaction().commit();
    } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.getTransaction().rollback();
    } finally {
        HibernateUtil.close(session);
    }
    }
     
    @Test
    public void testAdd02() {
    Session session = null;
    try {
            session = HibernateUtil.openSession();
        session.beginTransaction();
        //先添加多
        Student stu1 = new Student();
        stu1.setName("沙僧");
        stu1.setNo("003");
        session.save(stu1);
        Student stu2 = new Student();
        stu2.setName("唐僧");
        stu2.setNo("004");
        session.save(stu2);
        Classroom c = new Classroom();
        c.setGrade(2012);
        c.setName("计算机应用技术");
        session.save(c);
        //此时还会发两条update
        stu1.setClassroom(c);
        stu2.setClassroom(c);
        //最佳实践：一定要先添加一的一方，之后在添加多的一方
        session.getTransaction().commit();
    } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.getTransaction().rollback();
    } finally {
        HibernateUtil.close(session);
    }
    }
     
    @Test
    public void testLoad() {
    Session session = null;
    try {
            session = HibernateUtil.openSession();
        session.beginTransaction();
        Student stu = (Student)session.load(Student.class, 1);
        //此时仅仅只是发一条sql
        System.out.println(stu.getName());
        //此时student的关联对象Classroom也是延迟加载的，会再发一条sql来取对象
        System.out.println(stu.getClassroom().getName());
            session.getTransaction().commit();
    } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.getTransaction().rollback();
    } finally {
        HibernateUtil.close(session);
    }
    }
}

如果在添加student的时候，Classroom还没保存，就会出现抛异常如：

@Test
public void testAdd03() {
    Session session = null;
    try {
        session = HibernateUtil.openSession();
        session.beginTransaction();
        Classroom c = new Classroom();
        c.setGrade(2012);
        c.setName("计算机信息管理");
        //此时classroom没有存储，所以在添加student的时候没有外键，会抛出异常
        Student stu1 = new Student();
        stu1.setName("如来");
        stu1.setNo("005");
        session.save(stu1);
        Student stu2 = new Student();
        stu2.setName("观音");
        stu2.setNo("006");
        session.save(stu2);
        stu1.setClassroom(c);
        stu2.setClassroom(c);
        session.getTransaction().commit();
    } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.getTransaction().rollback();
    } finally {
        HibernateUtil.close(session);
    }
}

这时我们可以添加级联（级联是指两个对象之间的操作联动关系，对一个对象执行了操作之后，对其指定的级联对象也需要执行相同的操作）

修改Student.hbm.xml，在many-to-one加cascade属性

<!-- 当设置了cascade的时候，会自动完成关联，如果添加时没有关联对象，会自动创建一个关联对象
    最佳实践：如果没有特殊情况不要使用cascade,特别注意，可能使用cascade的地方一般都是一的一方进行删除时使用，特殊需求才会使用cascade的add，正常情况add方法都是应该有程序员完成添加 -->
<many-to-one name="classroom" column="cid" cascade="add"/>

对“可能使用cascade的地方一般都是一的一方进行删除时使用”这句话解释一下，如果在多的一方设置级联删除，例如删除一个学生，也把一个班级给删了，但这个班级可能还有其他学生，所以删除的时候会出异常。所以如果要用，就用在一的一方。

一般对<many-to-one>或<many-to-many>关联关系不设置级联（Cascade）操作

本文链接：hibernate中ManyToOne单向，由领悟书生原创(笔记)，转载请注明出处http://www.656463.com/article/397