Hibernate框架中如何将多对多映射转化为多对一映射

转载 2012年03月27日 09:29:42

原文网址:http://blog.csdn.net/lian47810925/article/details/5379821

在hibernate映射中,多对多映射是最麻烦,最复杂的映射,通常情况下我们都将其转化为多对一映射来提高效率。

      本文以老师与课程的对应关系(一个老师可以交多门课程,一门课程可以由多个老师任教)为案例讨论转化的实现:重点考虑其映射文件的配置。

      显然以上关系,通过一个中间表(teacher_course),我们可以将其简化成两个多对一得关系:

      teacher_course 与teacher 多对一;

      teacher_course 与course 多对一;

      建立Teacher.java 文件

package cn.csu.domain;

/**
 * @file Teacher.java
 * @version 1.0
 * @since Mar 14, 2010
 */
public class Teacher {
	private int id;
	private String teacherName;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTeacherName() {
		return teacherName;
	}
	public void setTeacherName(String teacherName) {
		this.teacherName = teacherName;
	}
	
}

Teacher.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="cn.csu.domain">
    <class name="Teacher">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="teacherName" column="teacher_name"/>          
    </class>
</hibernate-mapping>


建立Course.java文件

package cn.csu.domain;

/**
 * @file Course.java
 * @version 1.0
 * @since Mar 14, 2010
 */
public class Course {
 private int id;
 private String courseName;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getCourseName() {
  return courseName;
 }
 public void setCourseName(String courseName) {
  this.courseName = courseName;
 }
 
}


相应Course.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="cn.csu.domain">
    <class name="Course">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="courseName" column="course_name"/>          
    </class>
</hibernate-mapping>


 

接下来建立一个中间类,取代多对多映射

建立TeacherCourse.java 文件

package cn.csu.domain;

/**中间类
 * @file TeacherCourse.java
 * @version 1.0
 * @since Mar 14, 2010
 */
public class TeacherCourse {
	private int id;
	private Teacher teacher;
	private Course	course;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public Teacher getTeacher() {
		return teacher;
	}
	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}
	public Course getCourse() {
		return course;
	}
	public void setCourse(Course course) {
		this.course = course;
	}
}


相应TeacherCourse.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="cn.csu.domain">
    <class name="TeacherCourse" table="teacher_course">
        <id name="id">
            <generator class="native"/>
        </id>
        <many-to-one name="teacher" column="teacher_id" class="Teacher"/>
        <many-to-one name="course" column="course_id" class="Course"/>       
    </class>
</hibernate-mapping>


 

至此,三者之间的映射关系就建立完成。

可用如下测试类,测试:

建立Many2Many.java文件

package cn.csu.test;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import cn.csu.domain.Course;
import cn.csu.domain.Teacher;
import cn.csu.domain.TeacherCourse;
import cn.csu.util.HibernateUtil;

/**多对多关系转化成三个表进行关系映射
 * @file Many2Many.java
 * @version 1.0
 * @since Mar 14, 2010
 */
public class Many2Many {

	public static void main(String[] args) {
		create();
		get();
	}
	
	//多对多关系的插入
	static void create(){
		Session s=null;
		Transaction tx=null;
		try{			
			s=HibernateUtil.getSession();
			tx=s.beginTransaction();
			
			Teacher t1=new Teacher();
			t1.setTeacherName("t1");
			
			Teacher t2=new Teacher();
			t2.setTeacherName("t2");

			Course c1=new Course();
			c1.setCourseName("c1");
			
			Course	c2=new Course();
			c2.setCourseName("c2");
			
			TeacherCourse tc1=new TeacherCourse();
			tc1.setTeacher(t1);
			tc1.setCourse(c1);
			
			TeacherCourse tc2=new TeacherCourse();
			tc2.setTeacher(t1);
			tc2.setCourse(c2);
			
			TeacherCourse tc3=new TeacherCourse();
			tc3.setTeacher(t2);
			tc3.setCourse(c1);
			
			TeacherCourse tc4=new TeacherCourse();
			tc4.setTeacher(t2);
			tc4.setCourse(c2);
			
			s.save(t1);
			s.save(t2);
			s.save(c1);
			s.save(c2);
			
			s.save(tc1);
			s.save(tc2);
			s.save(tc3);
			tx.commit();			
			System.out.println("operate succeed!!!");
		}catch(Exception e){
			e.printStackTrace();
			if(tx!=null){
				tx.rollback();
			}
		}finally{
			if(s!=null){
				s.close();
			}
		}
	}
	
	//多对多关系的查询,
	static void get(){ 
		Session s=null;
		try{
			s=HibernateUtil.getSession();
			//先查出对应姓名的老师的id号
			String hql1="from Teacher where teacherName=:teacherName";
			Query query1=s.createQuery(hql1);
			query1.setString("teacherName", "t1");
			List<Teacher> list1=query1.list();
			Teacher teacher=list1.get(0);
			
			System.out.println("Teacher id:"+teacher.getId());			
			
			//以该id号查出中间表中相应课程号,从而获得课程名
			String hql2="from TeacherCourse where teacher=:teacher";
			Query query2=s.createQuery(hql2);
			query2.setEntity("teacher", teacher);			
			List<TeacherCourse> list2=query2.list();
			for(TeacherCourse m:list2){
				System.out.println("courseName="+
                                                    m.getCourse().getCourseName());
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			if(s!=null){
				s.close();
			}
		}
	}
}


 


 

Hibernate框架中如何将多对多映射转化为多对一映射

在hibernate映射中,多对多映射是最麻烦,最复杂的映射,通常情况下我们都将其转化为多对一映射来提高效率。       本文以老师与课程的对应关系(一个老师可以交多门课程,一门课程可以由多个...
  • u013161278
  • u013161278
  • 2014年11月25日 17:54
  • 261

SSH框架之Hibernate的关联映射之一对多、多对一映射

关联映射之一对多、多对一映射 一、需求: 部门与员工 一个部门有多个员工 【一对多】 多个员工,属于一个部门 【多对一】 二、逻辑分析: 三、代码实现 1、javabean及映射文件的配...
  • qq_34944851
  • qq_34944851
  • 2016年12月19日 11:37
  • 1829

Hibernate多对多关系映射

多对多关系并不是两张表的关系,而是三张表的关系,而且要求必须有一个中间表,中间表必须只有两个字段,必须为复合主键,必须包含外键。 如果以上条件都满足,MyEclipse在三张表一起选择时,就可以生成...
  • u013189665
  • u013189665
  • 2014年03月20日 13:08
  • 1690

【Hibernate步步为营】--多对多映射详解

上篇文章详细讨论了一对多映射,在一对多映射中单向的关联映射会有很多问题,所以不建议使用如果非要采用一对多的映射的话可以考虑使用双向关联来优化之间的关系,一对多的映射其实质上是在一的一端使用标签来标明它...
  • zhang_xinxiu
  • zhang_xinxiu
  • 2014年05月27日 10:10
  • 4561

hibernate自身一对多和自身多对多映射详解

有时候我们使用对象时可能涉及到自身关联,但部分操作和普通对象映射无异,但是还是有些细微的差异,这里我们来探讨一下详细解释都在代码中: 自身一对一关联,这里采用上下级部门映射: Departme...
  • do_bset_yourself
  • do_bset_yourself
  • 2016年04月09日 16:58
  • 1179

Hibernate一对多关联映射(注解)

Hibernate一对多关联映射,维护端(一方,无外键方)可以进行关联移除,级联删除,级联保存,级联更新,级联刷新。被维护端(多方,外键方),不可以进行关联移除,级联操作,只能级联刷新。   ...
  • hardworking0323
  • hardworking0323
  • 2016年04月10日 18:35
  • 2736

hibernate中多对多映射配置详细解析

本工程以项目与开发人员构成多对多的关系来展开,构建多对多的关系,具体实现代码如下所示: 1.hibernate.cfg.xml文件 ...
  • miachen520
  • miachen520
  • 2016年08月10日 22:15
  • 1919

【SSH进阶之路】Hibernate映射——多对一单向关联映射(四)

基本映射是对一个实体进行映射,关联映射就是处理多个实体之间的关系,将关联关系映射到数据库中,所谓的关联关系在对象模型中有一个或多个引用。...
  • jiuqiyuliang
  • jiuqiyuliang
  • 2014年10月22日 08:15
  • 31132

【SSH进阶之路】Hibernate映射——多对多关联映射(八)

多对多映射是现实生活中最常见的映射,也是最容易理解的映射。废话少说,直接开始。   映射原理        不论是单向关联还是双向关联都是通过第三张表,将两个表中的主键放到第三张做一个关联。用第三张表...
  • jiuqiyuliang
  • jiuqiyuliang
  • 2014年11月22日 08:14
  • 14877

(经典)Hibernate多对多关系映射(五)

多对多关系是产生在三张表的关系中的,必须有一张中间表,必须保证中间表只有两个字段,必须是复合主键,必须是另两张表的外键。 如果按照多对多关系来设计类,例如:学生选课 这里只创建学生和课程类,中间表...
  • u014078192
  • u014078192
  • 2014年05月06日 13:45
  • 1362
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Hibernate框架中如何将多对多映射转化为多对一映射
举报原因:
原因补充:

(最多只允许输入30个字)