Hinernate一对双向映射

最新推荐文章于 2019-05-05 21:26:01 发布
原创 最新推荐文章于 2019-05-05 21:26:01 发布 · 790 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了使用Java ORM框架Hibernate进行数据库连接配置，并展示了如何实现一对多关系操作，包括保存、更新、删除等关键操作。

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>
	<!-- 
		驱动
	-->
	<property name="connection.driver_class">
		com.mysql.jdbc.Driver
	</property>
	<!-- 
		url
	-->
	<property name="connection.url">
		jdbc:mysql://localhost:3306/hibernate0909
	</property>
	<!-- 
		username
	-->
	<property name="connection.username">root</property>
	<!-- 
		password
	-->
	<property name="connection.password"> </property>
	<!-- 
		hibernate针对建表的操作
		update  如果有表，检查表的结构，如果没有则创建
		create-drop 启动hibernate创建表，结束hibernate删除表
		create  每次启动都重新创建表
		validate 每次启动都检查表的结构
	-->
	<property name="hbm2ddl.auto">update</property>
	<property name="show_sql">true</property>
	<mapping
		resource="cn/itcast/hibernate0909/onetomany/doubl/Classes.hbm.xml" />
	<mapping
		resource="cn/itcast/hibernate0909/onetomany/doubl/Student.hbm.xml" />
</session-factory>
</hibernate-configuration>

Classes.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">
<!-- 
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="cn.itcast.hibernate0909.onetomany.doubl.Classes">	
    	<id name="cid" type="java.lang.Long" length="5">
    		<column name="cid"></column>
    		<generator class="increment"></generator>
    	</id>
    	
    	<property name="cname" type="java.lang.String" length="20"></property>
    	<property name="description" type="java.lang.String" length="100"></property>
    	<!-- 
    		cascade指的是对象对对象的操作
    		inverse指的是对象对关系的操作
    	 -->	
    	<set name="students" cascade="all" inverse="false">
    		<key>
    			<!-- 
    				通过classes建立与student之间的联系
    			 -->
    			<column name="cid"></column>
    		</key>
    		<one-to-many class="cn.itcast.hibernate0909.onetomany.doubl.Student"/>
    	</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">
<!-- 
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="cn.itcast.hibernate0909.onetomany.doubl.Student">	
    	<id name="sid" type="java.lang.Long" length="5">
    		<column name="sid"></column>
    		<generator class="increment"></generator>
    	</id>
    	
    	<property name="sname" type="java.lang.String" length="20"></property>
    	<property name="description" type="java.lang.String" length="100"></property>
    	<!-- 
    		多对一
    		   注意：在many-to-one中没有inverse属性
    		     	对student表的修改本身就是维护外键
    	 -->
    	<many-to-one name="classes" class="cn.itcast.hibernate0909.onetomany.doubl.Classes" cascade="all">
    		<!-- 
    			外键
    			   描述了通过student建立与classes之间的联系
    		 -->
    		<column name="cid"></column>
    	</many-to-one>
    </class>
</hibernate-mapping>


public class Classes implements Serializable{
	private Long cid;
	private String cname;
	private String description;
	
	public String getDescription() {
		return description;
	}

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

	private Set<Student> 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 Set<Student> getStudents() {
		return students;
	}

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


public class Student implements Serializable{
	private Long sid;
	private String sname;
	public String getDescription() {
		return description;
	}

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

	private String description;
	
	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 Classes getClasses() {
		return classes;
	}

	public void setClasses(Classes classes) {
		this.classes = classes;
	}

	private Classes classes;
}


/**
 * 1、保存班级
 * 2、保存学生
 * 3、保存班级的时候同时保存学生
 * 4、保存班级的时候同时保存学生，并且建立班级和学生之间的关系
 * 5、已经存在一个班级，新建一个学生，并且建立该学生和该班级之间的关系
 * 6、已经存在一个学生，新建一个班级，并且建立该学生和该班级之间的关系
 * 7、已经存在一个学生，已经存在一个班级，解除该学生和原来班级之间的关系，建立该学生和新班级之间的关系
 * 8、已经存在一个学生，解除该学生和该学生所在班级之间的关系
 * 9、解除该班级和所有的学生之间的关系，再重新建立该班级和一些新的学员之间的关系
 * 10、解除该班级和所有的学生之间的关系
 * 11、删除班级
 *      *
 *      	*  解除该班级和所有的学生之间的关系
 *      	*  删除该班级
 *      *   
 *          删除班级的同时删除学生
 * 12、删除学生
 *      同删除班级
 * @author Administrator
 *
 */
public class OneToManyDoubleTest {
	private static SessionFactory sessionFactory = null;
	static{
		Configuration  configuration = new Configuration();
		configuration.configure("cn/itcast/hibernate0909/onetomany/doubl/hibernate.cfg.xml");
		sessionFactory = configuration.buildSessionFactory();
	}
	/**
	 * 保存班级的时候同时保存学生
	 * 		Hibernate: select max(cid) from Classes
			Hibernate: select max(sid) from Student
			Hibernate: insert into Classes (cname, description, cid) values (?, ?, ?)
			Hibernate: insert into Student (sname, description, cid, sid) values (?, ?, ?, ?)
			Hibernate: update Student set cid=? where sid=?
			    	更新外键
		说明：
		  classes.setStudents(students);  通过classes来维护关系 ，要发出update语句，更新外键 
	 */
	@Test
	public void testSaveClasses_Cascade_S(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Classes classes = new Classes();
		classes.setCname("aaaa");
		classes.setDescription("asdffd");
		Student student = new Student();
		student.setSname("李克强");
		student.setDescription("tttttt");
		Set<Student> students = new HashSet<Student>();
		students.add(student);
		//通过classes建立classes与students之间的关系
		classes.setStudents(students);
		//通过student建立classes与students之间的关系
		//student.setClasses(classes);
		session.save(classes);
		transaction.commit();
		session.close();
	}
	/**
	 * 	Hibernate: select max(sid) from Student
		Hibernate: select max(cid) from Classes
		Hibernate: insert into Classes (cname, description, cid) values (?, ?, ?)
		Hibernate: insert into Student (sname, description, cid, sid) values (?, ?, ?, ?)
	 		student.setClasses(classes);通过student来维护classes
	 		 对student的增、删、改本身就是对外键的操作，所以这里不再发出update语句
	 	    一对多，多的一方维护关系，效率比较高
	 */
	@Test
	public void testSaveStudent_Cascade_C(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Classes classes = new Classes();
		classes.setCname("aaaa");
		classes.setDescription("asdffd");
		Student student = new Student();
		student.setSname("李克强");
		student.setDescription("tttttt");
		Set<Student> students = new HashSet<Student>();
		students.add(student);
		//通过classes建立classes与students之间的关系
		//classes.setStudents(students);
		//通过student建立classes与students之间的关系
		student.setClasses(classes);
		session.save(student);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 已经存在一个班级，新建一个学生，并且建立该学生和该班级之间的关系
	 */
	@Test
	public void testSaveStudent_R(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Classes classes = (Classes)session.get(Classes.class, 1L);
		Student student = new Student();
		student.setSname("里活命");
		student.setDescription("ufo");
		//通过student建立classes与student的关系
		student.setClasses(classes);
		session.save(student);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 已经存在一个学生，新建一个班级，并且建立该学生和该班级之间的关系
	 *   通过分析：
	 *      *  因为存在建立关系的操作，所以操作学生端效率比较高
	 *      *  在这里存在保存班级的操作，所以应该是通过更新学生级联保存班级
	 */
	@Test
	public void testUpdateStudent_CasCade(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Student student = (Student)session.get(Student.class, 2L);
		Classes classes = new Classes();
		classes.setCname("传智播客集团部");
		classes.setDescription("都是高官");
		student.setClasses(classes);
		session.save(classes);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 已经存在一个学生，已经存在一个班级，解除该学生和原来班级之间的关系，建立该学生和新班级之间的关系
	 */
	@Test
	public void testRebuild_R(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Student student = (Student)session.get(Student.class, 2L);
		Classes classes = (Classes)session.get(Classes.class, 1L);
		student.setClasses(classes);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 已经存在一个学生，解除该学生和该学生所在班级之间的关系
	 */
	@Test
	public void testRealse_R(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Student student = (Student)session.get(Student.class, 2L);
		student.setClasses(null);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 解除该班级和所有的学生之间的关系，再重新建立该班级和一些新的学员之间的关系
	 */
	@Test
	public void testRealse_Rebuild_R(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		/**
		 * 1、获取班级
		 * 2、获取该班级的所有的学生
		 * 3、遍历学生，把学生的班级设置为null
		 * 4、新建两个学员
		 * 5、建立两个学员与班级之间的关系
		 */
		Classes classes = (Classes)session.get(Classes.class, 1L);
		Set<Student> students = classes.getStudents();
		for(Student student:students){
			student.setClasses(null);
		}
		Student student = new Student();
		student.setSname("王二麻子");
		student.setDescription("爷们");
		Student student2 = new Student();
		student2.setSname("王二麻子的哥");
		student2.setDescription("爷们的哥");
		//student.setClasses(classes);
		//student2.setClasses(classes);
		students.add(student);
		students.add(student2);
		/**
		 * 当发生transaction.commit的时候，hibernate内部会检查所有的持久化对象
		 *   会对持久化对象做一个更新,因为classes是一个持久化状态的对象，所以hibernate
		 *   内部要对classes进行更新，因为在classes.hbm.xml文件中<set name="students" cascade="all" inverse="true">
		 *   意味着在更新classes的时候，要级联操作student,而student是一个临时状态的对象
		 *   所以要对student进行保存，在保存student的时候，就把外键更新了
		 */
		transaction.commit();
		session.close();
	}
	
	/**
	 * 解除该班级和所有的学生之间的关系
	 */
	@Test
	public void testRealseAll_R(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Classes classes = (Classes)session.get(Classes.class, 1L);
		Set<Student> students = classes.getStudents();
		for(Student student:students){
			student.setClasses(null);
		}
		transaction.commit();
		session.close();
	}
	/**
	 * 先解除关系，再删除班级
	 */
	@Test
	public void testDeleteClass_1(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Classes classes = (Classes)session.get(Classes.class, 1L);
		Set<Student> students = classes.getStudents();
		for(Student student:students){
			student.setClasses(null);
		}
		session.delete(classes);
		transaction.commit();
		session.close();
	}
	
	/**
	 * 在删除班级的时候，同时删除整个班级的学生
	 */
	
	/**
	 * 删除学生
	 *    直接删除学生即可
	 */
	
	@Test
	public void teetst(){
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Classes classes = (Classes)session.get(Classes.class, 1L);
		Set<Student> students = classes.getStudents();
		for(Student student:students){
				student.setClasses(null);
				break;
		}
		transaction.commit();
		session.close();
	}
}

一对多的操作：

   * hibernate是通过客户端的代码参照映射文件来决定怎么样去数据库进行操作

   * 一对多的双向：既能通过Classes.hbm.xml文件联系到student,也能通过student.hbm.xml文件联系到

      classes,在类中也要体现双向的关系

   * session.save/update(classes)，hibernate内部会参照classes.hbm.xml文件，这个时候student.hbm.xml

      映射文件不起作用，反之也成立

   * 在hibernate一对多的关系中，只有一的一端的set集合中有inverse属性，多的一端没有inverse属性

   * 在hibernate中，inverse属性和数据库的外键对应

   * 在Classes.hbm.xml文件中，set集合，inverse的值如果为true,说明classes放弃关系的维护，如果为false,

      则负责维护关系，但是多的一方维护关系效率比较高

   *　cascade说明指的是对象与对象之间的操作，和外键没有关系

   * 处于持久化状态的对象在session中，在客户端不需要做session.save/update操作，hiernate内部会自动去检查

     持久化状态的对象的属性是否发生改变，如果改变则发出update语句，如果没有改变则不会发出update语句。如果

     该对象是一的一方，在一的一方的映射文件中有cascade="all"时，hibernate内部还会检查该持久化对象关联的

     集合，对此集合做update/save操作。但是整个操作和外键没有关系。只有当通过多的一方建立关系以后，才能使

      外键有值

   * 一般一对多设计到关系的维护，都是通过多的一方来操作的


AutoMapper双向映射的艺术
m0_62153576的博客
06-19 36
双向映射指的是可以从源对象映射到目标对象，并且可以从目标对象回映射到源对象。在AutoMapper中，这通常涉及到定义映射关系和处理自定义值转换。
一对一双向关联映射
10-31
Hibernate的映射策略：一对一双向关联映射，有所有的测试用例，用以证明从任何一端都可以加载另一端信息。
一对多单向和双向映射
07-26
NULL 博文链接：https://quicker.iteye.com/blog/657795
ESBasic 可复用的.NET类库（11） －－ 双向映射 IBidirectionalMapping
zhuweisky
10-15 1076
1.缘起：    假设我们的用户管理系统要求用户的ID和Name都必须是唯一的，并且用户的ID和Name一经确定就不能被修改。而且管理系统经常需要根据ID来查找Name，也经常需要根据Name来查找ID。根据这样的需求，我们可以考虑使用一个Dictionary来将ID和Name缓存起来，通常ID作为Key，Name作为Value。这样便可实现通过ID查询Name的快速查找，但是，通过
一对多关联映射(双向)
yenairong的博客
02-05 435
一对多双向，从实体类上讲究是在“多”的一端持有“一”的实例，并在配置文件中用&lt;many-to-one&gt;标签将其配置上。这里有一点要特别注意，当两边都能够维护关系的时候，推荐让“多”的一端来做，做法上就是在“一”一端映射文件的&lt;set&gt;标签中设置属性inverse="true"。另外，&lt;key&gt;中为“多”一端表设置的外键要和&lt;many-to-one&gt...
Nhibernate一对多级联保存_双向映射[归类].pdf
10-11
在Nhibernate中，一对...总结来说，Nhibernate中的一对多级联保存和双向映射是用于管理复杂对象关系的重要特性。通过恰当的注解配置，可以实现父对象与子对象的自动保存和关系导航，简化了ORM的使用，提升了开发效率。
Hibernate双向关联教程：一对多与多对一关系映射
标签“一对多双向 Hibernate”强调了教程内容的核心是通过Hibernate实现一对多关系的双向映射。这种映射方式除了上述提到的集合和引用的设置，还包括了注解（如@OneToMany和@ManyToOne）和XML映射文件的配置，以确保...
Hibernate ORM关系映射详解：一对一、一对多、多对多关联
"hibernate相关文档，包括hibernate API、注解以及对象关系映射（ORM）原理，涵盖了各种关联映射的实例" 在Java持久化框架Hibernate中，对象关系映射（ORM）是其核心特性，允许开发者将数据库中的表与Java对象进行...
Hibernate关联映射深入理解：cascade与inverse详解
在Hibernate中，通过映射文件来定义实体间的关联关系，可以是单向的也可以是双向的。常见的关联关系类型有： - 一对一（One-to-One） - 一对多（One-to-Many） - 多对一（Many-to-One） - 多对多（Many-to-Many） #...
Hibernate关联映射：多对多关系
# 1. 理解Hibernate关联映射 Hibernate是一个开源的对象关系映射框架，被广泛应用于Java语言中。在实际的软件开发中，使用Hibernate进行关联映射是非常常见的操作，能够帮助...通过关联映射，可以在对象之间建立一对
双向一对多映射
lky888666的博客
07-25 395
1.many端和多对一关系时一致 package com.hibernate.entities.n21both; public class Order { private Integer orderId; private String orderName; private Customer customer; public Integer getOrderId() { r...
组件中双向映射
H华华的博客
05-28 458
组件中双向映射
Hibernate学习之双向一对多映射（双向多对一映射）
weixin_30838921的博客
06-13 275
© 版权声明：本文为博主原创文章，转载请注明出处 1.双向映射与单向映射 　　- 一对多单向映射：由一方（教室）维护映射关系，可以通过教室查询该教室下的学生信息，但是不能通过学生查询该学生所在教室信息； 　　　　　　　　　　　　删除教室时可以级联删除该教室下的所有学生信息。 　　- 多对一单向映射：由多方（学生）维护映射关系，可以通过学生查询该学生所在的教室信息，但是不能通过教室查询该教室...
Hibernate：双向映射案例
燕双嘤
05-05 288
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property n..
关于一对多双向映射
遗忘的千年
11-17 164
一对多双向映射 一对多双向关联 *在一的一端使用 在对方的表中中加入一个外键指向一的一端 *在多的一端使用 *注意和指定的外键名一定要相同则会出现错误 如果在一的一端维护关联关系 在save对象的时候会添加多余的update语句 所以我们一般用inverse将关系反转 在多的一端维护关联关系。 关于inverse属性： invers...
双向多对一映射关系
qq_36430463的博客
03-31 315
两个实体类public class Grade implements Serializable { private int gid; private String gname; private String gdesc; //在"一"方定义"多"方的集合 private Set<Student> students=new HashSet<Student>();
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值