有关Hibrnate中inverse的配置

最新推荐文章于 2018-10-28 22:50:24 发布
最新推荐文章于 2018-10-28 22:50:24 发布
阅读量86 收藏
点赞数
分类专栏： Hibernate 文章标签： Hibernate C C++ C# Myeclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_13651/article/details/81678682
版权

1.现在假设有两个类Customer与Order，一个Customer可以有多个Order


2.如果在Customer.hbm.xml中设置inverse=true，那么代表customer与order的关系由order来维护，就是说如果采用Customer c=customerDao.findById("1"),c.getOrders.add(new Order()),那么在数据库层面表现为，首先假设在order表格中customer_id可以为空，那么上面的代码会在order表中重保存一条order记录，但是这条纪录中的customer_id=null，这正体现出inverse的设置作用，customer的保存不会维护ustomer与order之间的关系。

 

3.如果在Customer.hbm.xml中设置iverser=false，那么代表customer与order的关系由customer来维护，

还是采用2种说明的代码，那么在数据库中表现为会增加一条order记录，并且这条记录的customer_d不为空.

 

具体代码说明:

1.模型类

Java代码 复制代码
  1. public class Customer {   
  2.   
  3.     private String id;   
  4.   
  5.     private String name;   
  6.   
  7.     private Set orders = new HashSet();   
  8.   
  9.     public String getId() {   
  10.         return id;   
  11.     }   
  12.   
  13.     public void setId(String id) {   
  14.         this.id = id;   
  15.     }   
  16.   
  17.     public String getName() {   
  18.         return name;   
  19.     }   
  20.   
  21.     public void setName(String name) {   
  22.         this.name = name;   
  23.     }   
  24.   
  25.     public Set getOrders() {   
  26.         return orders;   
  27.     }   
  28.   
  29.     public void setOrders(Set orders) {   
  30.         this.orders = orders;   
  31.     }   
  32. }  
public class Customer {

	private String id;

	private String name;

	private Set orders = new HashSet();

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Set getOrders() {
		return orders;
	}

	public void setOrders(Set orders) {
		this.orders = orders;
	}
}

 

 

Java代码 复制代码
  1. public class Order {   
  2.   
  3.     private String id;   
  4.   
  5.     private Customer customer;   
  6.   
  7.     private String address;   
  8.   
  9.     public String getAddress() {   
  10.         return address;   
  11.     }   
  12.   
  13.     public void setAddress(String address) {   
  14.         this.address = address;   
  15.     }   
  16.   
  17.     public Customer getCustomer() {   
  18.         return customer;   
  19.     }   
  20.   
  21.     public void setCustomer(Customer customer) {   
  22.         this.customer = customer;   
  23.     }   
  24.   
  25.     public String getId() {   
  26.         return id;   
  27.     }   
  28.   
  29.     public void setId(String id) {   
  30.         this.id = id;   
  31.     }   
  32. }  
public class Order {

	private String id;

	private Customer customer;

	private String address;

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
}

 

 

1.配置文件

Java代码 复制代码
  1. <?xml version="1.0" encoding="utf-8"?>   
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">   
  4. <!--    
  5.     Mapping file autogenerated by MyEclipse - Hibernate Tools   
  6. -->   
  7. <hibernate-mapping>   
  8.     <class name="domain.Customer" table="customers" catalog="blogday">   
  9.         <id name="id">   
  10.             <column name="id" />   
  11.             <generator class="native"></generator>   
  12.         </id>   
  13.         <property name="name">   
  14.             <column name="name" length="20" />   
  15.         </property>   
  16.         <set name="orders" lazy="true" inverse="true" cascade="all">   
  17.             <key column="customer_id" />   
  18.             <one-to-many class="domain.Order" />   
  19.         </set>   
  20.     </class>   
  21. </hibernate-mapping>   
  22.    
<?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 - Hibernate Tools
-->
<hibernate-mapping>
	<class name="domain.Customer" table="customers" catalog="blogday">
		<id name="id">
			<column name="id" />
			<generator class="native"></generator>
		</id>
		<property name="name">
			<column name="name" length="20" />
		</property>
		<set name="orders" lazy="true" inverse="true" cascade="all">
			<key column="customer_id" />
			<one-to-many class="domain.Order" />
		</set>
	</class>
</hibernate-mapping>
 

 

Java代码 复制代码
  1. <?xml version="1.0" encoding="utf-8"?>   
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">   
  4. <!--    
  5.     Mapping file autogenerated by MyEclipse - Hibernate Tools   
  6. -->   
  7. <hibernate-mapping>   
  8.     <class name="domain.Order" table="orders" catalog="blogday">   
  9.         <id name="id">   
  10.             <column name="id" />   
  11.             <generator class="native"></generator>   
  12.         </id>   
  13.         <property name="address">   
  14.             <column name="address" length="20" />   
  15.         </property>   
  16.         <many-to-one name="customer" column="customer_id"  
  17.             class="domain.Customer" cascade="none" />   
  18.     </class>   
  19. </hibernate-mapping>  
<?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 - Hibernate Tools
-->
<hibernate-mapping>
	<class name="domain.Order" table="orders" catalog="blogday">
		<id name="id">
			<column name="id" />
			<generator class="native"></generator>
		</id>
		<property name="address">
			<column name="address" length="20" />
		</property>
		<many-to-one name="customer" column="customer_id"
			class="domain.Customer" cascade="none" />
	</class>
</hibernate-mapping>

 

3.测试代码

Java代码 复制代码
  1. public void testSaveOrdersByInverse_Error_Method() {   
  2.         Exception e = null;   
  3.         Customer c = customerDao.findById("1");   
  4.         Order order = new Order();   
  5.         Order order2 = new Order();   
  6.         c.getOrders().add(order2);   
  7.         c.getOrders().add(order);   
  8.         try {   
  9.             customerDao.save(c);   
  10.             customerDao.getHibernateTemplate().flush();   
  11.         } catch (Exception e1) {   
  12.             e = e1;   
  13.         }   
  14.         assertNotNull(e);   
  15.     }   
  16.        
public void testSaveOrdersByInverse_Error_Method() {
		Exception e = null;
		Customer c = customerDao.findById("1");
		Order order = new Order();
		Order order2 = new Order();
		c.getOrders().add(order2);
		c.getOrders().add(order);
		try {
			customerDao.save(c);
			customerDao.getHibernateTemplate().flush();
		} catch (Exception e1) {
			e = e1;
		}
		assertNotNull(e);
	}
	 

4. 结果说明

 

4.1  如果设置invserse=true,那么方法testSaveOrdersByInverse_Error_Method()在测试的时候

customerDao.getHibernateTemplate().flush()进行flush的时候会发生错误,错误原因是在order表格中

不允许customer_id=null,而在此时方法testSaveOrdersByInverse_Error_Method会级联保存order记录,但是保存的order记录中hibernate却设置customer_id=null,这也说明了inverse=true说明customer不负责与order之间的引用关系,只是简单的保存记录,并没有建立起二者之间的关系.

 

4.2如果设置inverse=false,说明customer与order之间的关系由customer来维护,那么上面的测试方法testSaveOrdersByInverse_Error_Method()不但会保存相应的order记录,并且order记录中的customer_id也不为空.

 

5.性能考虑

 

5.1 如果设置inverse=true,用如下代码测试

Java代码 复制代码
  1. public void testSaveOrdersByInverse_Right_method() {   
  2.         Exception e = null;   
  3.         Customer c = customerDao.findById("1");   
  4.         Order order1 = new Order();   
  5.         Order order2 = new Order();   
  6.         c.getOrders().add(order1);   
  7.         c.getOrders().add(order2);   
  8.         order1.setCustomer(c);   
  9.         order2.setCustomer(c);   
  10.         try {   
  11.             customerDao.save(c);   
  12.             customerDao.getHibernateTemplate().flush();   
  13.         } catch (Exception e1) {   
  14.             e = e1;   
  15.         }   
  16.         assertNull(e);   
  17.     }  
public void testSaveOrdersByInverse_Right_method() {
		Exception e = null;
		Customer c = customerDao.findById("1");
		Order order1 = new Order();
		Order order2 = new Order();
		c.getOrders().add(order1);
		c.getOrders().add(order2);
		order1.setCustomer(c);
		order2.setCustomer(c);
		try {
			customerDao.save(c);
			customerDao.getHibernateTemplate().flush();
		} catch (Exception e1) {
			e = e1;
		}
		assertNull(e);
	}

   测试结果为:

 

Java代码 复制代码
  1. Hibernate: select orders0_.customer_id as customer3_1_, orders0_.id as id1_, orders0_.id as id1_0_, orders0_.address as address1_0_, orders0_.customer_id as customer3_1_0_ from blogday.orders orders0_ where orders0_.customer_id=?   
  2. Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)   
  3. Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)  
Hibernate: select orders0_.customer_id as customer3_1_, orders0_.id as id1_, orders0_.id as id1_0_, orders0_.address as address1_0_, orders0_.customer_id as customer3_1_0_ from blogday.orders orders0_ where orders0_.customer_id=?
Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)
Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)

    说明没插入一条order只需要执行一次插入操作,没有额外的代码执行.

 

5.2 如果设置inverse=false,也顺便设置数据库中order表格中customer_id可以为空,这样下面的代码才不会 抛出错误

Java代码 复制代码
  1. public void testSaveOrdersByInverse_Error_Method() {   
  2.         Exception e = null;   
  3.         Customer c = customerDao.findById("1");   
  4.         Order order1 = new Order();   
  5.         Order order2 = new Order();   
  6.         c.getOrders().add(order1);   
  7.         c.getOrders().add(order2);   
  8.         try {   
  9.             customerDao.save(c);   
  10.             customerDao.getHibernateTemplate().flush();   
  11.         } catch (Exception e1) {   
  12.             e = e1;   
  13.         }   
  14.         assertNull(e);   
  15.     }  
public void testSaveOrdersByInverse_Error_Method() {
		Exception e = null;
		Customer c = customerDao.findById("1");
		Order order1 = new Order();
		Order order2 = new Order();
		c.getOrders().add(order1);
		c.getOrders().add(order2);
		try {
			customerDao.save(c);
			customerDao.getHibernateTemplate().flush();
		} catch (Exception e1) {
			e = e1;
		}
		assertNull(e);
	}

 测试结果:

Java代码 复制代码
  1. Hibernate: select customer0_.id as id0_0_, customer0_.name as name0_0_ from blogday.customers customer0_ where customer0_.id=?   
  2. Hibernate: select orders0_.customer_id as customer3_1_, orders0_.id as id1_, orders0_.id as id1_0_, orders0_.address as address1_0_, orders0_.customer_id as customer3_1_0_ from blogday.orders orders0_ where orders0_.customer_id=?   
  3. Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)   
  4. Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)   
  5. Hibernate: update blogday.orders set customer_id=? where id=?   
  6. Hibernate: update blogday.orders set customer_id=? where id=?  
Hibernate: select customer0_.id as id0_0_, customer0_.name as name0_0_ from blogday.customers customer0_ where customer0_.id=?
Hibernate: select orders0_.customer_id as customer3_1_, orders0_.id as id1_, orders0_.id as id1_0_, orders0_.address as address1_0_, orders0_.customer_id as customer3_1_0_ from blogday.orders orders0_ where orders0_.customer_id=?
Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)
Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)
Hibernate: update blogday.orders set customer_id=? where id=?
Hibernate: update blogday.orders set customer_id=? where id=?

 

 

插入customer也会相应的插入order记录,这个在上面已经说明.但是看这里多出了两条update语句,针对每一个孩子都去更新父亲的id明显速度很慢，因为父亲有个孩子的集合，他无法知道哪个孩子的父亲id已经指向自己了,所以对于每一个孩子,都要更新父亲使他只想自己，而这个关系由孩子维护就好多了，每个孩子只有一个父亲，只有设置过的才需要更新，所以显然，这个父子关系由孩子来维护比较省力.减轻了数据库的负担.

 

 

正对以上情况在设置one-many或者many-one或者many-many的时候需要谨慎用inverse,而且从性能上来说一般还是有字节点来维护与父节点的关系比较好如下代码就可以简单而且高效来建立二者之间的关系.

 

Java代码 复制代码
  1. public void testSave() {   
  2.     Customer customer = customerDao.findById("1");   
  3.     Order order = new Order();   
  4.     order.setCustomer(customer);   
  5.     orderDao.save(order);   
  6.     assertNotNull(order.getId());   
  7. }  
	public void testSave() {
		Customer customer = customerDao.findById("1");
		Order order = new Order();
		order.setCustomer(customer);
		orderDao.save(order);
		assertNotNull(order.getId());
	}

 

这里的操作很简单而且数据库操作也仅有一条查询语句和一条插入语句.

 

Java代码 复制代码
  1. Hibernate: select customer0_.id as id0_0_, customer0_.name as name0_0_ from blogday.customers customer0_ where customer0_.id=?   
  2. Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)  
Hibernate: select customer0_.id as id0_0_, customer0_.name as name0_0_ from blogday.customers customer0_ where customer0_.id=?
Hibernate: insert into blogday.orders (address, customer_id) values (?, ?)

 

 

 

 

iteye_13651
关注
专栏目录
在 Hibernate 中inverse的属性
DreamChaser_gf的博客
10-25 846
**** hibernate配置文件中有这么一个属性inverse，它是用来指定关联的控制方的。 inverse属性默认是false，若为false，则关联由自己控制，若为true，则关联 由对方控制。**** Inverse和cascade是Hibernate映射中最难掌握的两个属性。两者都在对象的关联操作中发挥作用。 1．明确inverse和cascade的作用 inverse 决定是否把对...
浅谈hibernate中多表映射关系配置
08-30
在映射配置中，这种关系通常在“一”的一方进行配置，使用`<set>`标签，其中`inverse`属性用于指定是否由当前实体维护关联关系。如果`inverse="true"`，表示不维护关联，通常选择在“多”的一方放弃维护，以避免冗余...
闲聊hibernate的inverse的引入
技术收藏
10-26 629
 Inverse是hibernate双向关系中的基本概念，深刻理解inverse在hibernate中的含义对于掌握hibernate至关重要。在讨论inverse之前，先说说一些闲话，侃侃hibernate怎样处理对象间的一对多或者对多对关系。这些闲话的前提假设是正确的设置了inverse。看下面的代码：//TestA.java[/code]package org.hibernate.a
Hibernate inverse 字段
月之神
10-20 429
inverse常用于一对多双向关联关系中。 以Student（学生）和Class（班级）为例，它们之间的关系为一对多的关系，即一个学生只能属于一个班级，一个班级可以包含多个学 生。 学生类定义代码： Class Student{ private int id; private String name; private Class class; //省略getter()和setter()方法 } 班级类定义代码： Class Class{ private int
Hibernate 一对多配置实例（inverse）
写博客只为学习
04-11 1208
HIBERNATE一对多配置实例 1.环境：假定班级和学生是一对多的关系，班级是一，学生是多，对应表格分别是：zlass ,student 2.创建Zlass和Student对象 public class Zlass{ private String class_id; private String class_name; private java.util.Set stude
Hibernate inverse属性与cascade属性
孤独正患者的专栏
06-04 988
理解： inverse属性为false的那一端，拥有管理关系维护的权利 cascade属性指级联，说的通俗点，在cascade那端指定的操作，会影响到所关联的对象 举个例子： 班级和学生的关系是一对多 班级class类包含id，名称和学生的Set集合 学生student类包含id，姓名和班级的id（外键） cascade属性：学生是依赖班级存在的，班级不存在，
Hibernate 控制反转(Inverse 详解)
u013488838的专栏
11-27 3286
接触Hibernate已经很久了,一直在copy代码,从来没有进行过具体分析配置的参数 何为控制反转, 比如 Poeple(人) 和 Address(地址)  :一个人可以拥有多个地址,那么在配置的时候 在Poeple.hbm,xml 中 设置 one-To-Many (先不考虑Address配置文件) 那么Ok 当我们向People对象 添加 新的地址时  调用代码  People p =
hibernate配置文件中inverse的作用
如的博客
03-05 305
inverse常用于一对多双向关联关系中。以Student（学生）和Class（班级）为例，它们之间的关系为一对多的关系，即一个学生只能属于一个班级，一个班级可以包含多个学生。学生类定义代码：Class Student{ private int id; private String name; private Class class; //省略getter()和setter()方法}班级类...
Hibernate 配置文件中 inverse 讲解
杰哥一号号的博客
05-03 430
1、含义：inverse="true"就是反转控制器=真；也就是由对方控制，inverse="false"就是反转控制器=假；也就是不用对方控制，由自己控制2、到底在哪用inverse="ture"?      “set的inverse属性决定是否把对set的改动反映到数据库中去。inverse=false————反映；inverse=true————不反映”inverse属性默认为false  ...
hibernate xml配置中的inverse属性
Niexiaoya的博客
10-28 393
一、Inverse是hibernate双向关系中的基本概念。inverse的真正作用就是指定由哪一方来维护之间的关联关系。当一方中指定了“inverse=false”（默认），那么那一方就有责任负责之间的关联关系，说白了就是hibernate如何生成Sql来维护关联的记录！ Hibernate仅仅按照主控方对象的状态的变化来同步更新数据库。按照原来的映射文件，people.getAddresse...
hibernate inverse和cascade的详细讲解
10-01
在这些配置选项中，`inverse`和`cascade`是最具挑战性的两个概念之一。它们主要用于控制对象之间关联关系的维护以及操作的级联行为。本文将详细介绍这两个属性的概念、作用以及应用场景，并通过示例来帮助读者更好地...
hibernate之一对多配置demo
07-19
在XML配置中，我们可以设置级联属性： ```xml ``` 这里`cascade="all-delete-orphan"`表示级联所有操作，包括删除孤儿（即当一个班级被删除时，其关联的学生也将被删除）。 四、总结 通过本教程，你可以了解...
Hibernate中cascade与inverse属性详解
09-11
在 Hibernate 框架中，`cascade` 和 `inverse` 是两个非常重要的属性，它们用于管理对象之间的关联关系。...在实际开发中，需要根据业务需求灵活调整 `cascade` 和 `inverse` 的配置，以达到最佳的数据管理和性能优化。
Session缓存
风之影
01-15 135
缓存是位于应用程序与物理数据源之间，用于临时存放复制数据的内存区域，目的是为了减少应用程序对物理数据源访问的次数，从而提高应用程序的运行性能.   Hibernate在查询数据时，首先到缓存中去查找，如果找到就直接使用，找不到的时候就会从物理数据源中检索，所以，把频繁使用的数据加载到缓存区后，就可以大大减少应用程序对物理数据源的访问，使得程序的运行性能明显的提升.   Hibernate缓存分类：...
Hibernate多对多删除
风之影
01-19 99
Hibernate多对多的例子不少，但仔细一看，大多数都是保存的，删除谈的少，但问题还不少，因此有必须简单测试一下，以下我们来个简单的多对多关系建立 老师Teacher 与 课程Course 是一个多对多的关系，Pojo与XMl配置如下。   Pojo Java代码 /**    * Course Entity    * see table: tbl_course    */  ...
Join用法，HQL的方法，Hibernate中的fetch
风之影
02-01 96
Join用法，HQL的方法，Hibernate中的fetch Join用法: 主要有Inner Join 及 Outer Join:   最常用的（默认是Inner）： Select &lt;要选择的字段&gt; From &lt;主要资料表&gt; 　　&lt;Join 方式&gt; &lt;次要资料表&gt; [On &lt;Join 规则&gt;] Inner Jo...
hibernate对象的三种状态
风之影
04-03 88
Hibernate的透明持久化用起来非常舒服，有时甚至忘记了数据库的存在。我身边的朋友经常会分不清save、saveOrUpdate、update的区别，lock、merge、replicate、refresh、evict甚至不知道是干什么用的。而且关于实体对象的生命周期也有很多概念不清，分不清transient、persistent、detached的区别，只是知道PO、VO这样的通俗叫法。其实...
Hibernate中表关联配置详解
"本文将详细介绍Hibernate中表之间的关联关系配置，包括many-to-many关联关系的建立以及在配置文件中的体现。" 在Java开发中，Hibernate是一个强大的对象关系映射（ORM）框架，它允许开发者用面向对象的方式来操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值