Hibernate一对多(双向)

///
Hibernate:
///
双向关联就是有“一对多”和“多对一”两个关联组合而成德，在双向关联的两端都知道对方是谁。


下面就开始演示这种关联。


首先定义我们需要使用的POJO对象。


public class Member
{
   private String id; 
    private String name; 
    private Integer age; 
    private Set<Order> orders = new HashSet<Order>();//我知道Order对象
   ……
}


public class Order
{
   private Integer id; 
    private String name; 
    private String num; 
    private Member member;//我知道Member对象
……
}


两个POJO对应的映射文件分别为Member.hbm.xml和Order.hbm.xml。


Member.hbm.xml


<hibernate-mapping package="org.louis.domain"> 
    <class name="Member" table="TEST_MEMBER">
        <id name="id" column="ID"> 
            <generator class="uuid.hex"></generator> 
        </id> 
        <property name="age" column="AGE"></property> 
        <property name="name" column="NAME"></property> 
        <set name="orders" cascade="all" inverse="true">
<!--设置inverse=”true”表示Member不在作为主控方，就是说不再由Member来维持关联关系，
而有Order方来维持关联关系，这样Order在持久化的时候会主动去获取Member的主键值来作为自己
的外键值。 在one-to-manay关联关系中，一般将manay端设置为主控方（inverse=”false”），
这样将有助于改善性能。默认情况下inverse=”false” --> 
           <key column="MEMBER_ID"></key> 
           <one-to-many class="Order"/> 
        </set>
</class> 
</hibernate-mapping>


Order.hbm.xml


<hibernate-mapping package="org.louis.domain"> 
    <class name="Order" table="TEST_ORDER"> 
        <id name="id" column="ID"> 
            <generator class="native"></generator> 
        </id> 
        <property name="name" column="NAME"></property> 
        <property name="num" column="NUM"></property> 
        <many-to-one name="member" class="Member" column="MEMBER_ID"></many-to-one>
</hibernate-mapping>


下面我们来进行测试。


a、插入数据


public void insert()
{ 
        Session session = HibernateSessionFactory.getSessionFactory().getCurrentSession(); 
        session.beginTransaction(); 
        Member m = new Member(); 
        m.setAge(24); 
        m.setName("Louis");


        Order order = new Order();
        order.setName("order 1");
        order.setNum("order num 1");
        order.setMember(m);
        m.getOrders().add(order);


        session.save(m); 
        session.getTransaction().commit(); 
    }


查看Hibernate在后台使用的SQL语句如下：


Hibernate: 
   insert 
   into 
       TEST_MEMBER 
       (AGE, NAME, ID) 
   values 
       (?, ?, ?) 
Hibernate: 
   insert 
   into 
       TEST_ORDER 
       (NAME, NUM, MEMBER_ID) 
   values 
       (?, ?, ?)


仅仅就两条语句，明显比单向关联的时候少了一条更新语句（把Order的外键进行更新为Menber的主键值）。


b、加载数据

和单向关联的区别在于，如果加载的是Order对象，那么它也知道和它关联的对象。


c、删除数据

删除数据和单向关联时的删除数据的区别在于，对Member及它的关联对象Order加载后，不需要在更新Order的外键为NULL，而是紧跟着逐条删除Order，最后删除Member。

Hibernate: 
    select
        member0_.ID as ID0_0_,
        member0_.AGE as AGE0_0_,
        member0_.NAME as NAME0_0_ 
    from
        TEST_MEMBER member0_ 
    where
        member0_.ID=?
Hibernate: 
    select
        orders0_.MEMBER_ID as MEMBER4_1_,
        orders0_.ID as ID1_,
        orders0_.ID as ID1_0_,
        orders0_.NAME as NAME1_0_,
        orders0_.NUM as NUM1_0_,
        orders0_.MEMBER_ID as MEMBER4_1_0_ 
    from
        TEST_ORDER orders0_ 
    where
        orders0_.MEMBER_ID=?
Hibernate: 
    delete 
    from
        TEST_ORDER 
    where
        ID=?
Hibernate: 
    delete 
    from
        TEST_MEMBER 
    where
        ID=?

http://blog.csdn.net/yifei12315/article/details/6985194