Hibernate 关系映射案例（一对一关系，一对多关系，多对多关系）

Hibernate 关系映射案例（一对一关系，一对多关系，多对多关系）

本案例使用的hibernate版本为  hibernate-release-5.2.10.Final 

为了测试，本案例在mysql数据库中创建了一个db数据库。本案例为了能够将三种关系表达清楚，特地模拟了一个一学生的教务管理系统的一部分，学生登录教务系统需要账号，密码信息，所以在本人把账号，密码信息保存在一张account（账号）表里；在教务系统还存储学生学生的所有的个人信息如：姓名，出生年月，头像，个人简介等信息，这些信息我单独存放在student（学生）表中；教务系统还存储班级信息，我使用了一张数据表classes(班级)表来存储班级名称信息；教务系统还应该有课程，课程的名称，开课时间，结课时间等信息存储在了course（课程）表中。

现在我们看看各个表之间的关系：一个学生只对应一个账号信息，一个账号也只能对应一个学生，所以学生表和账号表属于一对一关系；一个学生只能属于一个班级，但一个班级可以有多名学生，所有班级和学生属于一对多关系；一个学生可以选择多门课程，一门课程可以有多名学生选择，所以学生和课程属于多对多关系；

我们把数据表对应成一个类，下面是类之间的关系图：

下面是简单的数据表的关系图（每张表设置了h_为前缀）：

注：多对多关系需要借助第三张表来完成。

创建一个java项目：项目的结构如下：（lib文件夹用于存放jar包）

lib目录下则是hibernate5需要的jar包（注需要将jar加载到项目中：选中jar包右键 --》BuildPath--》Add to Build Path）

log4j.properties为日志配置文件（需要加载配置junit），此项目可以不需要日志，使用日志只是为了观察方便。
注：junit配置可以参考 http://blog.csdn.net/benxiaohai888/article/details/78231911

由于在主配置文件配置了字段创建数据表的配置，所以第一次加载时就会自动创建数据表

配置的代码：

<!-- 自动生成数据表（数据表的生成方式） -->
<property name="hbm2ddl.auto">update</property>

接下来是示例代码：

1、主配置文件 hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!--配置一：数据库连接信息 --><!-- 数据库驱动 --><property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property><!-- 数据库URL --><property name="hibernate.connection.url">jdbc:mysql://localhost:3306/db?characterEncoding=utf8</property><!--数据库用户名， --><property name="hibernate.connection.username">root</property><!--数据库密码 --><property name="hibernate.connection.password"></property><!--配置二:数据库方言配置，配置数据库方言的作用是屏蔽数据库的差异，换句话说是使hibernate框架知道 要与哪种数据库取得联系 --><property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property><!--配置三：其它配置 （这些配置可选） --><!-- 是否在控制台显示sql语句 --><property name="hibernate.show_sql">true</property><!--是否格式化删除sql语句 --><property name="hibernate.format_sql">true</property><!-- 自动生成数据表（数据表的生成方式） --><property name="hbm2ddl.auto">update</property><!-- 将session绑定到当前线程 --><property name="hibernate.current_session_context_class">thread</property><!-- 设置事务的隔离级别 --><property name="hibernate.connection.isolation">4</property><!-- 配置四：映射配置 --><mapping resource="cn/sz/entity/Account.hbm.xml" /><mapping resource="cn/sz/entity/Classes.hbm.xml" /><mapping resource="cn/sz/entity/Course.hbm.xml" /><mapping resource="cn/sz/entity/Student.hbm.xml" /><!-- 基于注解的配置方式 --><!-- <mapping class="cn.sz.entity.Dept" /> --></session-factory></hibernate-configuration>

2、工具类（获取Session）HibernateUtil.java

package cn.sz.utils;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration;public class HibernateUtil {public static Session getSession() {Session session = null;// 创建一个读取主配置文件的对象Configuration cfg = new Configuration();// 读取主配置文件// cfg.configure("hibernate.cfg.xml");如果读取的主配置文件时默认的名字则可以省略参数cfg.configure();// 创建SessionFactorySessionFactory factory = cfg.buildSessionFactory();// 打开session// 我们在主配置中已经将session绑定到线程中，所以可以从线程中取出session// 不从线程中取出session，则可以使用 factory.openSession(); 方式获得sessionsession = factory.getCurrentSession();return session;}}

3、日志文件 log4j.properties

log4j.rootLogger=DEBUG,console,FILElog4j.appender.console=org.apache.log4j.ConsoleAppenderlog4j.appender.console.threshold=INFOlog4j.appender.console.layout=org.apache.log4j.PatternLayoutlog4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%nlog4j.appender.FILE=org.apache.log4j.RollingFileAppenderlog4j.appender.FILE.maxBackupIndex=100##log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender log4j.appender.FILE.Append=truelog4j.appender.FILE.File=c:/error1.loglog4j.appender.FILE.Threshold=INFOlog4j.appender.FILE.layout=org.apache.log4j.PatternLayoutlog4j.appender.FILE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%nlog4j.appender.FILE.MaxFileSize=1MB

4、实体类Account.java

package cn.sz.entity;import java.io.Serializable;public class Account implements Serializable {// 学生账号编号id（主属性）private Integer aid;// 学生登录账号名private String aname;// 密码private String password;// 对应另一个一的一方（Student）,一个学生对应一个账号，一个账号只对应一个学生（学生和账号属于一对一关系）private Student student;public Account() {}public Student getStudent() {return student;}public void setStudent(Student student) {this.student = student;}public Integer getAid() {return aid;}public void setAid(Integer aid) {this.aid = aid;}public String getAname() {return aname;}public void setAname(String aname) {this.aname = aname;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}}

5、实体类Account映射文件 Account.hbm.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><!-- package为实体类所在的包 --><hibernate-mapping package="cn.sz.entity"><!-- 实体类和哪个表对应 ;table用于配置实体类和表的对应；name用于配置哪个实体类和表对应 ；catalob:使用哪个数据库 --><class table="h_account" name="Account" catalog="db"><!-- id用于配置主属性和主键字段对应；id的name用于配置属性名 ，column为对应字段名 ;省略column则默认属性和字段名一致 --><!-- 基于外键时用此 （一对一关系） --><id name="aid" column="aid"><!-- 主键生成策略 --><generator class="native"></generator></id><!-- 共享主键用此 （一对一关系） --><!-- <id name="stuid"> <generator class="foreign"> <param name="property">user</param> </generator> </id> --><!-- property用于配置普通属性和字段的对应 ，type用于设置字段的类型，值的选择可以选hibernate类型，也可以选择Java类型; type可以省略，在省略的情况下hibernate自适应 ；length:设置长度 --><property name="aname" type="string" length="30"></property><property name="password" type="string" length="30"></property><!-- 配置一对一的关系，基于外键的方式 --><many-to-one name="student" class="Student" column="stuid"unique="true"></many-to-one><!-- 共享主键 （一对一关系） --><!-- <one-to-one name="user" class="User" constrained="true"></one-to-one> --></class></hibernate-mapping>

6、实体类Classes.java

package cn.sz.entity;import java.io.Serializable;import java.util.Set;public class Classes implements Serializable {// 班级编号id（主属性）private Integer classid;// 班级名称private String classname;// 对应学生一方,一个班级可以有多个学生，但一个学生只能属于一个班级（班级和学生属于一对多关系）private Set<Student> students;public Classes() {}public Set<Student> getStudents() {return students;}public void setStudents(Set<Student> students) {this.students = students;}public Integer getClassid() {return classid;}public void setClassid(Integer classid) {this.classid = classid;}public String getClassname() {return classname;}public void setClassname(String classname) {this.classname = classname;}}

7、实体类Classes映射文件Classes.hbm.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><!-- package为实体类所在的包 --><hibernate-mapping package="cn.sz.entity"><!-- 实体类和哪个表对应 ;table用于配置实体类和表的对应；name用于配置哪个实体类和表对应 --><class table="h_classes" name="Classes" catalog="db"><!-- id用于配置主属性和主键字段对应；id的name用于配置属性名 ，column为对应字段名 --><id name="classid" column="classid"><!-- 主键生成策略 --><generator class="native"></generator></id><!-- property用于配置普通属性和字段的对应 --><property name="classname" type="string" length="30"></property><!--配置set实现对应多的一方（一对多关系），学生和班级属于一对多关系，一个班级有多名学生，但一个学生只能属于一个班 --><set name="students" cascade="delete"><key column="classid"></key><one-to-many class="Student"></one-to-many></set></class></hibernate-mapping>

8、实体类Course.java

package cn.sz.entity;import java.io.Serializable;import java.util.Date;import java.util.Set;public class Course implements Serializable {// 课程编号id（主属性）private Integer cid;// 课程名称private String cname;// 开课日期private Date starttime;// 结课日期private Date endtime;// 对应学生一方，一门课程可以有多个学生选择，一个学生也可以学生多门课程（学生和课程属于多对多关系）private Set<Student> students;public Course() {}public Set<Student> getStudents() {return students;}public void setStudents(Set<Student> students) {this.students = students;}public Integer getCid() {return cid;}public void setCid(Integer cid) {this.cid = cid;}public String getCname() {return cname;}public void setCname(String cname) {this.cname = cname;}public Date getStarttime() {return starttime;}public void setStarttime(Date starttime) {this.starttime = starttime;}public Date getEndtime() {return endtime;}public void setEndtime(Date endtime) {this.endtime = endtime;}}

8、实体类Course映射文件 Course.hbm.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><!-- package为实体类所在的包 --><hibernate-mapping package="cn.sz.entity"><!-- 实体类和哪个表对应 ;table用于配置实体类和表的对应；name用于配置哪个实体类和表对应 --><class table="h_course" name="Course" catalog="db"><!-- id用于配置主属性和主键字段对应；id的name用于配置属性名 ，column为对应字段名 --><id name="cid" column="cid"><!-- 主键生成策略 --><generator class="native"></generator></id><!-- property用于配置普通属性和字段的对应 --><property name="cname" type="string" length="30"></property><property name="starttime" type="date"></property><property name="endtime" type="date"></property><!--对应students的集合属性 （多对多关系） 课程和学生属于多对多关系，一个学生可以学生多门课程，一门课程也可以有多个学生选择 --><set name="students" table="h_course_student"><!-- 用于配制本表在外键表中的外键 --><key column="cid"></key><!-- class配置对应的外类，column配置在第三方表中外类的外键 --><many-to-many class="Student" column="stuid"></many-to-many></set></class></hibernate-mapping>

9、实体类Student.java

package cn.sz.entity;import java.io.Serializable;import java.util.Date;import java.util.Set;public class Student implements Serializable {// 学生编号id（主属性）private Integer stuid;// 学生姓名private String stuname;// 生日private Date birthday;// 头像（这里为了演示映射配置文件可以使用byte[] 类型存储）private byte[] photo;// 个人说明private String content;// 对应一的一方（所属班级），一个班级可以有多个学生，但一个学生只能属于一个班级（班级和学生属于一对多关系）private Classes classes;// 对应另一个一的一方（Account），一个学生对应一个账号，一个账号只对应一个学生（学生和账号属于一对一关系）private Account account;// 对应课程，一方一门课程可以有多个学生选择，一个学生也可以学生多门课程（学生和课程属于多对多关系）private Set<Course> courses;public Student() {}public Classes getClasses() {return classes;}public void setClasses(Classes classes) {this.classes = classes;}public Set<Course> getCourses() {return courses;}public void setCourses(Set<Course> courses) {this.courses = courses;}public Account getAccount() {return account;}public void setAccount(Account account) {this.account = account;}public Integer getStuid() {return stuid;}public void setStuid(Integer stuid) {this.stuid = stuid;}public String getStuname() {return stuname;}public void setStuname(String stuname) {this.stuname = stuname;}public Date getBirthday() {return birthday;}public void setBirthday(Date birthday) {this.birthday = birthday;}public byte[] getPhoto() {return photo;}public void setPhoto(byte[] photo) {this.photo = photo;}public String getContent() {return content;}public void setContent(String content) {this.content = content;}}

10、实体类Student映射文件 Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><!-- package为实体类所在的包 --><hibernate-mapping package="cn.sz.entity"><!-- 实体类和哪个表对应 ;table用于配置实体类和表的对应；name用于配置哪个实体类和表对应 --><class table="h_student" name="Student" catalog="db"><!-- id用于配置主属性和主键字段对应；id的name用于配置属性名 ，column为对应字段名 --><id name="stuid" column="stuid"><!-- 主键生成策略 --><generator class="native"></generator></id><!-- property用于配置普通属性和字段的对应 --><property name="stuname" type="string" length="30"></property><property name="birthday" type="date"></property><property name="photo" type="byte[]" length="1024000"></property><property name="content" type="text" length="10000"></property><!-- 配置一对一关系，基于外键的方式 （学生和账号一对一关系） --><one-to-one name="account" class="Account" property-ref="student"cascade="delete"></one-to-one><!--对应courses的集合属性（多对多关系） 课程和学生属于多对多关系，一个学生可以学生多门课程，一门课程也可以有多个学生选择 --><set name="courses" table="h_course_student"><!-- 用于配置本表在外键表的外键 --><key column="stuid"></key><!-- class配置对应的外类，column配置在第三方表中外类的外键 --><many-to-many class="Course" column="cid"></many-to-many></set><!--配置一对多关系，学生和班级属于一对多关系，一个班级有多名学生，但一个学生只能属于一个班 --><many-to-one name="classes" class="Classes" column="classid"></many-to-one><!-- 共享主键的方案 --><!-- <one-to-one name="code" class="Code"></one-to-one> --></class></hibernate-mapping>

测试类：

11、TestStudentOrAccount.java (测试Student和Account 一对一关系)

package cn.sz.test;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.util.Date;import org.hibernate.Session;import org.junit.Test;import cn.sz.entity.Account;import cn.sz.entity.Student;import cn.sz.utils.HibernateUtil;public class TestStudentOrAccount {@Test// 演示Student和Account一对一关系添加方法public void testSave() throws IOException {Session session = HibernateUtil.getSession();session.beginTransaction();// 创建一个账号Account account = new Account();account.setAname("zs123");account.setPassword("123");// 创建一个学生（张三）Student stu1 = new Student();stu1.setStuname("张三");stu1.setBirthday(new Date());stu1.setContent("张三的个人描述。。。");// 获取桌面的一张演示图片，将图片转换为字节数组存储到数据库(利用字节输入流读取并将字节数组保存到数据库)InputStream is = new FileInputStream(new File("C:\\Users\\Administrator\\Desktop\\test.jpg"));byte[] photo = new byte[is.available()];is.read(photo);stu1.setPhoto(photo);// 将账号与学生建立联系，此账号属于只属于这个学生account.setStudent(stu1);// 保存到数据库中session.save(account);session.save(stu1);session.getTransaction().commit();is.close();session.close();}@Test// 演示Student和Account一对一关系删除方法public void testDelete() {Session session = HibernateUtil.getSession();session.beginTransaction();// 获取学生编号为1学生Student student = session.get(Student.class, 1);// 删除该学生（发现student表(主表)学生的该学生的信息被删除，account表（从表）的对应概述的信息也被删除，因为我们在映射文件中配置当主表数据删除时从表和它关联的数据也跟着删除（cascade="delete"）session.delete(student);// 发现当我们删除从表的数据时主表的对应的学生信息并不会删除// Account account = session.get(Account.class, 1);// session.delete(account);session.getTransaction().commit();session.close();}@Test// 演示Student和Account一对一关系查询方法public void testQuery() throws IOException {Session session = HibernateUtil.getSession();session.beginTransaction();// 根据学生编号获取学生信息和学生登录账号Student student = session.get(Student.class, 1);System.out.println("学生姓名： " + student.getStuname());// 将图片字节写出到桌面byte[] photo = student.getPhoto();OutputStream os = new FileOutputStream(new File("C:\\Users\\Administrator\\Desktop\\test1.jpg"));os.write(photo);Account account = student.getAccount();System.out.println("学生登录账号：" + account.getAname());System.out.println("------------------------");// 根据账号表的账号编号获取学生信息学生登录账号Account account2 = session.get(Account.class, 1);Student student2 = account2.getStudent();System.out.println("学生姓名： " + student2.getStuname());System.out.println("学生登录账号：" + account2.getAname());session.getTransaction().commit();os.close();session.close();}}

12、TestStudentOrClasses.java (测试Classes和Student 一对多关系)

package cn.sz.test;import java.util.HashSet;import java.util.Set;import org.hibernate.Session;import org.junit.Test;import cn.sz.entity.Classes;import cn.sz.entity.Student;import cn.sz.utils.HibernateUtil;public class TestStudentOrClasses {@Test// 演示Classes和Student一对多添加方法public void testSave() {Session session = HibernateUtil.getSession();session.beginTransaction();// 创建一个班级 A班Classes classes = new Classes();classes.setClassname("A班");// 创建一个学生（小白）Student student = new Student();student.setStuname("小白");student.setClasses(classes);// 创建一个学生（小花）Student student2 = new Student();student2.setStuname("小花");student2.setClasses(classes);// 两个同学都在A班HashSet<Student> set = new HashSet<>();set.add(student);set.add(student2);// classes.setStudents(set);// 保存到数据库session.save(student);session.save(student2);session.save(classes);session.getTransaction().commit();session.close();}@Test// 演示Classes和Student一对多删除方法public void testDelete() {Session session = HibernateUtil.getSession();session.beginTransaction();// 删除班级编号为1// 的班级，将发现该班级下面的学生都删除了，因为我们在映射文件中配置当主表数据删除时从表和它关联的数据也跟着删除（cascade="delete"）Classes classes = session.get(Classes.class, 4);session.delete(classes);session.getTransaction().commit();session.close();}@Test// 演示Classes和Student一对多查询方法public void testQuery() {Session session = HibernateUtil.getSession();session.beginTransaction();// 查询班级编号为1的班级信息和有哪些学生Classes classes = session.get(Classes.class, 4);System.out.println("班级名称：" + classes.getClassname());Set<Student> students = classes.getStudents();System.out.println("班级的学生：");for (Student student : students) {System.out.println(student.getStuname());}session.getTransaction().commit();session.close();}}

13、TestStudentOrCourse.java (测试Student和Course 多对多关系)

package cn.sz.test;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;import java.util.Date;import java.util.HashSet;import java.util.Set;import org.hibernate.Session;import org.junit.Test;import cn.sz.entity.Account;import cn.sz.entity.Course;import cn.sz.entity.Student;import cn.sz.utils.HibernateUtil;public class TestStudentOrCourse {@Test// 演示Student和Course多对多关系添加方法public void testSave() throws IOException {Session session = HibernateUtil.getSession();session.beginTransaction();// 创建一个学生（李四）Student stu1 = new Student();stu1.setStuname("李四");stu1.setBirthday(new Date());stu1.setContent("李四的个人描述。。。");// 创建一个学生（王五）Student stu2 = new Student();stu2.setStuname("王五");stu2.setBirthday(new Date());stu2.setContent("王五的个人描述。。。");// 创建一个学生（赵六）Student stu3 = new Student();stu3.setStuname("赵六");stu3.setBirthday(new Date());stu3.setContent("王五的个人描述。。。");// 创建一门课程（java开发技术）Course course1 = new Course();course1.setCname("java开发技术");course1.setStarttime(new Date());course1.setEndtime(new Date());// 创建一门课程（php开发技术）Course course2 = new Course();course2.setCname("php开发技术");course2.setStarttime(new Date());course2.setEndtime(new Date());// 创建一门课程（c++开发技术）Course course3 = new Course();course3.setCname("c++开发技术");course3.setStarttime(new Date());course3.setEndtime(new Date());// 现在李四选择 java开发技术和php开发技术 两门课程HashSet<Course> set1 = new HashSet<>();set1.add(course1);set1.add(course2);stu1.setCourses(set1);// 现在王五选择 java开发技术和c++开发技术 两门课程HashSet<Course> set2 = new HashSet<>();set2.add(course1);set2.add(course3);stu2.setCourses(set2);// 现在赵六选择 java开发技术和php开发技术和c++开发技术 三门课程HashSet<Course> set3 = new HashSet<>();set3.add(course1);set3.add(course2);set3.add(course3);stu3.setCourses(set3);// 现在java开发技术有3人选择 ，php开发技术有2人选择， c++开发技术有2人选择// 保存到数据库中session.save(stu1);session.save(stu2);session.save(stu3);session.save(course1);session.save(course2);session.save(course3);session.getTransaction().commit();session.close();}@Test// 演示Student和Course多对多关系删除方法public void testDelete() {Session session = HibernateUtil.getSession();session.beginTransaction();// 获取学生编号为2学生(李四)Student student = session.get(Student.class, 2);// 删除该学生（发现student表该学生的信息被删除，h_course_student表该学生选择的课程也将该学生移除session.delete(student);// 获取kec编号为3 的课程，删除该课程后，h_course_student表该课程的对应信息也删除了Course Course = session.get(Course.class, 3);session.delete(Course);session.getTransaction().commit();session.close();}@Test// 演示Student和Course多对多关系查询方法public void testQuery() throws IOException {Session session = HibernateUtil.getSession();session.beginTransaction();// 根据学生编号获取学生信息和学生现在的课程（就是查看该学生选择了那些课程）Student student = session.get(Student.class, 4);System.out.println("学生姓名： " + student.getStuname());Set<Course> courses = student.getCourses();System.out.println("选择的课程：");for (Course course : courses) {System.out.println(course.getCname());}System.out.println("------------------------");// 根据课程表编号课程信息和选择该课程的学生信息（就是查看该课程有哪些学生选择）Course course = session.get(Course.class, 2);System.out.println("课程名称： " + course.getCname());Set<Student> students = course.getStudents();System.out.println("选择该课程的学生：");for (Student student2 : students) {System.out.println(student2.getStuname());}session.getTransaction().commit();session.close();}}

由于我们配置了字段生成数据表的配置，所以在第一次测试时，将创建数据表，数据表的结构如下（每张表设置了h_为前缀）：

总体预览：

班级（classes）表结构：

课程表和学生表生成的中间表（course_student）结构：

学生（student）表结构：

账号（account）表结构：

课程(course)表结构：

下面是测试的结果：

接下来我们先测试student(学生) 和 account（账号）一对一关系：

测试的类为：TestStudentOrAccount.java

1、执行方法 testSave() 添加方法

我们发现信息添加到了两张数据表之中，两张表也建立了联系，关联的字段 stuid,账号表的stuid对应学生表的stuid.

2、执行testQuery()查询方法

我们发现能够使用学生表为主来查询到两张表的信息，也能够使用账号表为主来查询到两张表的信息。

3、执行testDelete() 删除方法

我们发现当主表的数据删除从表的数据也跟着删除了（我们配置了casade="delete",当删除主表数据时，从表关联数据也跟着删除）

接下来我们先测试student(学生) 和 course（课程）多对多关系：

测试的类为：TestStudentOrCourse.java

1、执行方法 testSave() 添加方法

发现数据添加到数据表中，学生表和课程在第三张中建立联系，cid对应课程表的cid字段，stuid对应学生表的stuid字段。

2、执行testQuery()查询方法

能够根据学生查询出他选择的课程，也可以根据课程查看选择该课程的学生。

3、执行testDelete() 删除方法

删除学生表的数据，发现在第三张表的他关联的信息也被删除了，删除课程发现在第三张表他关联的数据也跟着删除了。

接下来我们先测试student(学生) 和 classes（班级）一对多关系：

测试的类为：TestStudentOrClasses.java

1、执行方法 testSave() 添加方法

添加数据，两张表建立了联系，学生表的classid对应班级表的classid

2、执行testQuery()查询方法

能够根据班级查询他的所有学生。

3、执行testDelete() 删除方法

删除班级后，在这个班级里面的学生也被删除了（在设置关联的时候设置了 cascade="delete"，主表数据删除，从表关联的数据也跟着删除）