`

一对多/多对一 cascade属性 inverse属性 随记

阅读更多
基本配置操作:http://yafei.iteye.com/blog/799999
inverse属性:http://www.iteye.com/topic/2633
inverse属性及hibernate其它知识(易理解):http://www.javaworld.com.tw/confluence/pages/viewpage.action?pageId=3479
	<class name="org.onetomany.bo.Child" table="CHILD">    
                <id name="id" column="ID" type="integer">    
                    <generator class="sequence">
						<param name="sequence">SEQ_ID</param>
					</generator>    
                </id>    
        <many-to-one name="parent" class="org.onetomany.bo.Parent" cascade="save-update"  column="PARENTID"/>    
    </class>    
    <class name="org.onetomany.bo.Parent" table="PARENT">    
                <id name="parentId" column="PARENTID" type="integer">    
                    <generator class="sequence">
						<param name="sequence">SEQ_PAERENTID</param>
					</generator>      
                </id>    
        <bag name="child"  inverse="true" cascade="all">    
             <key column="PARENTID"/>    
             <one-to-many class="org.onetomany.bo.Child"/>    
        </bag>    
    </class> 


		Session s=null;
		Transaction tx=null;
		try{
			s=HibernateSessionFactory.getSession();
			tx=s.beginTransaction();    //hibernate的事务默认是关闭的,我们必须把他打开。
			
			Parent parent = new Parent();
            Child child = new Child();  
            Child child2 = new Child();  
            Child child3 = new Child();  
            List list = new ArrayList();    
            list.add(child);   
            list.add(child2);
            list.add(child3);
            parent.setChild(list);   
            System.out.println("dddddddddddddddddddddddddddddddddddddddddddddddddddddd");  
            
            child.setParent(parent);
            child2.setParent(parent);
            child3.setParent(parent);   
            s.save(child);;    
            s.flush();;    
            System.out.println("llllllllllllllllllllllllllll");   
			tx.commit();
		}catch(HibernateException e){
			if(tx!=null){
				tx.rollback();
			}
			throw e;
		}finally{
			if(s!=null){
				s.close();
			}
		}

cascade属性: 
去掉parent里的cascade="all"

Hibernate: select SEQ_PAERENTID.nextval from dual
Hibernate: insert into PARENT (PARENTID) values (?)
dddddddddddddddddddddddddddddddddddddddddddddddddddddd
Hibernate: select SEQ_ID.nextval from dual
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
ID          PARENTID   
----------- -----------   
         74           19  

不不去掉parent里的[color=red]cascade="all"

dddddddddddddddddddddddddddddddddddddddddddddddddddddd
Hibernate: select SEQ_ID.nextval from dual
Hibernate: select SEQ_PAERENTID.nextval from dual
Hibernate: select SEQ_ID.nextval from dual
Hibernate: select SEQ_ID.nextval from dual
Hibernate: insert into PARENT (PARENTID) values (?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
llllllllllllllllllllllllllll
ID          PARENTID   
----------- -----------   
         74           19   
         75           19  
         76           19

去掉parent里的[color=red]inverse="true" 属性
dddddddddddddddddddddddddddddddddddddddddddddddddddddd
Hibernate: select SEQ_ID.nextval from dual
Hibernate: select SEQ_PAERENTID.nextval from dual
Hibernate: select SEQ_ID.nextval from dual
Hibernate: select SEQ_ID.nextval from dual
Hibernate: insert into PARENT (PARENTID) values (?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
Hibernate: update CHILD set PARENTID=? where ID=?
Hibernate: update CHILD set PARENTID=? where ID=?
Hibernate: update CHILD set PARENTID=? where ID=?
llllllllllllllllllllllllllll
ID          PARENTID   
----------- -----------   
         74           19   
         75           19  
         76           19

多了三次update ,存在性能问题

改成如下代码:
Session s=null;
		Transaction tx=null;
		try{
			s=HibernateSessionFactory.getSession();
			tx=s.beginTransaction();    //hibernate的事务默认是关闭的,我们必须把他打开。
			
			Parent parent = new Parent();;    
            Child child = new Child();;    
            Child child2 = new Child();;    
            List list = new ArrayList();;    
            list.add(child);;    
            list.add(child2);;    
            parent.setChild(list);;    
            s.save(parent);;    
            s.flush();;    
            System.out.println("dddddddddddddddddddddddddddddddddddddddddddddddddddddd"); ;    
            Child child3 = new Child();;  
            child3.setParent(parent);;  
//            child.setParent(parent);
//            child2.setParent(parent);
            s.save(child3);;  
//            s.save(child);;
//            s.save(child2);;
            System.out.println("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); ;    
			tx.commit();
		}catch(HibernateException e){
			if(tx!=null){
				tx.rollback();
			}
			throw e;
		}finally{
			if(s!=null){
				s.close();
			}
		}	


去掉parent里的[color=red]inverse="true" 属性
Hibernate: select SEQ_PAERENTID.nextval from dual
Hibernate: select SEQ_ID.nextval from dual
Hibernate: select SEQ_ID.nextval from dual
Hibernate: insert into PARENT (PARENTID) values (?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
Hibernate: update CHILD set PARENTID=? where ID=?
Hibernate: update CHILD set PARENTID=? where ID=?
dddddddddddddddddddddddddddddddddddddddddddddddddddddd
Hibernate: select SEQ_ID.nextval from dual
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
ID          PARENTID   
----------- -----------   
         74           19   
         75           19  
         76           19


不去掉parent里的[color=red]inverse="true" 属性
Hibernate: select SEQ_PAERENTID.nextval from dual
Hibernate: select SEQ_ID.nextval from dual
Hibernate: select SEQ_ID.nextval from dual
Hibernate: insert into PARENT (PARENTID) values (?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)
dddddddddddddddddddddddddddddddddddddddddddddddddddddd
Hibernate: select SEQ_ID.nextval from dual
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Hibernate: insert into CHILD (PARENTID, ID) values (?, ?)

ID          PARENTID   
----------- -----------   
         74           -   
         75           -  
         76           19

分享到:
评论

相关推荐

    Hibernate中cascade与inverse属性详解

    Hibernate中cascade与inverse属性详解

    hibernate 级联(cascade和inverse)一对多

    在一对多关系中,如果一个实体(父实体)与多个实体(子实体)关联,设置级联属性可以确保在处理父实体时,子实体的操作也会随之进行。例如,当删除父实体时,可以选择是否同时删除所有子实体。Hibernate提供了多种...

    hibernate inverse和cascade的详细讲解

    - **多对多**:例如,一个`Student`和多个`Course`课程的关系,`inverse`属性通常放在独立的关系表中,并且只能在一方设置为`true`,另一方为`false`,以确保关系的正确维护。 #### 三、Cascade 属性详解 `cascade...

    关于cascade和inverse属性[文].pdf

    在软件网络技术领域,尤其是在使用Hibernate这种对象关系映射(ORM)框架时,理解和正确使用`cascade`和`inverse`属性至关重要。这两个属性主要用于管理对象之间的关联关系,特别是如何在数据库中维护这些关系。 ...

    NHibernate Inverse & Cascade

    在一对多或多对一的关系中,当一个实体引用另一个实体时,通常会有一个主实体和一个从属实体。默认情况下,NHibernate认为主实体负责维护关联关系。然而,设置`inverse="true"`可以将责任转移给从属实体。 例如,...

    inverse和cascade使用阐述

    在数据库设计中,当我们在两个表之间建立一对多或者多对一的关系时,可能会涉及到“inverse”概念。例如,一个部门可以有多个员工,而一个员工只属于一个部门。这种情况下,员工表通常会有一个外键指向部门表。如果...

    JavaEE学习笔记之Hibernate表关系之一对多(inverse详解)

    本文将深入探讨Hibernate中的一对多关系,并重点解析`inverse`属性的作用及其应用。 一对多关系是数据库设计中常见的关联类型,例如一个用户可以拥有多个订单,一个班级可以包含多个学生等。在Hibernate中,通过...

    hibernate基于主外键的一对多/多对一关联

    在一对一或多对一的关联中,`mappedBy`属性应该放在拥有外键的一方,表示由这一方来维护关系。例如,在上述的User和Order例子中,`@OneToMany(mappedBy = "user")`应该放在User类的orders属性上。 最后,当我们使用...

    Hibernate中cascade和inverse应用

    在 Hibernate 框架中,`cascade` 和 `inverse` 是两个重要的概念,它们主要用于管理对象之间的持久化关系,特别是涉及到一对一(one-to-one)、一对多(one-to-many)和多对多(many-to-many)关系时。这两个属性都...

    关联映射cascade,inverse讲解

    例如,一个用户可能有多个订单,这种一对多的关系就可以通过关联映射来实现。关联映射可以通过XML配置文件或注解完成,确保对象间的关联能够在数据库层面得到正确的反映。 接下来,我们详细探讨“cascade”。...

    hibernate知识复习三:关联映射:一对多/多对一

    本文将深入探讨Hibernate中的关联映射,特别是“一对多”和“多对一”的关系映射,这对于理解如何在Java应用程序中处理复杂的数据库交互至关重要。 一、Hibernate简介 Hibernate是Java平台上的一个开源ORM框架,它...

    hibernate集合映射inverse和cascade详解.txt

    在Hibernate中,`inverse`属性主要用于多对一或一对多的关系中,用于指定哪一方负责维护关系。当两个实体之间存在关联时,如果一方的集合变更,那么另一方的实体可能也需要更新。这时,`inverse`属性就变得尤为重要...

    Hibenate cascade

    默认情况下,一对多或多对多关系的两端都会维护关联关系,即两者都可以触发对关系表的操作。`inverse="true"`意味着关系的维护责任转移给了另一端的对象。这会影响到何时以及如何更新关系表,以保持数据库和对象模型...

    inverse 例子

    首先,`inverse`属性主要应用于一对多(OneToMany)和多对一(ManyToOne)的关系映射中。默认情况下,Hibernate假设一方(通常是一对多的那一方)负责维护关联关系,也就是说,当这一方的对象被保存或更新时,它会...

    hibernate多对一、一对一、一对多、多对多映射的理解(经典)

    Hibernate 多对一、一对一、一对多、多对多映射的理解 Hibernate 是一个流行的 Java 持久层框架,它提供了多种方式来映射 Java 对象与数据库表之间的关系。其中,多对一、一对一、一对多、多对多是四种基本的映射...

    hibernate many-to-one(多对一)及 cascade(级联).doc

    ### Hibernate Many-to-One (多对一) 及 Cascade (级联) #### 一、Many-to-One(多对一) 在数据库设计中,实体之间的关系主要包括一对一、一对多、多对多等几种类型。而在ORM(对象关系映射)框架Hibernate中,...

    Hibernate关于注解的一对多,多对多,一对一

    本篇文章将深入探讨Hibernate中注解的一对多、多对多和一对一关系映射。 ### 一对多关系 在现实生活中,例如一个班级有一个班主任,而班主任可以管理多个学生,这就是典型的“一对多”关系。在Hibernate中,我们...

    hibernate一对多案例

    本案例主要探讨的是Hibernate中的一对多关系映射,这是一种常见的对象关系映射(ORM)配置,用于表示一个实体与多个其他实体之间的关联。 在传统的数据库设计中,一对多关系是指一个表(父表)中的记录可以与另一个...

Global site tag (gtag.js) - Google Analytics