hibernate多对多关系
package com.manytomany; import java.util.HashSet;
import java.util.Set; public class Student {
private Long id;
private String name; private Set<Teacher> teachers = new HashSet<Teacher>(); // 关联的老师们 public Long getId() {
return id;
} public void setId(Long id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Set<Teacher> getTeachers() {
return teachers;
} public void setTeachers(Set<Teacher> teachers) {
this.teachers = teachers;
} @Override
public String toString() {
return "[Student: id=" + id + ", name=" + name + "]";
}
}
package com.manytomany; import java.util.HashSet;
import java.util.Set; public class Teacher {
private Long id;
private String name; private Set<Student> students = new HashSet<Student>(); // 关联的学生们 public Long getId() {
return id;
} public void setId(Long id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Set<Student> getStudents() {
return students;
} public void setStudents(Set<Student> students) {
this.students = students;
} @Override
public String toString() {
return "[Teacher: id=" + id + ", name=" + name + "]";
}
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.manytomany">
<class name="Student" table="t_student">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name" /> <!--
teachers属性,Set集合,表达的是本类与Teacher的多对多的关系
table属性:中间表(集合表)
key子元素:集合外键(引用当前表主键的那个外键)
-->
<set name="teachers" table="teacher_student" inverse="false">
<key column="studentId"></key>
<many-to-many class="Teacher" column="teacherId"></many-to-many>
</set>
</class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.manytomany">
<class name="Teacher" table="teacher">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name" type="string" column="name" /> <!-- students属性,Set集合,表达的是本类与Student的多对多的关系 -->
<set name="students" table="teacher_student" inverse="true">
<key column="teacherId"></key>
<many-to-many class="Student" column="studentId"></many-to-many>
</set>
</class>
</hibernate-mapping>
package com.manytomany.test; import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.EnumSet; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test; import com.hello.Account;
import com.hello.User;
import com.manytomany.Student;
import com.manytomany.Teacher; public class HelloTest { private static SessionFactory sessionFactory; static {
sessionFactory = new Configuration()
.configure() // 读取配置文件
.buildSessionFactory();
} // 根据配置生成表结构
@Test
public void test() {
//hibernate 5.0
Configuration conf = new Configuration().configure();//1、读取配置文件
StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().configure().build();
Metadata metadata = new MetadataSources(serviceRegistry).buildMetadata();
} @Test
public void hello(){ Session session=sessionFactory.openSession();
Transaction tx = session.beginTransaction();
//==================================================
Student student1 = new Student();
student1.setName("王同学"); Student student2 = new Student();
student2.setName("李同学"); Teacher teacher1 = new Teacher();
teacher1.setName("赵老师"); Teacher teacher2 = new Teacher();
teacher2.setName("蔡老师"); // 关联起来
student1.getTeachers().add(teacher1);
student1.getTeachers().add(teacher2);
student2.getTeachers().add(teacher1);
student2.getTeachers().add(teacher2); teacher1.getStudents().add(student1);
teacher1.getStudents().add(student2);
teacher2.getStudents().add(student1);
teacher2.getStudents().add(student2); // 保存
session.save(student1);
session.save(student2);
session.save(teacher1);
session.save(teacher2); //==================================================
tx.commit();
} // 解除关联关系
@Test
public void testRemoveRelation() {
Session session = sessionFactory.openSession();
session.beginTransaction();
// ------------------------------------------- // 如果inverse=false就可以解除,如果为true就不可以解除(删除中间表中的记录)
// Teacher teacher = (Teacher) session.get(Teacher.class, 3L);
// teacher.getStudents().clear();
Student student=session.get(Student.class, 4l);
student.getTeachers().clear(); // -------------------------------------------
session.getTransaction().commit();
session.close();
}
// 删除对象,对关联对象的影响
@Test
public void testDelete() {
Session session = sessionFactory.openSession();
session.beginTransaction();
// ------------------------------------------- // 删除老师方
// a,如果没有关联的对方:能删除
// b,如果有关联的对方且inverse=false,由于可以维护关联关系,它就会先删除关联关系,再删除自己。
// c,如果有关联的对方且inverse=true,由于不能维护关联关系,所以会直接执行删除自己,就会有异常
// Teacher teacher = (Teacher) session.get(Teacher.class, 5L);
// session.delete(teacher);
Student student=session.get(Student.class, 6l);
session.delete(student);
// -------------------------------------------
session.getTransaction().commit();
session.close();
} @Test
public void testGet(){ Session session=sessionFactory.openSession(); }
}
删除打印sql语句
Hibernate:
select
student0_.id as id1_1_0_,
student0_.name as name2_1_0_
from
t_student student0_
where
student0_.id=?
Hibernate:
delete
from
teacher_student
where
studentId=?
Hibernate:
delete
from
t_student
where
id=?
hibernate多对多关系的更多相关文章
- Hibernate多对多关系映射(建表)
下边讲述Hibernate多对多关系映射. 多对多关系的表的结构为: 两个实体表,还包含一个关系表,关系表为复合主键,如果要使用Hibernate多对多关系映射,则关系表必须只包含两个字段,如果生成了 ...
- 菜鸟学习Hibernate——多对多关系映射
Hibernate中的关系映射,最常见的关系映射之一就是多对多关系映射例如用户与角色的关系,一个用户对应多个角色,一个角色对应多个用户.如图: Hibernate中如何来映射这两个的关系呢? 下面就为 ...
- hibernate 多对多关系总结
hibernate中,对对象关系的映射处理估计是最让人迷惑和头疼的,特别是cascade和inverse属性的使用,不知已经杀死了我多少个脑细胞了,好记性永远比不上烂笔头,为了能节省自己的脑细胞,降低 ...
- Hibernate多对多关系映射
两张表的多对多关系,在数据库中通常是通过第三张中间表来实现的,第三张中间表放的是两张表各自的主键值,通过主键与主键的对应来体现表直接的关系.比如在权限系统中,一个用户可以拥有多种权限,而一种权限也可以 ...
- hibernate多对多关系配置
一.创建用户,角色实体类. 一名用户可以有多个角色.一个角色可以对于多名用户. 用户实体类 public class User { private int uId; private String uN ...
- Hibernate 多对一关系中,在多的一方进行数据的插入
先看两个映射关系: 部门: <?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//H ...
- 12.Hibernate多对多关系
JavaBean的编写 Person private long pid ; private String name ; private Set<Role> roles = new Hash ...
- Hibernate学习第三天(2)(多对多关系映射)
1.1.1 Hibernate多对多关系的配置 1.1.1.1 创建表 l 用户表 CREATE TABLE `sys_user` ( `user_id` bigint(32) NO ...
- 如何决解项目中hibernate中多对多关系中对象转换json死循环
先写一下原因吧!我是写的SSH项目,在项目中我遇到的问题是把分页对象(也就是pageBean对象)转化为json数据,下面为代码: public class PageBean <T>{// ...
随机推荐
- TCP协议三次握手、四次挥手
TCP的概述 TCP 把连接作为最基本的对象,每一条 TCP 连接都有两个端点,这种断点我们叫作套接字(socket),它的定义为端口号拼接到 IP 地址即构成了套接字,例如,若 IP 地址为 192 ...
- 剑指offer 01:二维数组中的查找
题目描述 在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序.请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数 ...
- 补充一下 sizeof
sizeof是一个运算符,给出某个类型或变量在内存中所占据的字节数 sizeof(int) //告诉你int占据几个字节 sizeof(i) //告诉你i这个变量占据几个字节 注:sizeof是静态运 ...
- Nginx教程--02.Nginx虚拟主机的配置
1.Nginx虚拟主机的配置 1.1 在conf目录下,使用命令 : vim nginx.conf 对上图解释: //全局区 worker _processes 1; //表示当前有1个工作的子进程, ...
- 【七】jquery之属性attr、 removeAttr、prop[全选全不选及反选]
全选全不选 界面: 代码: <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> ...
- 使用metrics统计接口tps
metrics的简单介绍 metrics是一种性能指标工具,有很多开源工具使用之来来作为其性能监控,如Hadoop,Kafka,Spark,JStorm等. metrics使用最主要有三个东西: Me ...
- iSCSI网络协议.学习笔记
Internet SCSI(iSCSI)是一种网络协议,使用TCP/IP网络来传输SCSI协议.它是代替FC(Fibre Channel-based,光纤通道) SAN的很好选择.你可以在Linux下 ...
- SASS 简单实用
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- 『流畅的Python』第12章:继承的优缺点
- string部分方法
1.string.lastIndexOf() lastIndexOf 是从string末尾查找,但是返回值仍是首部的位置值. 2.string.replace() 放一个正则匹配会全部替换. 3.st ...