hibernate 双向1对多

1：

还是用客户Customer和订单Order来解释：

“一对多”的物理意义：一个客户可以有多个订单，某个订单只能归宿于一个客户。

“双向”的物理意义：客户知道自己有哪些订单，订单也知道自己归宿于哪个客户。也就是说，通过客户对象可以检索到其拥有哪些订单；同时，通过订单也可以查找到其对应的客户信息。这是符合我们业务逻辑需求。

 1的1方
 <set name="orders" table="ORDERS">
             <key column="customer_Id"></key>
             <one-to-many class="Order"/>
         </set>

多的1方
<many-to-one name="customer" class="Customer" column="customer_Id"></many-to-one> 

例子：

1的一方：

package com.hibernate.n21.both;

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

public class Customer {
    private Integer customerId;
    private String customerName;
    //双向1对多  在1的1方加一个set集合
　　　　//需要把集合进行初始化。可防止空指针异常。
        private Set<Order> orders =new HashSet<Order>();

        public Set<Order> getOrders() {
            return orders;
        }

        public void setOrders(Set<Order> orders) {
            this.orders = orders;
        }
    public Integer getCustomerId() {
        return customerId;
    }

    public void setCustomerId(Integer customerId) {
        this.customerId = customerId;
    }

    public String getCustomerName() {
        return customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }

}

1的一方的配置文件：

 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 <hibernate-mapping package="com.hibernate.n21.both">

     <class name="Customer" table="customer">

         <id name="customerId" type="java.lang.Integer">
             <column name="customer_Id" />
             <!-- 指定主键的生成方式, native: 使用数据库本地方式 -->
             <generator class="native" />
         </id>

         <property name="customerName"
             type="java.lang.String" column="customer_Name" >
         </property>

         <set name="orders" table="ORDERS">
             <key column="customer_Id"></key>
             <one-to-many class="Order"/>
         </set>

     </class>

 </hibernate-mapping>

多的一方：

 package com.hibernate.n21.both;

 public class Order {
     private Integer orderId;
     private String orderName;
     private Customer customer;
     public Integer getOrderId() {
         return orderId;
     }
     public void setOrderId(Integer orderId) {
         this.orderId = orderId;
     }
     public String getOrderName() {
         return orderName;
     }
     public void setOrderName(String orderName) {
         this.orderName = orderName;
     }
     public Customer getCustomer() {
         return customer;
     }
     public void setCustomer(Customer customer) {
         this.customer = customer;
     }

 }

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hibernate.n21.both">

    <class name="Order" table="orders" >

        <id name="orderId" type="java.lang.Integer">
            <column name="order_Id" />
            <!-- 指定主键的生成方式, native: 使用数据库本地方式 -->
            <generator class="native" />
        </id>

        <property name="orderName"
            type="java.lang.String" column="order_Name" >
        </property>

        <!-- 映射n-1的关联关系 -->
        <many-to-one name="customer" class="Customer" column="customer_Id"></many-to-one>
    </class>

</hibernate-mapping>

测试：

保存save()：

@org.junit.Test
    public void testN21Save(){
        Customer customer=new Customer();
        customer.setCustomerName("AA");
        
        Order order1 =new Order();
        order1.setOrderName("order-1");
        
        Order order2 =new Order();
        order2.setOrderName("order-2");
        //会出现3个insert。2个update。  因为 1 的一端和 n 的一端都维护关联关系. 所以会多出 UPDATE
        //可以在 1 的一端的 set 节点指定 inverse=true, 来使 1 的一端放弃维护关联关系!
        //建议设定 set 的 inverse=true, 建议先插入 1 的一端, 后插入多的一端

inverse  相反的。反转。反转维护的方向。

inverse="true"。就是让1的一方放弃维护关系。因为我们都可以记住习大大。但是习大大不可能全记得我们

        //好处是不会多出 UPDATE 语句
        //设置关联关系。就是给多的一方设置外键
        order1.setCustomer(customer);
        order2.setCustomer(customer);
        
        customer.getOrders().add(order1);
        customer.getOrders().add(order2);

        session.save(customer);
        session.save(order1);
        session.save(order2);
    }

查询：

 @org.junit.Test
     public void testGet(){
         Customer customer=(Customer) session.get(Customer.class, 1);
         System.out.println(customer.getCustomerName());
     }

只显示Customer。没有出现set集合的内容。

 @org.junit.Test
     public void testGet(){
         Customer customer=(Customer) session.get(Customer.class, 1);
         System.out.println(customer.getCustomerName());
         //2:class org.hibernate.collection.internal.PersistentSet 返回的hibernate内置的集合类型。
         //这个类型具有延迟加载和存放代理对象的功能。
         System.out.println(customer.getOrders().getClass());

     }

@org.junit.Test
    public void testGet(){
        Customer customer=(Customer) session.get(Customer.class, 1);
        System.out.println(customer.getCustomerName());
        //class org.hibernate.collection.internal.PersistentSet 返回的hibernate内置的集合类型。
        //这个类型具有延迟加载和存放代理对象的功能。
        System.out.println(customer.getOrders().getClass());
        //3:在查询完customer后就把session关闭。会出现懒加载异常。
        session.close();
        System.out.println(customer.getOrders().size());
    }

4：在需要使用集合中元素的时候进行初始化。

删除：

 @org.junit.Test
     public void testDelete(){
         Customer customer=(Customer) session.get(Customer.class, 1);
         session.delete(customer);
     }

直接删除的话会报错。

在配置文件中的set集合。设置cascade属性。

这是级联删除。就是只要多的一方的外键是1的主键的。删除1。对应的多的全部删除掉。

<set name="orders" table="ORDERS" inverse="true" cascade="delete">

cascade="delete-orphan":删除孤儿。解除关联关系。把多的外键为1主键的都删除掉。因为解除关系了。变成孤儿了。

　　　　　save-update   级联保存。就是不用写session.save(order);

order-by属性：里面是数据库中的字段名。不是类的属性名。