`
tianhei
  • 浏览: 210397 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Hibernate 关联映射之多对多

阅读更多

Hibernate的关联映射包括:

一对一(Persion - IDCard)

一对多(Department - Employee)

多对一(Employee - Department)

多对多(Teacher - Student)

组件映射(User - Name)

集合映射(Set、List、Map)

inverse和cascade(Employee - Department)

 

本文以多对多为例:

多个老师对应多个学生(Teacher- Student)

在操作和性能方面都不太理想,所以多对多的映射使用较少,实际使用中最好转换成一对多。Hibernate会为我们创建中间关联表,转换成两个一对多。

<set  name="teacher"  table="teacher_student">

    <key  column="teacher_id"/>

    <many-to-many  class="student"  column="student_id"/>

</set>

这样老师跟中间表是一对多关系、学生跟中间表也是一对多关系。

 

实体类:Teacher.java 和 Student.java

package com.cos.entity;
import java.util.Set;

public class Teacher {
	private int id;
	private String name;
	private Set<Student> student;//一对多
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Student> getStudent() {
		return student;
	}
	public void setStudent(Set<Student> student) {
		this.student = student;
	}
}

/////////////////////////////////////////////////////////////////////////////////
package com.cos.entity;
import java.util.Set;

public class Student {
	private int id;
	private String name;
	private Set<Teacher> teacher;//一对多
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Teacher> getTeacher() {
		return teacher;
	}
	public void setTeacher(Set<Teacher> teacher) {
		this.teacher = teacher;
	}
}

  映射文件:Teacher.hbm.xml 和 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>
	<class name="com.cos.entity.Teacher" lazy="true">
		<id name="id">
			<generator class="native"/>
		</id>	
		<property name="name"/>
		<set name="student" table="teacher_student">
			<key column="teacher_id"></key>
			<many-to-many class="com.cos.entity.Student" column="student_id"/>
		</set>
	</class>
</hibernate-mapping>

<!-- /////////////////////////////////////////////  -->
<?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>
	<class name="com.cos.entity.Student" lazy="true">
		<id name="id">
			<generator class="native"/>
		</id>	
		<property name="name"/>
		<set name="teacher" table="teacher_student">
			<key column="student_id"></key>
			<many-to-many class="com.cos.entity.Teacher" column="teacher_id"/>
		</set>
	</class>
</hibernate-mapping>

 

Hibernate配置文件:hibernate.cfg.xml

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///hi</property>
        <property name="hibernate.connection.username"></property>
        <property name="hibernate.connection.password"></property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.hbm2ddl.auto">create</property>
        <property name="show_sql">true</property>
		<mapping resource="com/cos/entity/Teacher.hbm.xml"/>
		<mapping resource="com/cos/entity/Student.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

 

工具类:HibernateUtil.java

package com.cos.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public final class HibernateUtil {

	private static SessionFactory sesseionFactory;

	static {
		Configuration conf = new Configuration();
		conf.configure();
		sesseionFactory = conf.buildSessionFactory();
	}

	public static SessionFactory getSesseionFactory() {
		return sesseionFactory;
	}
}

 

测试类:Many2Many.java

package com.cos.main;

import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.cos.entity.Student;
import com.cos.entity.Teacher;
import com.cos.util.HibernateUtil;

public class Many2Many {

	public static void main(String[] args) {
		add();
	}
	public static void add(){
		SessionFactory  sessionFactory = null;
		Session s = null;
		Transaction t = null;
		try{
			Set<Teacher> teacher = new HashSet<Teacher>();
			Teacher t1 = new Teacher();
			t1.setName("teacher 1");
			teacher.add(t1);
			
			Teacher t2 = new Teacher();
			t2.setName("teacher 2");
			teacher.add(t2);
			
			Set<Student> student = new HashSet<Student>();
			Student s1 = new Student();
			s1.setName("student 1");
			student.add(s1);
			
			Student s2 = new Student();
			s2.setName("student 2");
			student.add(s2);
			
//			t1.setStudent(student);
//			t2.setStudent(student);
			
			//和上面的两行代码二者有一即可
			s1.setTeacher(teacher);
			s2.setTeacher(teacher);
			
			sessionFactory = HibernateUtil.getSesseionFactory();
			s = sessionFactory.openSession();
			t = s.beginTransaction();
			s.save(t1);
			s.save(t2);
			s.save(s1);
			s.save(s2);
			t.commit();
			s.close();
			sessionFactory.close();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

 

表结构:

CREATE TABLE `teacher` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(255) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=latin1

CREATE TABLE `student` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(255) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=latin1

CREATE TABLE `teacher_student` (
  `teacher_id` int(11) NOT NULL,
  `student_id` int(11) NOT NULL,
  PRIMARY KEY  (`student_id`,`teacher_id`),
  KEY `FK2E2EF2DEE60D3423` (`teacher_id`),
  KEY `FK2E2EF2DED571E983` (`student_id`),
  CONSTRAINT `FK2E2EF2DED571E983` FOREIGN KEY (`student_id`) REFERENCES `student` (`id`),
  CONSTRAINT `FK2E2EF2DEE60D3423` FOREIGN KEY (`teacher_id`) REFERENCES `teacher` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

 

 

 

 

分享到:
评论

相关推荐

    hibernate关联映射详解

    hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,包含4个说明文档,分别详细解说了hibernate关联映射的...

    hibernate多对多关联映射

    总之,Hibernate的多对多关联映射是解决复杂关系数据库设计的关键技术之一。通过合理的配置和使用,开发者可以轻松管理实体之间的多对多关系,提高开发效率。理解并熟练掌握这部分知识对于提升Java企业级应用开发...

    hibernate关联映射实例

    本文将深入探讨“hibernate关联映射实例”中的关键知识点,包括一对多、多对多和继承映射,这些都是Hibernate中至关重要的概念。 1. **一对多关联映射**: 在现实世界中,一个实体可能会与多个其他实体相关联,...

    hibernate关联映射的作用和常用属性解释

    ### Hibernate关联映射的作用与常用属性详解 #### 关联映射概述 在对象关系映射(Object Relational Mapping,简称ORM)技术中,Hibernate作为Java领域内非常成熟且功能强大的框架之一,它允许开发者将Java类映射...

    Hibernate关联映射

    9. Hibernate 一对一外键双向关联、主键双向关联、连接表双向关联、一对多外键双向关联、一对多连接表双向关联、多对多双向关联: 这些关联方式与单向关联类似,区别在于两个实体类都知道彼此的关联。在双向关联中...

    hibernate关联映射详解SSH 多对多,一对多关系对象映射

    总之,Hibernate的关联映射是其强大之处,能够帮助开发者轻松处理复杂的数据库关系。SSH框架结合了MVC设计模式、依赖注入和持久化管理,为Java Web开发提供了一套完整的解决方案。通过深入学习和实践,我们可以更好...

    hibernate多对多关联映射(单项关联)

    在Java的持久化框架Hibernate中,多对多关联映射是一种常见的关系模型,它用于处理两个实体类之间存在多个对应关系的情况。这篇博客"hibernate多对多关联映射(单项关联)"深入探讨了如何在Hibernate中实现这种映射...

    Hibernate一对一主键关联映射(双向关联)

    在Java的持久化框架Hibernate中,一对一(One-to-One)关联映射是一种常见的关系数据库模型映射方式。这种关联通常发生在两个实体之间,且每个实体都只有一个对应的实例。本篇文章将详细探讨双向一对一主键关联映射...

    Hibernate关联映射.rar

    本教程“Hibernate关联映射.rar”聚焦于Hibernate中的关联映射,特别是多对一和一对多的关系映射,非常适合初学者了解和实践。 首先,我们要理解什么是关联映射。在数据库中,表与表之间存在各种关系,如一对一、一...

    Hibernate集合映射与关联关系

    本主题将深入探讨Hibernate集合映射与关联关系,包括"student与Score的Map集合关系"、"student与class的多对一"以及"一对多映射"的概念。 首先,让我们理解一下Hibernate中的集合映射。在关系型数据库中,一个实体...

    hibernate 单向多对多关联映射练习

    本练习主要关注的是Hibernate中的单向多对多关联映射,这是一种常见的关系数据库设计模式,用于表示两个实体间复杂的关系。 在多对多关联中,两个实体类可以相互拥有多个实例,但只在一个方向上建立关联。例如,...

    Hibernate 关联关系映射分类

    在深入探讨Hibernate关联关系映射分类之前,我们首先简要回顾一下Hibernate框架的基本概念。Hibernate是一种持久层框架,主要用于Java应用程序中的对象关系映射(ORM),它能够将面向对象的数据模型转换为数据库中的...

    hibernate 双向多对多关联映射练习

    在Java的持久化框架Hibernate中,双向多对多关联映射是一种常见的数据关系模型,它允许两个实体类之间存在多个实例互相引用的情况。本练习旨在帮助开发者深入理解并熟练运用这种映射方式。通过以下详细讲解,我们将...

    hibernate 全面学习->hibernate 关联映射学习

    总的来说,这个压缩包提供了丰富的Hibernate关联映射的学习资源,涵盖了从基础到进阶的各种关联类型。通过学习这些示例,你将能够熟练掌握如何在Java项目中使用Hibernate进行数据持久化,并灵活地处理各种数据库关系...

    hibernate双向多对多关联映射(注解版)

    在这个“hibernate双向多对多关联映射(注解版)”的主题中,我们将深入探讨如何使用Hibernate的注解配置来处理数据库中的双向多对多关联关系。 首先,多对多关联在数据库设计中是指两个实体之间存在多个对应关系,...

    Hibernate双向一对一关联映射(注解版)

    本主题聚焦于“Hibernate双向一对一关联映射”的注解实现,这是一种高级的数据库设计模式,用于处理两个实体之间一对一的关系。 在Hibernate中,一对一关联映射分为单向和双向。单向一对一映射通常涉及一个实体持有...

    Hibernate映射一对多关联关系

    ### Hibernate映射一对多关联关系 #### 知识点概览 - **概念解析**:一对多(One-to-Many)关联关系的概念及其在Hibernate中的实现方式。 - **域模型设计**:创建具有一个实体与多个实体关联的域模型。 - **关系...

Global site tag (gtag.js) - Google Analytics