Hibernate关联映射之多对多单/双向关联映射

实例1 单向映射

-----------此实例为多对多（Teacher——Student）单向关联映射，即老师教多个学生，但学生不知道自己被哪些个老师教------------

方法一：使用Annotation实现

（1）建立Teacher类和Student类

package com.model;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Teacher {
	private int id;
	private String name;
	private Set<Student> students = new HashSet<Student>();
	@Id
	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;
	}
	@ManyToMany
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
}

package com.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Student {
	private int id;
	private String name;
	@Id
	@GeneratedValue
	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;
	}
}

（2）设置Hibernate配置文件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="connection.driver_class">com.mysql.jdbc.Driver</property>
		<!-- 连接的数据库的url -->
		<property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
		<!-- 连接的数据库的用户名-->
		<property name="connection.username">root</property>
		<!-- 连接的数据库的密码 -->
		<property name="connection.password"></property>
		<!-- 配置Hibernate数据库方言 -->
		<property name="Dialect">org.hibernate.dialect.MySQLDialect</property>
		<!-- 输出执行的SQL语句 -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
		<!-- 启动时撤销并重新创建数据库的模式-->
		<property name="hbm2ddl.auto">create</property>
		
		<property name="current_session_context_class">thread</property>
		<mapping class="com.model.Teacher"/>
		<mapping class="com.model.Student"/>
	</session-factory>	
</hibernate-configuration>

（3）建立测试类，此处使用Junit4进行测试，仅仅测试一对一映射如何建表即可。

package com.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.Test;

public class ORMappingTest {

	@Test
	public void test() {
		Configuration cfg = new Configuration();
		cfg.configure();
		ServiceRegistry  sr = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry(); 
		SessionFactory  sf = cfg.buildSessionFactory(sr);
		Session s = sf.getCurrentSession();
		Transaction tx = s.beginTransaction();
		
		tx.commit();
		sf.close();
	}

}

（4）运行测试类，查看后台输出的建表SQL语句。

Hibernate: 
    create table Student (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
Hibernate: 
    create table Teacher (
        id integer not null,
        name varchar(255),
        primary key (id)
    )
Hibernate: 
    create table Teacher_Student (
        Teacher_id integer not null,
        students_id integer not null,
        primary key (Teacher_id, students_id)
    )
Hibernate: 
    alter table Teacher_Student 
        add index FK55FA429EFD4517CB (students_id), 
        add constraint FK55FA429EFD4517CB 
        foreign key (students_id) 
        references Student (id)
Hibernate: 
    alter table Teacher_Student 
        add index FK55FA429E43F43EE8 (Teacher_id), 
        add constraint FK55FA429E43F43EE8 
        foreign key (Teacher_id) 
        references Teacher (id)

------------从测试结果我们可以看到，系统自动生成中间表Teacher_Student，其外键字段为Teacher_id, students_id。自动生成的外键字段不太符合习惯标准，我们可以另外自己设置中间表表名和外键字段名。

例如：在Teacher类中设置

	@ManyToMany
	@JoinTable(name="t_s", 
		joinColumns={@JoinColumn(name="teacher_id")},
		inverseJoinColumns={@JoinColumn(name="student_id")}	
		)
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}

运行测试类，查看后台输出的建表SQL语句为：

Hibernate: 
    create table Student (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
Hibernate: 
    create table Teacher (
        id integer not null,
        name varchar(255),
        primary key (id)
    )
Hibernate: 
    create table t_s (
        teacher_id integer not null,
        student_id integer not null,
        primary key (teacher_id, student_id)
    )
Hibernate: 
    alter table t_s 
        add index FK1BF6843F43EE8 (teacher_id), 
        add constraint FK1BF6843F43EE8 
        foreign key (teacher_id) 
        references Teacher (id)
Hibernate: 
    alter table t_s 
        add index FK1BF683358F448 (student_id), 
        add constraint FK1BF683358F448 
        foreign key (student_id) 
        references Student (id)

 

方法二：使用映射文件hbm.xml实现：

（1）建立Teacher类和Student类，在方法一的基础上去掉@注解即可。

（2）建立映射文件Teacher.hbm.xml和Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.model">
    <class name="Teacher">
    		<id name="id">
    			<generator class="native"></generator>
    		</id>
            <property name="name" />  
            <set name="students" table="teacher_student">
            	<key column="teacher_id"></key>
            	<many-to-many class="Student" column="student_id"></many-to-many>
            </set> 
    </class>  
</hibernate-mapping>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.model">
    <class name="Student">
    		<id name="id">
    			<generator class="native"></generator>
    		</id>
            <property name="name" />  
    </class>  
</hibernate-mapping>

（3）设置Hibernate配置文件hibernate.cfg.cml的映射文件

	<mapping resource="com/model/Teacher.hbm.xml"/> 
	<mapping resource="com/model/Student.hbm.xml"/> 

（4）运行方法一的测试类，得到相同的测试结果：

Hibernate: 
    create table Student (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
Hibernate: 
    create table Teacher (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
Hibernate: 
    create table teacher_student (
        teacher_id integer not null,
        student_id integer not null,
        primary key (teacher_id, student_id)
    )
Hibernate: 
    alter table teacher_student 
        add index FK2E2EF2DE43F43EE8 (teacher_id), 
        add constraint FK2E2EF2DE43F43EE8 
        foreign key (teacher_id) 
        references Teacher (id)
Hibernate: 
    alter table teacher_student 
        add index FK2E2EF2DE3358F448 (student_id), 
        add constraint FK2E2EF2DE3358F448 
        foreign key (student_id) 
        references Student (id) 

 

实例2 双向映射

-----------此实例为多对多（Teacher——Student）双向关联映射，即老师知道自己教哪些学生，学生也知道教自己的有哪些老师------------

方法一：使用Annotation实现

在单向关联映射实例的方法一中仅仅设置Student类，其他保持不变，得到相同的测试结果。

package com.model;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Student {
	private int id;
	private String name;
	private Set<Teacher> teachers = new HashSet<Teacher>();
	@Id
	@GeneratedValue
	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;
	}
	@ManyToMany(mappedBy="students")
	public Set<Teacher> getTeachers() {
		return teachers;
	}
	public void setTeachers(Set<Teacher> teachers) {
		this.teachers = teachers;
	}
}

方法二：使用映射文件hbm.xml实现：

在单向关联映射实例的方法二中仅仅设置Student.hbm.xml，其他保持不变，得到相同的测试结果。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.model">
    <class name="Student">
    		<id name="id">
    			<generator class="native"></generator>
    		</id>
            <property name="name" />
            <set name="teachers" table="teacher_student">
            	<key column="student_id"></key>
            	<many-to-many class="Teacher" column="teacher_id"></many-to-many>
            </set>   
    </class>  
</hibernate-mapping>

----------------特别注意的是Student.hbm.xml的设置要和Teacher.hbm.xml中的设置相互对应，Teacher.hbm.xml中设置为：

    <class name="Teacher">
    		<id name="id">
    			<generator class="native"></generator>
    		</id>
            <property name="name" />  
            <set name="students" table="teacher_student">
            	<key column="teacher_id"></key>
            	<many-to-many class="Student" column="student_id"></many-to-many>
            </set> 
    </class>