`
Wind_ZhongGang
  • 浏览: 264837 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

Hibernate one-to-many cascade探究

阅读更多

  对于Hibernate的one-to-many关联关系中,合理使用cascade属性能够显著减少代码量,减轻程序员的工作量。

 

  一。Husband

 

package com.hibernate;

import java.util.Set;

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 9/7/11
 * Time: 2:22 PM
 */
public class Husband {
    private Integer id;
    private String name;
    private Set<Wife> wifes;

    public Husband() {
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Set<Wife> getWifes() {
        return wifes;
    }

    public void setWifes(Set<Wife> wifes) {
        this.wifes = wifes;
    }
}

 

 

<?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 default-access="field">

    <class name="com.hibernate.Husband" table="husband" dynamic-insert="true" dynamic-update="true">
        <id name="id" column="id" type="java.lang.Integer">
            <generator class="native"/>
        </id>
        <property name="name" column="name" type="java.lang.String"/>
        <set name="wifes">
            <key column="husbandid"/>
            <one-to-many class="com.hibernate.Wife"/>
        </set>
    </class>

</hibernate-mapping>
 

  二。Wife

 

package com.hibernate;

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 9/7/11
 * Time: 2:22 PM
 */
public class Wife {
    private Integer id;
    private String name;
    private Husband husband;

    public Wife() {
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Husband getHusband() {
        return husband;
    }

    public void setHusband(Husband husband) {
        this.husband = husband;
    }
}

 

 

<?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 default-access="field">

    <class name="com.hibernate.Wife" table="wife" dynamic-insert="true" dynamic-update="true">
        <id name="id" column="id" type="java.lang.Integer">
            <generator class="native"/>
        </id>
        <property name="name" column="name" type="java.lang.String"/>
        <many-to-one name="husband" column="husbandid" class="com.hibernate.Husband" cascade="save-update"/>
    </class>

</hibernate-mapping>

 

  三。db.properties and testDatasource.xml

 

 


db.url=jdbc:mysql://localhost:3306/dream

db.driver=com.mysql.jdbc.Driver

db.username=root

db.password=root

hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

hibernate.show_sql=true

hibernate.hbm2ddl.auto=update

hibernate.jdbc.batch_size=100
 

 


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"
       default-autowire="byName">

    <context:property-placeholder location="classpath:db.properties"/>

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
        <property name="driverClassName" value="${db.driver}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
    </bean>

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mappingLocations">
            <list>
                <value>classpath:/hibernate_mappings/*</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
            </props>
        </property>
    </bean>

    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <aop:config>
        <aop:pointcut id="service" expression="execution(* com.hibernate..*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="service"/>
    </aop:config>

</beans>

 

  四。HibernateCascadeTest

 


package com.hibernate;

import junit.framework.TestCase;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 9/7/11
 * Time: 2:43 PM
 */
public class HibernateCascadeTest extends TestCase {

    public void testDelete() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("testDatasource.xml");
        SessionFactory sessionFactory = (SessionFactory) context.getBean("sessionFactory");
        Session session = sessionFactory.openSession();

        Husband husband = new Husband();
        husband.setName("Husband");

        Wife wife1 = new Wife();
        wife1.setName("Wife 1");
        wife1.setHusband(husband);

        Wife wife2 = new Wife();
        wife2.setName("Wife 2");
        wife2.setHusband(husband);

        Set<Wife> wifes = new HashSet<Wife>();
        wifes.add(wife1);
        wifes.add(wife2);

        husband.setWifes(wifes);

        session.saveOrUpdate(wife1);
        session.saveOrUpdate(wife2);

        session.flush();

        session.delete(wife1);

        session.flush();
    }
}

 

  理解cascade级联操作:当对实体进行CRUD操作时,对其配置文件中的配置有cascade的属性的实体是否也应该执行该操作。如当对Husband实体进行保存时,如果此时在Husband.hbm.xml配置文件中,对Wife的实体配置cascade="save-update",表明当对Husband进行保存或修改时,也会引起对与Husband实体相关的Wife的实体的保存或修改操作。cascade有这样几种常用值,save-update,delete,all等。delete表明只有进行删除操作,才会引起级联删除操作,而all则表明对实体进行CRUD操作时,会引起cascade的实体的CRUD操作。具体配置哪种值,可根据项目中的实际需要,具体需求,具体分析。

  那么对于一个one-to-many的实体关联关系,应该将cascade配置在一方还是多方呢?我的建议是配置在一方。试想,对于上述举例,如果在Husband.hbm.xml中的wifes属性上配置 cascade="all",那么当添加或修改Husband实体时,会相应地引起对于Wife的级联添加或修改操作,而如果删除Husband实体,因为该实体在数据库中已不存在,那么再在Wife实体中的Husband维护这样的一对多关系,完全是没有任何必要的。而如果在Wife.hbm.xml中的husband属性上配置cascade="all",那么当保存或修改Wife实体时,会级联保存或修改Husband实体,而当删除Wife实体时,会级联删除Husband实体,这样Hibernate是会报错的,原因很简单,一个Husband关联着多个Wife,当删除其中一个Wife时,就去删除Husband,那么其它的Wife的Husband不就找不到对应的实体了嘛,所以在多方配置cascade="all"或cascade="all-delete-orphan",cascade="delete",不仅导致系统错误,在现实需求中来说也是绝对不允许的。

分享到:
评论

相关推荐

    hibernate many-to-many级联保存,级联更新,级联删除

    在Java的持久化框架Hibernate中,Many-to-Many关系是一种常见的数据库表之间的关联方式,它表示一个实体可以与多个其他实体进行关联,反之亦然。本文将深入探讨如何在Hibernate中处理Many-to-Many关系的级联保存、...

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

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

    Hibernate one-to-many-annotation

    在Hibernate中,`one-to-many`关系是常见的实体间关系之一,表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...

    Hibernate Many-To-Many Mapping Annotations

    在Java的持久化框架Hibernate中,Many-to-Many映射是一种常见的关系模型,它用于表示两个实体类之间多对多的关系。在这个主题中,我们将深入探讨如何使用注解来实现这种映射,以及其背后的数据库原理和实际应用。 ...

    Hibernate many-to-many

    "Hibernate many-to-many"指的是Hibernate中处理多对多关联关系的一种方式。多对多关系是两个实体类之间存在的一种复杂关联,比如学生和课程之间的关系,一个学生可以选修多门课程,一门课程也可以被多个学生选修。 ...

    Hibernate one to many(many to one) 配置

    标题"Hibernate one to many(many to one) 配置"涉及到的是关系型数据库在Java中的持久化框架Hibernate中的两种关联映射关系:一对一(One-to-One)和多对一(Many-to-One)。在数据库设计中,这种关系很常见,例如...

    Hibernate Tutorial 04 (Many-to-one and One-to-one Association

    为了使用 `publisher` 属性,我们需要在 `Book` 类的 Hibernate 映射文件中添加 `&lt;many-to-one&gt;` 映射。这将在 `BOOK` 表中添加一个名为 `PUBLISHER_ID` 的列,并存储关联出版商的 ID。 ```xml &lt;!-- 其他属性的...

    Hibernate应用例子one-to-one

    【Hibernate应用例子one-to-one】 Hibernate 是一个强大的Java对象关系映射(ORM)框架,它允许开发者以面向对象的方式操作数据库,从而简化了数据库应用程序的开发。在Hibernate中,"one-to-one"(一对一)关联是...

    NHibernate One-to-Many一对多映射-xxlinux_com

    在数据库世界中,一对多(One-to-Many)关系是一种常见的关联类型,其中一个表(父表)可以与多个其他表(子表)相关联。在NHibernate中,配置这种映射关系对于理解和使用ORM至关重要。 一对多关系意味着一个实体...

    hibernate-one-to-many-uni

    【标题】"hibernate-one-to-many-uni" 指的是在Hibernate框架下实现的一对多单向关联关系。Hibernate是Java开发中常用的持久化框架,它简化了数据库操作,使得开发者可以更加专注于业务逻辑而不是数据库交互。在这个...

    hibernate-one-to-many

    &lt;many-to-one name="department" class="com.example.Department" column="DEPARTMENT_ID" /&gt; ``` 如果使用注解,上述关系已经在实体类中定义。 ### 3. 操作一对多关系 在实际应用中,我们可以通过Hibernate提供...

    PyPI 官网下载 | django-postgres-delete-cascade-2.0a1.tar.gz

    标题中的“PyPI 官网下载 | django-postgres-delete-cascade-2.0a1.tar.gz”表明这是一个从Python Package Index(PyPI)官方源获取的软件包,名为“django-postgres-delete-cascade”。这个软件包的版本是2.0a1,...

    hibernate-one-to-one-uni

    本项目“hibernate-one-to-one-uni”专注于探讨和实现Hibernate框架中的一对一(One-to-One)关系映射,这种关系在数据库设计中比较常见,用于表示两个实体之间一对一的联系。 一对一关系映射在Hibernate中分为两种...

    Hibernate one to one详细配置

    在Java的持久化框架Hibernate中,一对一(One-to-One)关联映射是常见的关系映射类型之一。它用于表示两个实体之间一对一的关联关系,即一个实体对应另一个实体的唯一实例。下面将详细介绍Hibernate中如何进行一对一...

    hibernate最新版jar包(全)

    10. **多对一(One-to-Many)、一对多(Many-to-One)、一对一(One-to-One)、多对多(Many-to-Many)关系**: Hibernate支持这四种数据库关联关系,通过不同的注解配置来实现。 **使用Hibernate的步骤** 1. **...

    hibernate many to one

    在Java的持久化框架Hibernate中,"Many-to-One"关系是一种常见的关联映射类型,它表示一个实体(类)可以与多个其他实体实例相关联。在这个主题中,我们将深入探讨Hibernate如何处理这种关系,以及如何在实际编程中...

    Hibernate学生-课程-成绩表的例子(many2many)

    在这个“Hibernate学生-课程-成绩表的例子(many2many)”中,我们将探讨如何利用Hibernate处理多对多关联关系,以及相关源码和工具的使用。 多对多关联是数据库设计中常见的关系类型,它表示两个实体之间可以有多个...

    hb-04-one-to-many-uni

    标题“hb-04-one-to-many-uni”和描述中的信息看似简洁,但结合标签“Java”,我们可以推测这是一个关于Java编程中的一个特定主题——一对一(One-to-One)、一对多(One-to-Many)关系的统一处理(uni)的示例项目...

    Hibernate中cascade与inverse属性详解

    在深入讲解这两个属性之前,我们首先需要理解 Hibernate 中的一些基本概念,如 one-to-many 和 many-to-one 关系、对象的状态以及 Session 缓存。 一、one-to-many 和 many-to-one 关系 在示例中,`class` 表(班级...

Global site tag (gtag.js) - Google Analytics