【Hibernate】manyTomany练习

最新推荐文章于 2020-10-17 17:40:58 发布
最新推荐文章于 2020-10-17 17:40:58 发布
阅读量554 收藏
点赞数
分类专栏： Hibernate 文章标签： hibernate 
<!-- 
    		table 指的是多对多的第三张表
    	 -->
    	<set name="students" table="student_course" cascade="save-update" inverse="true">
    		<key>
    			<column name="cid"></column>
    		</key>
    		<many-to-many class="cn.itcast.hibernate0909.manytomany.Student" column="sid"></many-to-many>
    	</set>
<!-- 
    		table 指的是多对多的第三张表
    	 -->
    	<set name="course" table="student_course" cascade="save-update">
    		<key>
    			<column name="sid"></column>
    		</key>
    		<many-to-many class="cn.itcast.hibernate0909.manytomany.Course" column="cid"></many-to-many>
    	</set>

/**
 * 1、保存课程
 * 2、保存学生
 * 3、保存课程的时候同时保存学生
 * 4、保存课程的时候同时保存学生，并且建立课程和学生之间的关系
 * 5、已经存在一个课程，新建一个学生，并且建立该学生和该课程之间的关系
 * 6、已经存在一个学生，新建一个课程，并且建立该学生和该课程之间的关系
 * 7、已经存在一个学生，已经存在一个课程，解除该学生和原来课程之间的关系，建立该学生和新课程之间的关系
 * 8、已经存在一个学生，解除该学生和该学生的所有的课程之间的关系
 * 9、解除该课程和所有的学生之间的关系，再重新建立该课程和一些新的学员之间的关系
 * 10、解除该课程和所有的学生之间的关系
 * 11、删除课程
 *      *
 *      	*  解除该班级和所有的学生之间的关系
 *      	*  删除该班级
 *      *   
 *          删除班级的同时删除学生
 * 12、删除学生
 *      同删除班级
 * @author Administrator
 *
 */
public class ManyToManyTest {
	private static SessionFactory sessionFactory = null;
	static{
		Configuration  configuration = new Configuration();
		configuration.configure("cn/itcast/hibernate0909/manytomany/hibernate.cfg.xml");
		sessionFactory = configuration.buildSessionFactory();
	}
	/**
	 * 保存课程
	 */
	@Test
	public void testSaveCourse(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Course course = new Course();
		course.setCname("生理卫生");
		course.setDescription("讲得都是讲卫生的");
		session.save(course);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 保存学生
	 */
	@Test
	public void testSaveStudent(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Student student = new Student();
		student.setSname("里活命");
		student.setDescription("传智播客的UFO");
		session.save(student);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 保存课程同时保存学生
	 * 		Hibernate: select max(cid) from Course
			Hibernate: select max(sid) from Student
			Hibernate: insert into Course (cname, description, cid) values (?, ?, ?)
			Hibernate: insert into Student (sname, description, sid) values (?, ?, ?)
	 			往Course表和Student表中分别插入了一行数据，和关系表没有关系
	 	        通过映射文件可以看出，Student维护关系,但是从代码中找不到维护关系的代码
	 */
	@Test
	public void testSaveCourse_Cascade(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		/*
		 * 新建一个课程
		 */
		Course course = new Course();
		course.setCname("java基础");
		course.setDescription("名师老冯讲课");
		/**
		 * 新建一个学生
		 */
		Student student = new Student();
		student.setSname("老冯得意门生：西门庆");
		student.setDescription("高手");
		
		Set<Student> students = new HashSet<Student>();
		students.add(student);
		/**
		 * 通过课程建立课程与学生之间的关系
		 */
		course.setStudents(students);//因为课程是一个新的，所以根据没有学生
		session.save(course);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 保存课程同时保存学生，并且建立关系
	 */
	@Test
	public void testSaveCourse_Cascade_R(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		/**
		 * 新建课程
		 */
		Course course = new Course();
		course.setCname("java高级");
		course.setDescription("专讲框架,由金云龙代课");
		Set<Course> courses = new HashSet<Course>();
		courses.add(course);
		/**
		 * 新建学生
		 */
		Student student = new Student();
		student.setSname("班长");
		student.setDescription("高手,元方，你怎么看?");
		/*
		 * 通过学生建立学生和课程之间的关系
		 */
		student.setCourse(courses);
		session.save(student);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 已经存在一个课程，新建一个学生，并且建立该学生和该课程之间的关系
	 * 		Hibernate: select course0_.cid as cid0_0_, course0_.cname as cname0_0_, course0_.description as descript3_0_0_ from Course course0_ where course0_.cid=?
			Hibernate: select max(sid) from Student
			Hibernate: insert into Student (sname, description, sid) values (?, ?, ?)
			Hibernate: insert into student_course (sid, cid) values (?, ?)
			    	该sql语句是维护关系
	 */
	@Test
	public void testSaveStudent_R(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		/**
		 * 1、查找一个课程
		 * 2、新建一个学生
		 * 3、通过学生来维护该学生和课程之间的关系
		 */
		//查找课程2
		Course course = (Course)session.get(Course.class, 2L);
		//新建一个学生
		Student student = new Student();
		student.setSname("王健得意门生");
		student.setDescription("张霞");
		//通过学生来维护该学生和课程之间的关系
		Set<Course> courses = new HashSet<Course>();
		courses.add(course);
		student.setCourse(courses);
		session.save(student);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 已经存在一个学生，新建一个课程，并且建立该学生和该课程之间的关系
	 */
	@Test
	public void testSaveCourse_R(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		/**
		 * 1、新建一个课程
		 * 2、查找学生
		 * 3、在学生原来的基础上新添加一门课程
		 */
		//新建课程
		Course course = new Course();
		course.setCname("项目课");
		course.setDescription("主讲老师赵栋，所有的美女都是得意门生");
		//查找学生
		Student student = (Student)session.get(Student.class, 5L);
		Set<Course> courses = student.getCourse();//获取该学生现在所有的课程
		courses.add(course);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 已经存在一个学生，已经存在一个课程，解除该学生和原来一个课程之间的关系，建立该学生和新的一个课程之间的关系
	 */
	@Test
	public void testRealse_Rebuild_R(){
		/*
		 * 分析：
		 *   *  从需求分析上看，这个例子就是关系的操作
		 *   *  要查看谁来维护关系，通过映射文件可以看出，Student来维护关系
		 *   *  步骤
		 *       *  查询sid为5的学生
		 *       *  得到该学生的所有的课程
		 *       *  遍历课程
		 *          有可能有两种操作：
		 *             *  先移除集合中的一个元素，再添加
		 *             *  直接修改集合中的元素
		 *  多对多的关系的维护包括两个操作
		 *     第三张表的增加、删除
		 */
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		//得到sid为5的学生
		Student student = (Student)session.get(Student.class, 5L);
		//得到cid为1的课程
		Course course2 = (Course)session.get(Course.class, 1L);
		//得到该学生的所有的课程
		Set<Course> courses = student.getCourse();
		for(Course course:courses){
			if(course.getCid().longValue()==2){
				courses.remove(course);//先移除
				
				break;
			}
		}
//		List<Course> courseList = new ArrayList<Course>(courses);
//		for(int i=0;i<courseList.size();i++){
//			if(courseList.get(i).getCid().longValue()==2){
//				courseList.set(i, course2); 
//			}
//		}
//		Set<Course> courses2 = new HashSet<Course>(courseList);
//		student.setCourse(courses2);
		courses.add(course2);//增加
		transaction.commit();
		session.close();
	}
	
	/**
	 * 已经存在一个学生，已经存在多个课程，解除该学生和原来多个课程之间的关系，建立该学生和新的多个课程之间的关系
	 */
	@Test
	public void testRealse_Rebuild_R_Many(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Student student = (Student)session.get(Student.class, 5L);
		Course course2 = (Course)session.get(Course.class, 2L);
		Course course5 = (Course)session.get(Course.class, 5L);
		Set<Course> courses = student.getCourse();
		for(Course course:courses){
			//在关系表中把sid为5,cid为1  sid为5，cid为3的两行删除
			if(course.getCid().longValue()==1||course.getCid().longValue()==3){
				courses.remove(course);
				break;
			}
		}
		courses.add(course5);
		courses.add(course2);
		transaction.commit();
		session.close();
	}
	
	/*
	 * 已经存在一个学生，解除该学生和该学生的所有的课程之间的关系
	 */
	@Test
	public void testRealse_R(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Student student = (Student)session.get(Student.class, 5L);
		student.setCourse(null);//解除该学生和所有的课程之间的关系
		transaction.commit();
		session.close();
	}
	
	/**
	 * 解除该课程和所有的学生之间的关系，再重新建立该课程和一些新的学员之间的关系
	 *   说明：
	 *     *  必须由学生来维护关系
	 *     *  已经条件是课程
	 *         cid-->course-->set<student>-->遍历每一个student
	 *         -->从每一个student中得到所有的课程-->找到要移除的课程-->移除
	 */
	@Test
	public void testRealse_R_C(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Course course = (Course)session.get(Course.class, 3L);
		Set<Student> students = course.getStudents();
		for(Student student:students){
			Set<Course> courses = student.getCourse();
			for(Course course2:courses){
				if(course2.getCid().longValue()==3){
					courses.remove(course2);
					break;
				}
			}
		}
		Student student4 = (Student)session.get(Student.class, 4L);
		Student student5 = (Student)session.get(Student.class, 5L);
		student4.getCourse().add(course);
		student5.getCourse().add(course);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 解除该课程和所有的学生之间的关系
	 */
}


【Hibernate步步为营】--多对多映射详解
航帆远洋
05-27 6045
上篇文章详细讨论了一对多映射，在一对多映射中单向的关联映射会有很多问题，所以不建议使用如果非要采用一对多的映射的话可以考虑使用双向关联来优化之间的关系，一对多的映射其实质上是在一的一端使用<many-to-one>标签来标明它们之间的关系，另外还需要在一的一端的对象中使用set标明集合映射。
Hibernate多对多映射
球球之家
03-04 1126
多对多：   * 关系在第三张表中，和两张表本身没有关系   * 多对多谁维护关系：谁都能维护关系(效率是一样的)，一般情况下可以通过页面      来体现   * 关系体现：         第三张表的维护：增加、删除
hibernate manytomany
u014164005的博客
11-03 169
如有两个表用户（users） 和角色（role） 他们是多对多关系：Users: import java.io.Serializable; import java.util.HashSet; import java.util.Set; import javax.persistence.Entity; import javax.persistence.FetchType; imp...
Hibernate ManyToMany
iteye_2694的博客
08-20 193
[size=medium]对象之间的关系有多对一,一对多和多对多三种,现在我们主要分析一下多对多[/size] [size=medium]先看实体类:[/size] User [code="java"] private int id; private String username; private Set roles; @Id @GeneratedValue(str...
Hibernate之多对多映射
bighuan的博客
05-02 342
一,概述 在开发中,表与表之间的多对多关系是挺常见的,也比较复杂.这篇博客就是关于Hibernate如何通过映射文件来生成多对多关系对应的三张表.需求:项目与开发人员,一个项目由多个开发人员开发,开发人员可以参与多个项目的开发,这是典型的多对多关系. 二,JavaBean设计 1)项目 package com.bighuan.c_many2many; import java.util.H
hibernate:Hibernate练习
06-20
9. **一对多、多对一、一对一和多对多关系映射**：这些是数据库中常见的关联关系，Hibernate提供了对应的关系映射配置，如`@OneToMany`、`@ManyToOne`、`@OneToOne`和`@ManyToMany`。 10. **事件监听器和拦截器**：...
hibernate总结练习源码
02-14
本资源包含的"hibernate总结练习源码"提供了对Hibernate ORM框架实际应用的实例，有助于深入理解和掌握其核心概念与功能。 1. **对象关系映射（ORM）**：Hibernate 提供了一种机制，将数据库中的表映射为Java类，表...
Hibernate关联关系练习【全】
06-18
本练习主要涵盖了Hibernate中的关联关系，这是理解Hibernate核心概念的重要一环。 首先，我们需要理解什么是关联关系。在数据库设计中，关联通常指的是表与表之间的连接，例如一对一、一对多、多对一和多对多关系。...
hibernate练习
06-20
"hibernate练习" 这个标题表明我们将探讨的是关于Hibernate的实践操作，Hibernate是一个流行的Java对象关系映射（ORM）框架，它允许开发人员使用面向对象的方式来处理数据库交互，极大地简化了Java应用中的数据访问...
hibernate 练习
04-12
【hibernate 练习】 Hibernate 是一个开源的 Java 库，它作为对象关系映射（ORM）框架，简化了数据库操作，使开发者能够用面向对象的方式处理数据。本练习旨在帮助你深入理解和掌握 Hibernate 的核心概念和常用功能...
hibernate（多对多关系映射）
07-19
hibernate（多对多关系映射）实现存储，内附sql脚本和详细的注释，适合初学者
hibernate多对多关联映射
04-05
NULL 博文链接：https://1028826685.iteye.com/blog/1536060
【Hibernate】多对多映射
颗粒归仓
01-10 1057
前面的博客介绍了一对多，多对一和一对一关联映射，这篇博客介绍多对多关联映射。和之前的一样，包括单向多对多和双向多对多。 一、单向多对多     单向多对多的例子用人和职位来举例，一个人可以有多个职位，一个职位会有多个人。单向多对多是指只能在一端来查询获取另一端的内容。多对多的关系在生成关系模型时会生成对象之前的关联表，关联表中存放着两个关系表的主键，它们的关系如下所示：
hibernate多对多映射
xiaoxiaoxinhuan的博客
06-22 295
hibernate的多对多映射就好比项目（Project）与开发人员(Developer),他们之间的关系用中间表（t_relation）联系起来。中间表的字段分别为两个表的外键d_id与p_id。 1、创建实体类Project.java package com.itcast.b; import java.util.HashSet; import java.util.Set; public
Hibernate多对多关系映射
weixin_40222311的博客
10-17 114
创建多对多关系表  用户表 CREATE TABLE `sys_user` ( `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id', `user_code` varchar(32) NOT NULL COMMENT '用户账号', `user_name` varchar(64) NOT NULL COMMENT '用户名称', `user_password` varchar(32) NOT NULL COMMENT '用户
《Hibernate》-----ManyToMany
zhoukun@Fly
02-11 734
前言 用户，角色，权限是OA系统中最常见的问题，一个用户是是什么角色，一种角色应该被分配什么样的权限……，由于小编做的OA系统操作数据库是封装的Hibernate，所以今天就拿用户与角色这个多对多关系的例子来总结一下Hibernate中的多对多操作。 User.hbm.xm<hibernate-mapping> <class name="com.dmsd.elec.domain.User" ta
【Hibernate】——多对多关联映射
许小乖……是总攻
05-12 875
对比单向和双向关联映射，可以从查询加载的地方看出二者的不同，单向关联映射只能从循环遍历用户获得角色，但是双向关联映射既可以循环遍历用户获得角色，也可以循环遍历角色获得用户。 需要注意的是<key>中的column对应的是当前类在中间表中对应的字段，即对方想要的外键，而<many-to-manyclass="com.bjpowernode.hibernate.Role"column="role_id"/>中的column指示的是中间表中本类想要的外键。还要注意的是inverse的值只能
Hibernate关联关系深度练习解析
文件标题“Hibernate关联关系练习【全】”暗示了该文件是一份关于Hibernate框架中关联关系的全面练习资料。这可能包括对一对一、一对多、多对一以及多对多关联关系的定义、配置和应用的详细练习题和解答。这些练习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值