hibernate的多对多解析

最新推荐文章于 2018-09-27 19:30:43 发布
最新推荐文章于 2018-09-27 19:30:43 发布
阅读量599 收藏 1
点赞数
分类专栏： --------《三大框架》 三大框架(S2SH)深入学习和理解 文章标签： hibernate的多对多解析 hibernate的多对多解析案例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_li13/article/details/49701843
版权

问题？hibernate的多对多的解析

环境：先搭建hibernate环境

注：在这里我们选择，由持久化类和映射文件来生成表(因为这样做的话，只在多对多的两个之间生成一个中间表。共三张表)。如果由表来生成持久化类和映射文件的话，它会生成一个联合组件类。相对来说在操作上。困难度加大了，也复杂化了。

                   

案例：

先写两个持久化类和相应的映射文件

Course.java

package cn.itcast.hibernate.manyTOmanyDomain;

import java.io.Serializable;
import java.util.Set;

public class Course implements Serializable{
	private Long cid;
	private String cname;
	private String description;
	private Set<Students> students;//Students多的方
	
	
	public Long getCid() {
		return cid;
	}

	public void setCid(Long cid) {
		this.cid = cid;
	}

	public String getCname() {
		return cname;
	}

	public void setCname(String cname) {
		this.cname = cname;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public Set<Students> getStudents() {
		return students;
	}

	public void setStudents(Set<Students> students) {
		this.students = students;
	}

	
}


Students.java 

package cn.itcast.hibernate.manyTOmanyDomain;

import java.io.Serializable;
import java.util.Set;

public class Students implements Serializable{
	private Long sid;
	private String sname;
	private String description;
	private Set<Course> courses;//Course多的一方
	
	public Long getSid() {
		return sid;
	}

	public void setSid(Long sid) {
		this.sid = sid;
	}

	public String getSname() {
		return sname;
	}

	public void setSname(String sname) {
		this.sname = sname;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public Set<Course> getCourses() {
		return courses;
	}

	public void setCourses(Set<Course> courses) {
		this.courses = courses;
	}


}

Course.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="cn.itcast.hibernate.manyTOmanyDomain.Course">
		<id name="cid" length="5">
			<generator class="increment"></generator>
		</id>
		<property name="cname" length="20"></property>
		<property name="description" length="100"></property>
		
		<set name="students" table="student_course" cascade="save-update">
			<key>
				<column name="cid"></column>
			</key>
			<many-to-many class="cn.itcast.hibernate.manyTOmanyDomain.Students" column="sid"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

Students.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="cn.itcast.hibernate.manyTOmanyDomain.Students">
		<id name="sid" type="java.lang.Long" length="5">
			<generator class="increment"></generator>
		</id>
		<property name="sname" type="java.lang.String" length="20"></property>
		<property name="description" length="100"></property>
		<!-- 
			table就是用来描述第三张表
			column,这个外键，就是在那张表，外键就填谁
		 -->
		<set name="courses" table="student_course" cascade="save-update">
			<key>
				<column name="sid"></column>
			</key>
			<many-to-many class="cn.itcast.hibernate.manyTOmanyDomain.Course" column="cid"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

最后就是配置文件了.hibernate.cfg.xml文件

因为在这里我是放再跟持久化文件和映射文件同一个包下的。所以相对来说。工具类就得采用上一次所说的第二种方式了(在configur（URL）中写配置文件的地址。第一种方式，是配置文件就根目录下，就不用写。)


hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<!-- 
		一个session-factory只能连接一个数据库，一般我们也只写一个。
	-->
<session-factory>
	<!-- 
		数据库的用户名
	-->
	<property name="connection.username">root</property>
	<!-- 
		数据库的密码
	-->
	<property name="connection.password">root</property>
	<!-- 
		数据库的url:itcast_sh_hibernate是你用的数据库
	-->
	<property name="connection.url">
		jdbc:mysql://localhost:3306/itcast_sh_hibernate
	</property>
	<!-- @hbm2ddl.auto
		作用：根据持久化类和映射文件生成表
		validate:验证持久化类在映射文件中描述正不正确，只验证
		create-drop：hibernate容器开启的时候生成表，关闭的时候删除表(不用)
		create:hibernate容器开启的时候生成表(不用)
		update:表示hibernate开启的时候，先检查持久化类和映射问件和表到底对应不对应，
		不对应的话，我新建一个表。对应的话，验证描述正不正确(validate)
	-->
	<property name="hbm2ddl.auto">update</property>

	<!-- 
		显示hibernate内部生成的sql语句
	-->
	<property name="show_sql">true</property>

	<!--@mapping resource
		表示和映射文件相对应
	-->
	<mapping
		resource="cn/itcast/hibernate/manyTOmanyDomain/Course.hbm.xml" />
	<mapping
		resource="cn/itcast/hibernate/manyTOmanyDomain/Students.hbm.xml" />

</session-factory>
</hibernate-configuration>

最后就是写读取配置文件的工具类了。（ 注：这里的@Before是指先执性子类的static，最后在执性父类的static，不然url就传不过去了）

HibernateUtil.java

package cn.itcast.hibernate.util;

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

public class HibernateUtil {
	public static SessionFactory sessionfactory;
	public static String url;

	@Before
	public void init(){
		Configuration configuration=new Configuration();
		configuration.configure(url);
		sessionfactory=configuration.buildSessionFactory();
	}
}

最后就是写测试文件了。注意，一定要先建库(MySql） 
package cn.itcast.hibernate.manyTOmanyTest;


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

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.hibernate.manyTOmanyDomain.Course;
import cn.itcast.hibernate.manyTOmanyDomain.Students;
import cn.itcast.hibernate.util.HibernateUtil;

/**
 * 1、新建一个课程
 * 2、新建一个学生
 * 3、新建课程的同时新建学生 级联
 * 4、已经存在一个课程，新建一个学生，建立课程和学生之间的关系
 * 5、已经存在一个学生，新建一个课程，建立课程和学生之间的关系
 * 6、已经存在一个课程，已经存在一个学生，建立关联
 * 7、把已经存在的一些学生加入到已经存在的一个课程中
 * 8、把一个学生加入到一些课程中
 * 9、把多个学生加入到多个课程中
 * 10、把一个已经存在的学生从一个已经的课程中移除
 * 11、把一些学生从一个已经存在的课程中移除
 * 12、把一个学生从一个课程转向到另外一个课程
 * 13、删除课程
 * 14、删除学生
 * @author Think
 *
 */
public class CreateTable extends HibernateUtil{
	static{ 
		url="cn/itcast/hibernate/manyTOmanyDomain/hibernate.cfg.xml";
	}
	@Test
	public void CreateTable1(){
		
	}
/*	 * 1、新建一个课程
	 * 2、新建一个学生
	 * 3、新建课程的同时新建学生 级联*/
	@Test
	public void testSaveStudent_Cascade_Course_Save(){
		Session session = sessionfactory.openSession();
		Transaction transaction = session.beginTransaction();
		Students student = new Students();
		student.setSname("班长2");
		student.setDescription("牛人");
		
		Course course = new Course();
		course.setCname("生理卫生");
		course.setDescription("很好");
//通过操作student表级联操作course表(这个的要求是在students映射文件中，必须要有save-upate)
//		Set<Course> courses = new HashSet<Course>();
//		courses.add(course);
//		student.setCourses(courses);
//		session.save(student);
//		
		
//通过course表级联操作操作student表(这个的要求是在course映射文件中，必须要有save-upate)
		Set<Students> students=new HashSet<Students>();
		students.add(student);
		course.setStudents(students);
		session.save(course);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 已经存在一个课程，新建一个学生，建立课程和学生之间的关系
	 *    从课程角度出发
	 * 已经存在一个学生，新建一个课程，建立课程和学生之间的关系
	 */
	@Test
	public void testUpdateCourse_Cascade_Student_Save_R(){
		Session session = sessionfactory.openSession();
		Transaction transaction = session.beginTransaction();
//		Course course = (Course)session.get(Course.class, 1L);
//		Students student = new Students();
//		student.setSname("班迷");
//		student.setDescription("班丝：班长的钢丝");
//		course.getStudents().add(student);
		
		
//		session.save(student);
		//这个是在course映射文件中没有save-update的时候做，又student操作course
		Students students=(Students)session.get(Students.class, 1L);
		Course course=new Course();
		course.setCname("大神2");
		course.setDescription("非常牛逼");
		
		students.getCourses().add(course);
		transaction.commit();
		session.close();
	}
	
	//已经存在一个课程，已经存在一个学生，建立关联
	@Test
	public void testR(){
		Session session = sessionfactory.openSession();
		Transaction transaction = session.beginTransaction();
		Course course = (Course)session.get(Course.class, 1L);
		Students student = (Students)session.get(Students.class, 2L);
//		student.getCourses().add(course);
		course.getStudents().add(student);
		transaction.commit();
		session.close();
	}

	/**
	 * 把学生3,4加入到课程1中
	 */
	@Test
	public void testR_Some(){
		Session session = sessionfactory.openSession();
		Transaction transaction = session.beginTransaction();
		Course course = (Course)session.get(Course.class, 1L);
		Students student3 = (Students)session.get(Students.class, 3L);
		Students student4 = (Students)session.get(Students.class, 4L);
		course.getStudents().add(student3);//很明显较相对来说，由课程来加入学生效率高
		course.getStudents().add(student4);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 把一个学生加入到一些课程中
	 */
	@Test
	public void testR_Some_2(){
		Session session = sessionfactory.openSession();
		Transaction transaction = session.beginTransaction();
		Students student = (Students)session.get(Students.class, 3L);
		List<Course> courseList = session.createQuery("from Course where cid in(1,2,3)").list();
		student.getCourses().addAll(courseList);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 把一个课程加入到一些学生中
	 */
	@Test
	public void testR_Some_3(){
		Session session = sessionfactory.openSession();
		Transaction transaction = session.beginTransaction();
		Course course = (Course)session.get(Course.class, 3L);
		List<Students> studentsList = session.createQuery("from Students where sid in(1,2,3,4)").list();
		course.getStudents().addAll(studentsList);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 把学生从一个课程转移到另外一个课程
	 */
	@Test
	public void testTransform(){
		Session session = sessionfactory.openSession();
		Transaction transaction = session.beginTransaction();
		Students student = (Students) session.get(Students.class, 3L);
		Course course2 = (Course)session.get(Course.class, 2L);
		Course course3 = (Course)session.get(Course.class, 3L);
		
		student.getCourses().remove(course3);
		student.getCourses().add(course2);
		transaction.commit();
		session.close();
	}
}

案例：下载 案例


黯雅悸动
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate一对多、多对一、多对多问题
DanielAnton的博客
08-26 5975
最近在写一个博客项目，数据库表的建立要考虑多表的问题，记录下学习所得！ CRUD create read update delete 实体类的设计： Article： articleId title content  createDate author(User类型 多对一关系维护端) category(Category类型 多对一关系维护端)                comment...
hibernate 多对多关系详解(包括中间表，一对多字表)
kenchow126的专栏
05-25 7989
Event事件表 Person 人员表 Person_Event 人员事件表 PersonEmailAddr邮件地址表  关系图： 事件对人员是多对多的关系，中间表Person_Event只有两个字段(PERSON_ID,EVENT_ID)，邮件地址表只对应人员ID，一个人可以多个邮箱   *************** CLASS PERSON ***************
Hibernate的一对多关联关系（单向和双向）
Alan_Xiang的博客
12-04 5307
在领域模型中，类与类之间最普遍的关系就是关联关系。在 UML 中，关联是有方向的。以 Customer 和 Order 为例：一个用户能发出多个订单, 而一个订单只能属于一个客户。从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联。 　　单向n-1的关联关系　　单向 n-1 关联只需从 n 的一端可以访问 1 的一端。 　　域模型：从
hibernate一对多多对多映射（注解）
qq_21911655的博客
12-02 1万+
4，一对多多对一单向关联 –@ManyToOne：在多的一方维护记录（在tuser2表维护记录） （1）表结构：tuser2表的groupid字段关联tgroup表的主键id，tuser2是多的一方，tgroup是一的一方： （2）bean： @Entity @Table(name="tuser2") public class TUser2 implements Seriali...
Hibernate (超详细一对一，一对多，多对一，多对多)
念念不忘，必有回响
09-27 3638
（一对一，双向关联）对应关系： 一个人对应一个地址 整体路径结构 Person类 public class Person implements Serializable { /** * */ private static final long serialVersionUID = 1L; private Integer personid; private Str...
hibernate多对多查询
Tw368WJZ的博客
07-06 1473
hibernate多表查询 分析表关系 1.多对多 1.1创建实体类 客户和联系人的关系 import java.util.HashSet; import java.util.Set; /* * CREATE TABLE `sys_user` ( `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMM...
hibernate 多对多源代码
10-24
在Java的持久化框架Hibernate中，多对多（Many-to-Many）关系是数据库中常见的关联类型，它允许一个实体实例对应多个其他实体实例，反之亦然。本篇将深入探讨Hibernate如何处理这种复杂的数据关联。 一、多对多关系...
hibernate多对多关联映射
04-05
本文将深入探讨Hibernate如何实现多对多关联映射，并通过实际例子解析相关配置和操作。 一、多对多关联概述 在数据库设计中，多对多关联表示两个表之间的关系，如学生和课程的关系，一个学生可以选修多门课程，而...
hibernate实现多对多关联关系源码
10-09
在Java的持久化框架Hibernate中，多对多（Many-to-Many）关联关系是一种常见的实体间关系类型，它表示一个实体可以与多个其他实体相关联，反之亦然。本源码示例将深入探讨如何使用Hibernate来配置和管理这种复杂的...
hibernate 多对多操作
05-24
标题“hibernate 多对多操作”表明了本文将探讨的是在Java编程中，使用Hibernate框架处理数据库中的多对多关联关系。Hibernate是Java领域广泛使用的对象关系映射（ORM）工具，它允许开发者用面向对象的方式处理...
Hibernate一对多关联实例
10-19
本文将详细解析" Hibernate一对多关联实例 "，并涵盖关联的保存(save)、删除(delete)、查询(select)和更新(update)操作。 一、一对多关联概念 在数据库设计中，一对多关联表示一个表中的记录可以与另一个表中的多个...
SSH框架之Hibernate的关联映射之一对多、多对一映射
一点一滴
12-19 1万+
关联映射之一对多、多对一映射 一、需求： 部门与员工 一个部门有多个员工 【一对多】 多个员工，属于一个部门 【多对一】 二、逻辑分析： 三、代码实现 1、javabean及映射文件的配置： 1）Employee.java、Employee.hbm.xml 2）Dept.java、Dept.hbm.xml
Hibernate 映射多对多关联关系
C.
02-04 2833
多对多持久化类和映射文件的搭建1.创建持久化类1.创建Student类package cn.itcast.hibernate0909.manytomany;import java.io.Serializable; import java.util.Set;public class Student implements Serializable{ private Long sid; p
Hibernate一对多，多对多操作
热门推荐
Marvel__Dead 胡艺宝的博客
03-16 1万+
表与表之间的关系一对多： 分类和商品关系，一个分类里面有多个商品，一个商品只能属于一个分类。 客户和联系人是一对多关系：联系人在人际交流中担任着重要的角色，在销售过程中，我们通常不是在最开始就联系到有决策权的高管，而有可能是接电话的前台A、营销人员B、客服C、技术人员D等等。这些人都是我们与企业保持交流的联系人。他们对产品的支持态度决定了产品是否能够顺利推送到高管面前。通常销售人员在跟进一个客户时，
Hibernate或者ssh三大框架中出现 XXXX is not mapped问题
Mr_li13的博客
12-13 5117
Hibernate或者ssh三大框架中出现 XXXX is not mapped问题 错误异常信息： org.springframework.orm.hibernate3.HibernateQueryException: loginUser is not mapped [from loginUser order by userId]; nested exception is org.hib
三大框架整合原理及详解<一>
Mr_li13的博客
12-13 3764
问题？三大框架整合原理及详解 提示：myeclipse环境、工程环境、tomcat环境的jdk保持一致（在这里我所使用的而是jdk1.6版本) 在这里我们调成1.6，并点击确定。 cmd:java -version  :查看jdk的版本 1.新建一个工程，把工程的编码为utf-8 2.首先是三大框架所需要的jar包,把jar包放入到工程中的lib下(下载链接：点击下载jar包
Struts2框架的搭建及配置文件的配置
Mr_li13的博客
10-25 2476
一、问题：Struts2框架的搭建，及jar包的使用， 二、Struts2简介（面试）面试资料及Struts2的介绍可下载资源: 三、搭建Struts2的开发环境 1、找到所需的jar包：官网下载(http://struts.apache.org/download.cgi#struts23241)struts-2.1.8.1-all(zip包）解压发行包的lib目录中（不同版本需要的最小
struts2中如何设置四大域对象
Mr_li13的博客
10-26 1928
问题！struts2中如何设置四大域对象 我们以案例来说明： struts.xml文件 /customer/error.jsp /scope.jsp cn.itcast.action.ScopeAction在这个类中写域对象的设置值 /** * */ package cn.itcast.action; impo
Hibernate一对多关联映射深度解析
在数据库层面，关系数据库通过外键机制来实现关联，通常是"many"方（Order）引用"one"方（Customer），以避免数据冗余，所以实际的数据库设计只支持多对一或一对一的单向关联，如图7-4所示。在Hibernate映射配置文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值