Hibernate中inverse属性与cascade属性

 Hibernate集合映射中,经常会使用到"inverse"和"cascade"这两个属性。对于我这样,Hibernate接触不深和语文水平够烂的种种因素,发现这两个属性实在是难以理解,无奈只好将这个两个属性解释工作交给了Google和Baidu,查看了许多牛人的解释,加上自己在Eclipse上的调试,对"inverse"和"cascade"这两个属性有了一定的见解。



"inverse"属性探究

  "inverse"-直译过来就是"反转,使颠倒"的意思,书面化的解释为"是否将关系维护的权力交给对方"(这个解释真够蛋疼的-_-!!,就是理解不了)。 Hibernate中的"inverse"属性只有两个值"true"和"false"。"true"表示将关系维护的权力交给对方,"false"表示不交出维护权力(默认值)。

  例如有两张表,customer和orders,他们的关系是一对多,customer是一方,orders为多方。

drop table if exists customer;
drop table if exists orders;

create table customer
(
    id varchar(255) not null,
    username varchar(255),
    password varchar(255),
    age integer,
    register_time datetime,
    primary key (id)
);

create table orders
(
    id varchar(255) not null,
    orderNumber varchar(255),
    balance integer,
    customer_id varchar(255),
    primary key (id)
);

  两表对应的hbm文件,对应的POJO类:

/*customer表对应的POJO类*/
public class Customer
{
    private String id;
    private String username;
    private String password;
    private Timestamp registerTime;
    private int age;
    private Set<Order> orders = new HashSet<Order>();

    public Customer()
    {

    }

    /*get and set method*/

}

/*orders表对应的POJO类*/
public class Order
{
    private String id;
    private String orderNumber;
    private int balance;
    private Customer customer;

    public Order()
    {

    }

    /* get and set method*/
}

  

<!--Customer类的hbm文件-->
    <hibernate-mapping>
        <class name="com.suxiaolei.hibernate.pojos.Customer" table="customer">
            <id name="id" type="string">
                <column name="id"></column>
                <generator class="uuid"></generator>
            </id>

            <property name="username" column="username" type="string"></property>
            <property name="password" column="password" type="string"></property>
            <property name="age" column="age" type="integer"></property>
            <property name="registerTime" column="register_time" type="timestamp"></property>

            <set name="orders" inverse="true" cascade="all">
                <key column="customer_id" ></key>
                <one-to-many class="com.suxiaolei.hibernate.pojos.Order"/>
            </set>

        </class>
    </hibernate-mapping>

<!--Order类的hbm文件-->
    <hibernate-mapping>
        <class name="com.suxiaolei.hibernate.pojos.Order" table="orders">
            <id name="id" type="string">
                <column name="id"></column>
                <generator class="uuid"></generator>
            </id>

            <property name="orderNumber" column="orderNumber" type="string"></property>
            <property name="balance" column="balance" type="integer"></property>

            <many-to-one name="customer" class="com.suxiaolei.hibernate.pojos.Customer">
                <column name="customer_id"></column>
            </many-to-one>
        </class>
    </hibernate-mapping>

  

下面写一些测试代码测试"inverse"属性的特性:

情况一:将"inverse"设置为true,让多方维护关系

try
        {
            tx = session.beginTransaction();

            /*
             * 创建Customer对象,并设置其属性值
             */
            Customer customer = new Customer();
            customer.setUsername("zhangsan");
            customer.setPassword("123456");
            customer.setAge(22);
            customer.setRegisterTime(new Timestamp(new Date().getTime()));

            /*
             * 创建Order对象order1,并设置其属性值
             */
            Order order1 = new Order();
            order1.setOrderNumber("a1a2a3");
            order1.setBalance(1000);
            order1.setCustomer(customer);//将customer对象关联到order1对象上

            /*
             * 创建Order对象order2,并设置其属性值
             */
            Order order2 = new Order();
            order2.setOrderNumber("d3d2d1");
            order2.setBalance(670);
            order2.setCustomer(customer);///将customer对象关联到order2对象上

            customer.getOrders().add(order1);//将order1对象关联到customer对象上
            customer.getOrders().add(order2);//将order2对象关联到customer对象上

            session.saveOrUpdate(customer);

            tx.commit();
        }
        catch (Exception e)
        {
            if(tx != null)
            {
                tx.rollback();
            }

            e.printStackTrace();
        }
        finally
        {
            session.close();
        }

  

数据库中的数据更新为:

customer表:

orders表:

现在将order1.setCustomer(customer);这段代码注释掉,再次运行程序:

customer表:

orders表:

  可以到看到显著地差别了,第一次保存"id"="402881e534ea7c750134ea7c76bc0001"的数据时,orders表中插入了两条数据,他们的customer_id都为customer中对应记录的主键值,而第二次保存记录"id"="402881e534ea81be0134ea81bfea0001"的数据时,由于先前将原来的代码段order1.setCustomer(customer);注释掉了,此时order表中插入的数据中order1代表的那条记录没有customer_id值。

  从以上现象可以有助于理解"inverse"这个属性。首先,"inverse"控制关系维护权力,那么什么是"关系"?,关系的具体体现是什么?在以上例子中,"关系"就是两个表之间的关系,通常为"一对多","一对一","多对多"三种关系,而关系的具体体现为orders表中的customer_id列,而"inverse"属性就是告诉Hibernate哪一方有权力管理和维护这一列。上面的例子将"inverse"设置为true那么customer_id这一列由多方(order对象)维护。这说明了,只有order对象对关系的操作会反映到数据库中。(对象对关系的操作就是对关联属性的操作,例如order对象对自身的"customer"属性操作,customer对象对自身的orders集合(Set<Order>)操作)

  例如,将id="402881e534ea7c750134ea7c76bc0001"的customer对象从数据库中取出,获取到该customer对象所关联的order对象集合,将该customer对象所关联的order对象删除。

Customer customer = (Customer)session.get(Customer.class, "402881e534ea7c750134ea7c76bc0001");
Order order = (Order)session.get(Order.class, "402881e534ea7c750134ea7c76ce0002");

System.out.println("customer association order count:"+customer.getOrders().size());
customer.getOrders().remove(order);
System.out.println("customer association order count:"+customer.getOrders().size());

session.saveOrUpdate(customer);

  

//Console Output:

customer association order count:2
customer association order count:1

  可以看到customer中关联的order对象集合确实有对象被删除了,若操作有效,表示该order对象与customer对象没有关系了,反映到数据库中应该将该order对象对应的customer_id设置为null。现在查看一下数据库数据:

看到了吧,刚刚那个操作就是个无用操作,不会反应到数据库中。我们修改一下程序代码:

Customer customer = (Customer)session.get(Customer.class, "402881e534ea7c750134ea7c76bc0001");
Order order = (Order)session.get(Order.class, "402881e534ea7c750134ea7c76ce0002");

order.setCustomer(null);

session.saveOrUpdate(customer);

  

这次我们使用order对象来操作关系,将该order对象与customer对象脱离关系,若操作有效,则反映在数据库中应该是该order对象的customer_id字段的值变成null,现在查看一下数据库:

可以看到,此次操作成功的反映到了数据库中了。

情况二、将"inverse"属性设置为"false",双方都维护关系(因为没有一方交出权力,"inverse"的默认值为"false",而且"inverse"属性只能在set、list、map等几个标签中设置,像many-to-one这一类的标签都不能设置"inverse"这个属性值,它们只能取值"false")

  这里会产生书中所说的性能问题(囧,这个也是理解了很久很久),这个不管怎么说你都可能理解不了,我就是这样的(-_-!!),所以我建议使用第三方的软件将Hibernate输出的SQL语句的绑定值显示出来(可以参考这里)。之所以会产生性能为题,当你操作关系是会无故多产生一些update语句,比如你使用上面的例子保存一个customer对象,它关联了2个order对象,它不但会生成3条insert语句(用于插入数据),还会生成2条update语句(将关联的order对象的customer_id更新为自己的主键值),你想想要是一个customer对象包含几万了order对象(购物狂),那么每次保存它得要多生成几万条update语句,这个就是很严重的性能问题了。

  为什么Hibernate会产生update语句呢?那是Hibernate太主动,太热情,太负责的表现,它怕你出现错误,例如有几万个order对象需要关联到customer对象上,这就需要调用order.setCustomer(customer);,几万个对象这不是人可以不放错的完成的。所以Hibernate怕你出错忘记调用这个方法,所以他将会在order对象保存完毕后将所有关联对象的customer_id字段更新一遍,确保正确性,这样也就产生上面的性能问题。

  将"inverse"设置为false后,你可以尝试设置order1.setCustomer(null),它依然会正确的将customer的主键值完美的插入到order的customer_id字段上,只是会多一条update语句。



"cascade"属性

  "cascade"-直译过来就是"级联、串联"的意思,书面化的解释为"该属性会使我们在操作主对象时,同时Hibernate帮助我们完成从属对象相应的操作(比如,有Customer和Order这两张表,关系为一对多,只使用JDBC删除Customer表中的一行记录时,我们还需要手动的将Order表中与之关联的记录全都删除,使用Hibernate的‘cascade‘属性后,当我们删除一条Customer记录时,Hibernate会帮助我们完成相应Order表记录的删除工作,方便了我们的工作)"。



总结

  使用"inverse"这个属性时,要考虑清楚关系,不然你的系统就会有大的性能问题(不过我可能想不清楚,现在还是一个普通大学生没什么实战经验-_-!!,要继续努力~_~),书本上和一些牛人建议,关系一般由"多方"维护,当遇到"多对多"时怎么办,其实多对多久是两个"一对多",随意设置一方"inverse"为"true"就可以了,不要两方都设置或都不设置(囧,我开始就是死板这样的设置)。而是用"cascade"属性时,主对象(一方)一般设置为"all",而多方不建议设置包含delete操作的选项,建议设置多方为"save-update",这是因为你删除一方,多方已经没有存在的意义了,而删除多方不能代表一方没意义了(例如,消费者和订单)。最后,"cascade"操作的是两张表的记录或两端的对象,而"inverse"操作的是两张表的关系或两个对象的关系。

时间: 2024-10-15 13:01:27

Hibernate中inverse属性与cascade属性的相关文章

hibernate中inverse的用法

hibernate中inverse的用法 转自:http://blog.csdn.net/leader_lx/archive/2008/08/06/2774137.aspx 一.Inverse是hibernate双向关系中的基本概念.inverse的真正作用就是指定由哪一方来维护之间的关联关系.当一方中指定了“inverse=false”(默认),那么那一方就有责任负责之间的关联关系,说白了就是hibernate如何生成Sql来维护关联的记录 Hibernate仅仅按照主控方对象的状态的变化来同

Hibernate中inverse=&quot;true&quot;的理解

Hibernate中inverse="true"的理解 Customer类: Java代码 1. public class Customer { 2. private int id; 3. private String name; 4. private Set orders = new HashSet(); 5. ??? 6. } 即Customer类具有一个set集合属性orders,其中Order是一个普通的类: Java代码 1. public class Order { 2.

(07)Hibernate的inverse属性和cascade属性

Hibernate中的inverse和cascade,这两个属性都用于一多对(one-to-many)或者多对多(many-to-many)的关系中. 概括的来说,inverse代表是否由己方维护关系,cascade代表是否执行级联操作.接下来,举一列子来更加详细的说明这一关系. 假设有T_Department(部门表)和T_Employee(员工表),它们存在一对多的关系.表的定义如下: create table T_Department(     id int auto_increment,

Hibernate inverse属性和cascade属性

Inverse属性 Inverse属性,是在维护关联关系的时候起作用的. 表示控制权是否转移.(在一的一方起作用) Inverse , 控制反转. Inverse = false  不反转:   当前方有控制权 True  控制反转: 当前方没有控制权 维护关联关系中,是否设置inverse属性: 1.保存数据                    有影响. 如果设置控制反转,即inverse=true, 然后通过部门方维护关联关系.在保存部门的时候,同时保存员工,数据会保存,但关联关系不会维护

Hibernate inverse属性与cascade属性

理解: inverse属性为false的那一端,拥有管理关系维护的权利 cascade属性指级联,说的通俗点,在cascade那端指定的操作,会影响到所关联的对象 举个例子: 班级和学生的关系是一对多 班级class类包含id,名称和学生的Set集合 学生student类包含id,姓名和班级的id(外键) cascade属性:学生是依赖班级存在的,班级不存在,那么学生也不存在.也就是说,删除班级的同时,学生也就得删除,而不能反过来.一的那端删除时,多的那方已经没有意义了:而多的那端删除时,并不能

hibernate中inverse属性

inverse属性:是在维护关联关系的时候起作用的. 表示控制权是否转移(在一的一方起作用) inverse=false    不反转,当前方有控制权 inverse=true  控制反转,当前方没有控制权 保存数据:会影响到多的一方的数据 一的一方在保存数据时候 不会维护多的一方数据(多的一方数据不会保存到数据库中) 解除关联关系.clear()  方法 inverse=false  解除与多的一方关系  就是把多的一方的外键设为null inverse=true   不会解除 删除关联关系

hibernate中inverse属性详解

术语"inverse"直译为"反转".在Hibernate中,inverse属性指定了关联关系中的方向.关联关系中,inverse="false"的为主动方,由主动方维护关联关系.在一对多关联中,将one方的inverse设置为true,这将有助于性能的改善.也就是让所有新生主动来报到.Hibernate: insert into district (name, id) values (?, ?)Hibernate: insert into st

Hibernate中&lt;set&gt;的3个属性(3)

inverse 属性 1.在hibernate中通过对 inverse 属性的来决定是由双向关联的哪一方来维护表和表之间的关系. inverse = false 的为主动方,inverse = true 的为被动方, 由主动方负责维护关联关系 2.在没有设置 inverse=true 的情况下,父子两边都维护父子 关系 3.在 1-n 关系中,将 n 方设为主控方将有助于性能改善(如果要国家元首记住全国人民的名字,不是太可能,但要让全国人民知道国家元首,就容易的多) 4.在 1-N 关系中,若将

一口一口吃掉Hibernate(八)——Hibernate中inverse的用法

一.Inverse是hibernate双向关系中的基本概念.inverse的真正作用就是指定由哪一方来维护之间的关联关系.当一方中指定了"inverse=false"(默认),那么那一方就有责任负责之间的关联关系,说白了就是hibernate如何生成Sql来维护关联的记录! Hibernate仅仅按照主控方对象的状态的变化来同步更新数据库.按照原来的映射文件,people.getAddresses().add(address),即主控方对象的状态发生了改变,因此数据库会跟着对象状态的变