hibernate:many-to-many
以学生和老师为例
建表语句:
CREATE DATABASE `manytomany`
CHARACTER SET 'utf8';
USE `manytomany`;
DROP TABLE IF EXISTS `student`;
create table student(
sid int auto_increment primary key,
name varchar(10) not null
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
DROP TABLE IF EXISTS `teacher`;
create table teacher(
tid int auto_increment primary key,
name varchar(10) not null
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
DROP TABLE IF EXISTS `st`;
create table st(
sid int not null,
tid int not null
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
Teacher.java
package com.test.domain;
import java.util.HashSet;
import java.util.Set;
public class Teacher implements java.io.Serializable {
private Integer tid;
private String name;
private Set students = new HashSet();
public Teacher() {
}
public Teacher(String name) {
this.name = name;
}
public Integer getTid() {
return this.tid;
}
public void setTid(Integer tid) {
this.tid = tid;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = students;
}
}
Student.java:
package com.test.domain;
import java.util.HashSet;
import java.util.Set;
public class Student implements java.io.Serializable {
private Integer sid;
private String name;
private Set teachers = new HashSet();
public Student() {
}
public Student(String name) {
this.name = name;
}
public Integer getSid() {
return this.sid;
}
public void setSid(Integer sid) {
this.sid = sid;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public Set getTeachers() {
return teachers;
}
public void setTeachers(Set teachers) {
this.teachers = teachers;
}
}
Teacher.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>
<class name="com.test.domain.Teacher" table="teacher" catalog="manytomany">
<id name="tid" type="java.lang.Integer">
<column name="tid" />
<generator class="native" />
</id>
<property name="name" type="java.lang.String">
<column name="name" length="10" not-null="true" />
</property>
<!--inverse="false": 由teacher操作student -->
<set name="students" table="st" cascade="save-update" inverse="false">
<key column="tid"></key>
<many-to-many class="com.test.domain.Student" column="sid">
</many-to-many>
</set>
</class>
</hibernate-mapping>
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>
<class name="com.test.domain.Student" table="student" catalog="manytomany">
<id name="sid" type="java.lang.Integer">
<column name="sid" />
<generator class="native" />
</id>
<property name="name" type="java.lang.String">
<column name="name" length="10" not-null="true" />
</property>
<!--inverse="true": 由teacher操作student -->
<set name="teachers" table="st" cascade="save-update" inverse="true">
<key column="sid"></key>
<many-to-many class="com.test.domain.Teacher" column="tid">
</many-to-many>
</set>
</class>
</hibernate-mapping>
测试类,Test.java
package com.test.dao;
import org.hibernate.Session;
import com.test.domain.Student;
import com.test.domain.Teacher;
public class Test {
public static void main(String[] args) {
Session session = HibernateSessionFactory.getSession();
Teacher teacher1 = new Teacher();
teacher1.setName("teacher1");
Teacher teacher2 = new Teacher();
teacher2.setName("teacher2");
Teacher teacher3 = new Teacher();
teacher3.setName("teacher3");
Student student1 = new Student();
student1.setName("student1");
Student student2 = new Student();
student2.setName("student2");
//student1.getTeachers().add(teacher1);student1.getTeachers().add(teacher2);student2.getTeachers().add(teacher1);这几句代码可以不要,因为Teacher掌握主动权。所以下面几句代码给注释掉了
// //学生一有2个老师
// student1.getTeachers().add(teacher1);
// student1.getTeachers().add(teacher2);
//
// //学生二有一个老师
// student2.getTeachers().add(teacher1);
//因为老师是inverse="false" ,老师掌握主动权
//第一个老师有2个学生
teacher1.getStudents().add(student1);
teacher1.getStudents().add(student2);
//第二个老师有一个学生
teacher2.getStudents().add(student1);
session.saveOrUpdate(teacher1);
session.saveOrUpdate(teacher2);
session.beginTransaction().commit();
session.close();
/**执行的sql
Hibernate: insert into manytomany.teacher (name) values (?)
Hibernate: insert into manytomany.student (name) values (?)
Hibernate: insert into manytomany.student (name) values (?)
Hibernate: insert into manytomany.teacher (name) values (?)
Hibernate: insert into st (tid, sid) values (?, ?)
Hibernate: insert into st (tid, sid) values (?, ?)
Hibernate: insert into st (tid, sid) values (?, ?)
*/
}
}
分享到:
相关推荐
在Java的持久化框架Hibernate中,Many-to-Many关系是一种常见的数据库表之间的关联方式,它表示一个实体可以与多个其他实体进行关联,反之亦然。本文将深入探讨如何在Hibernate中处理Many-to-Many关系的级联保存、...
"Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型,用于表示实体间的关联。在这个主题中,我们将深入探讨这两种关系映射的原理、配置和实际应用。 一、一对一(one-to-one)与一对多(one-to-...
本话题主要探讨两种基本的关系映射类型:many-to-one(多对一)和one-to-many(一对多)。这两种关系映射是数据库中常见的关联类型,理解和掌握它们对于开发高质量的Java应用至关重要。 1. many-to-one关系 many-to...
### Hibernate Many-to-One (多对一) 及 Cascade (级联) #### 一、Many-to-One(多对一) 在数据库设计中,实体之间的关系主要包括一对一、一对多、多对多等几种类型。而在ORM(对象关系映射)框架Hibernate中,...
同时,`Account.hbm.xml`中的`many-to-one`元素将`column`属性设置为`FID`,表示通过`FID`字段关联到`User`实体。 #### 测试场景解释 在测试场景中,我们创建了一个`User`对象和一个`Account`对象,并在`User`对象...
在Java的持久化框架Hibernate中,Many-to-Many映射是一种常见的关系模型,它用于表示两个实体类之间多对多的关系。在这个主题中,我们将深入探讨如何使用注解来实现这种映射,以及其背后的数据库原理和实际应用。 ...
free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of ...
"Hibernate many-to-many"指的是Hibernate中处理多对多关联关系的一种方式。多对多关系是两个实体类之间存在的一种复杂关联,比如学生和课程之间的关系,一个学生可以选修多门课程,一门课程也可以被多个学生选修。 ...
在配置双向一对多关联时,我们通常在"多"一端(这里是`Student`)的集合属性上使用`<many-to-one>`标签,将`Classes`对象映射到数据库中的外键。同时,在"一"端(`Classes`)使用`<set>`标签,表示班级可以包含多个...
<one-to-many class="Order"/> ``` ```java @Entity public class User { @Id private Long id; private String name; @Fetch(FetchMode.JOIN) @OneToMany(mappedBy = "user") private List<Order>...
本示例将详细讲解如何在Hibernate中实现多对多(many-to-many)的关系映射。 在数据库设计中,多对多关系是指两个实体之间存在多个关联,比如学生和课程的关系,一个学生可以选修多门课程,一门课程也可以被多个...
在Hibernate中,`one-to-many`关系是常见的实体间关系之一,表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...
例如,`<one-to-one>`、`<many-to-one>`、`<one-to-many>`和`<many-to-many>`元素分别对应这四种关系。关联映射通常涉及外键的处理和级联操作。 5. 注解方式的Mapping 除了XML映射,Hibernate还支持注解方式的映射...
映射文件`*.hbm.xml`则是Hibernate对象与数据库表之间的映射定义,DTD在这里定义了如`<class>`、`<table>`、`<id>`、`<property>`、`<many-to-one>`等元素的结构。通过这些元素,开发者可以详细指定Java类与数据库表...
本实例将详细讲解如何在Hibernate中实现Many-to-One关系映射,这是一种常见的数据库关联,表示一个实体可以与多个其他实体相关联。 在Many-to-One关系中,通常一个实体(如部门)可以有多个相关实体(如员工),而...
- Many-to-Many:多对多关联。 十、Inheritance Mapping Hibernate支持三种继承映射策略:Single Table、Table Per Class Hierarchies 和 Table Per Subclass。 十一、Hibernate事件监听 允许自定义监听器,如...
10. **多对一(One-to-Many)、一对多(Many-to-One)、一对一(One-to-One)、多对多(Many-to-Many)关系**: Hibernate支持这四种数据库关联关系,通过不同的注解配置来实现。 **使用Hibernate的步骤** 1. **...
在本文中,我们将深入探讨如何使用Hibernate来实现多对多(many-to-many)的映射关系。 首先,多对多映射关系通常涉及到两个实体类之间的关联,例如在学生选课的例子中,学生(Student)和课程(Course)之间存在多...
8. **一对多(One-to-Many)、多对一(Many-to-One)和多对多(Many-to-Many)关系**:Hibernate通过`@OneToMany`,`@ManyToOne`,`@ManyToMany`注解来处理这些关联关系,自动建立关联表或中间表。 9. **事务管理**...
在Hibernate中,一对一唯一外键关联映射可以通过 `<many-to-one>` 标签来配置。例如,以下是Person实体与IdCard实体的一对一唯一外键关联映射配置: ```xml <many-to-one name="idCard" column="card_id...