目录
第一节：班级学生一对多映射实现（单向）
第二节：Junit4 方法详解
|
setUpBeforeClass() 类初始化前调用; tearDownAfterClass() 类初始化后调用; setUp() 在测试方法前调用; tearDown() 在测试方法后调用; |
第三节：级联保存更新
|
在<many-to-one>这端，cascade 默认是”none”。 假如我们希望（不用save()方法）在持久化多的一端的时候，也能自动级联保存和更新，我们可以把 cascade 设置成”save-update”； |
第四节：班级学生一对多映射实现（双向）
第五节：inverse 属性
第六节：级联删除
第七节：一对多双向自身关联关系映射
（1）班级学生一对多映射实现（单向）
新建一个班级类：
Class.java代码内容： 快捷生成的get/set方法：shift+ alt+ s
源代码：
package model;
public class Class {
private long id;
private String name;
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;
}
}
再生成class对象的 hibernate映射文件。
Class.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="model">
<class name="Class" table="t_class">
<id name="id" column="classId">
<generator class="native"></generator>
</id>
<property name="name" column="className"></property>
</class>
</hibernate-mapping>
再更改一下Student.hbm.class内容：
如何用hibernate实现多对一的关系：
课程与学生之间的关系为：一对多。
因此实现单向关联时，
首先在多的一方：（学生方），声明一个私有的以班级为类的班级属性。
之后还会再Class中关联集合。
这个对象也是需要get/set方法的。
于是Student.java源代码为：
package 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;
}
//为了打印方便，把toString的方法重写
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}
}
然后需要在student对象的hibernate配置文件中配置项对应的关系。
多对一的关联就配置完毕了。
去hibernate的全局配置文件中添加Class的映射文件。（hibernate.cfg.xml）
进入数据库，先将student表删除，再删除class表，再进行测试StudentTest.java文件。
点击运行之后，看数据库：
如下：
这样实现就完成啦！！！
（2）Junit4 方法详解
StudentTest.java
内容：并运行。
源代码：
package service;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import model.Student;
import util.HibernateUtil;
import model.Class;
public class StudentTest {
public static void main(String[] args) {
SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
Session session=sessionFactory.openSession(); // 生成一个session
session.beginTransaction(); // 开启事务
Class c=new Class();
c.setName("08计本");
session.save(c);
Student s1=new Student();
s1.setName("张三");
s1.setC(c);
Student s2=new Student();
s2.setName("王五");
s2.setC(c);
session.save(s1);
session.save(s2);
session.getTransaction().commit(); // 提交事务
session.close(); // 关闭session
//sessionFactory.close(); // 关闭session工厂
}
}
打开【Hibernate02】项目
然后我们发现在写方法的时候很麻烦，所以有一个用Junit的优化的方法
我们可以发现，每次的方法里都有重复的东西：
这时候我们就可以用到junit对其进行优化：
首先New一个新的junit case
StudentTest2源代码：
package service;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
public class StudentTest2 {
@BeforeClass
public static void setUpBeforeClass() throws Exception {
System.out.println("类初始化前调用。。。");
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
System.out.println("类初始化后调用。。。");
}
@Before
public void setUp() throws Exception {
System.out.println("测试方法前调用。。。");
}
@After
public void tearDown() throws Exception {
System.out.println("测试方法后调用。。。");
}
@Test
public void test() {
System.out.println("测试方法");
}
}
再新建一个Junit case,命名为StudentTest3
其可以简介化代码成如下模样：
StudentTest3:
package service;
import static org.junit.Assert.fail;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import model.Student;
import util.HibernateUtil;
public class StudentTest3 {
private static SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
//SessionFactory因为每个操作都有用到它，所以拿到外面来。
private static Session session;
@BeforeClass
public static void setUpBeforeClass() throws Exception {
session=sessionFactory.openSession(); // 生成一个session
session.beginTransaction(); // 开启事务
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
session.getTransaction().commit(); // 提交事务
session.close(); // 关闭session
//sessionFactory.close(); // 关闭session工厂
}
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void testSaveClassAndStudent() {//写测试的具体内容
Student s=new Student();
s.setName("朱九");
session.save(s);
}
}
出现这样的原因是因为我用的是Hibernate02项目。
（3）级联的保存更新
hibernate中对象有很多种状态：
如果是new的一个对象，那么这个对象叫临时对象，
当对它进行save保存的时候，此时的它的状态便是持久化对象。
当如果一个对象没有被save时，编译器就会报错：
org.hibernate.TransientObjectException:objext refrences an unsaved transient instance – save the transient instance before flushing……
对象引用了一个未被保存的临时对象（损态实例）。
解决方式：
在<many-to-one>这端，cascade 默认是”none”。
假如我们希望（不用save()方法）在持久化多的一端的时候，也能自动级联保存和更新，我们可以把 cascade 设置成”save-update”；
