hibernate学习（5）——一对多关系表达

一对多实现

1、 实现类

package com.alice.hibernate02.vo;

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

public class Customer {
    private Integer id;
    private String name;
    // 一对多：一个客户（当前客户） 拥有 【多个订单】
    // * 需要容器存放多个值，一般建议Set （不重复、无序）
    // * 参考集合：List、Map、Array等
    // ** 建议实例化--使用方便

    private Set<Order> orders = new HashSet<Order>();

    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<Order> getOrders() {
        return orders;
    }

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

}

package com.alice.hibernate02.vo;

public class Order {
    private Integer id;
    private String name;
  //多对一：多个订单属于【一个客户】
    private Customer customer;
	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 Customer getCustomer() {
		return customer;
	}
	public void setCustomer(Customer customer) {
		this.customer = customer;
	}
}

　　2、 配置文件

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.alice.hibernate02.vo">
     <class name="Customer" table="t_customer">
        <id name="id" column="id">
           <generator class="native"></generator>
        </id>
        <property name="name" column="name" type="string"></property>
        <!-- 表达一对多关系中的集合
             name:集合的属性名称
             inverse: 是否将关系的维护反转给对方. 默认值: false
                    true: 在Customer 中 放弃维护外键关系

             cascade :级联操作
                 save-update：级联保存,级联修改. 保存A时,同时保存B.
                delete：删除A，同时删除B，AB都不存在
                delete-orphan：孤儿删除，解除关系，同时将B删除，A存在的。
                如果需要配置多项，使用逗号分隔。<set cascade="save-update,delete">

                all : save-update 和 delete 整合
                all-delete-orphan : 三个整合

          -->
        <set name="orders">
        <!--
                 key 用来描述外键
                 column : 外键的值
               -->
          <key column="cid"></key>
          <one-to-many class="Order"/>
        </set>
     </class>
</hibernate-mapping>

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.alice.hibernate02.vo">
     <class name="Order" table="t_order">
        <id name="id" column="id">
           <generator class="native"></generator>
        </id>
        <property name="name" column="name" type="string"></property>
        <!-- 表达一对多关系中的集合
             name:集合的属性名称
             inverse: 是否将关系的维护反转给对方. 默认值: false
                    true: 在Customer 中 放弃维护外键关系

             cascade :级联操作
                 save-update：级联保存,级联修改. 保存A时,同时保存B.
                delete：删除A，同时删除B，AB都不存在
                delete-orphan：孤儿删除，解除关系，同时将B删除，A存在的。
                如果需要配置多项，使用逗号分隔。<set cascade="save-update,delete">

                all : save-update 和 delete 整合
                all-delete-orphan : 三个整合

          -->
        <!-- 表达多对一关系
             name: 引用的属性名称
             column: 外键的列名
             class: 我引用的Order的完整类名
         -->
         <many-to-one name="customer" column="cid" class="Customer"></many-to-one>
     </class>
</hibernate-mapping>

3、一对多操作

 public void test01() {
         Session session = HibernateUtil.openSession();
         Transaction tran = session.beginTransaction();

         Customer cus = new Customer();
         cus.setName("alice");

         Order o1 = new Order();
         o1.setName("apple");

         Order o2 = new Order();
         o2.setName("banana");

         cus.getOrders().add(o1);// 维护关系
         cus.getOrders().add(o2);// 维护关系

         o1.setCustomer(cus);
         o2.setCustomer(cus);

         session.save(cus);//保存对象
         session.save(o1);//保存对象
         session.save(o2);//保存对象

         tran.commit();

         session.close();

     }

4、   级联操作（读、理解）

save-update：A保存，同时保存B

delete：删除A，同时删除B，AB都不存在

delete-orphan：孤儿删除，解除关系，同时将B删除，A存在的。

如果需要配置多项，使用逗号分隔。<set cascade="save-update,delete">

all : save-update 和 delete 整合

all-delete-orphan : 三个整合

package com.alice.hibernate02.many;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.alice.hibernate02.util.HibernateUtil;
import com.alice.hibernate02.vo.Customer;
import com.alice.hibernate02.vo.Order;

//测试 一对多关系
public class ManyTest02 {

    @Test
    //增
    //我们希望在保存Customer时,自动将未保存的Orders当中的Order保存
    //cascade: save-update
    public void test01() {
        Session session = HibernateUtil.openSession();
        Transaction tran = session.beginTransaction();

        Customer cus = new Customer();
        cus.setName("alice");

        Order o1 = new Order();
        o1.setName("apple");

        Order o2 = new Order();
        o2.setName("banana");

        cus.getOrders().add(o1);// 维护关系
        cus.getOrders().add(o2);// 维护关系

//        o1.setCustomer(cus);
//        o2.setCustomer(cus);

        session.save(cus);//保存对象
//        session.save(o1);//保存对象
//        session.save(o2);//保存对象

        tran.commit();

        session.close();

    }
    @Test
     //增
      //我们希望在保存Customer时,自动将未保存的Orders当中的Order保存
      //cascade: save-update
    public void test02() {
        Session session = HibernateUtil.openSession();
        Transaction tran = session.beginTransaction();

        Customer cus = (Customer) session.get(Customer.class, 2);//1条 select

        for(Order o :cus.getOrders()){// 1条 select
            o.setName("mike");// 修改订单
        }

        tran.commit();//因为设置级联修改,自动将订单的修改保存到数据

        session.close();

    }
  //cascade: delete
      //删除Customer时 ,会将Customer下的订单一并删除
      //inverse : false   6条sql语句
      //inverse : true    5条sql语句 比上面少一条维护外键
    @Test
    public void test03() {
        Session session = HibernateUtil.openSession();
        Transaction tran = session.beginTransaction();

        Customer cus = (Customer) session.get(Customer.class, 3);//1条 select

        session.delete(cus);//删除Customer
         // 删除两个Order

        tran.commit();//因为设置级联修改,自动将订单的修改保存到数据

        session.close();

    }
  //cascade: delete
      //操作的两方cascade值都为delete
      //需要注意: 千万不要在两方都配置 级联删除. 删除任何一方,会导致整个关系链对象全部删除.
    @Test
    public void test04() {
        Session session = HibernateUtil.openSession();
        Transaction tran = session.beginTransaction();

        Order o =(Order) session.get(Order.class, 6);

        session.delete(o);//删除Customer
         // 删除两个Order

        tran.commit();//因为设置级联修改,自动将订单的修改保存到数据

        session.close();

    }

}

package com.alice.hibernate02.many;

import java.util.Iterator;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.alice.hibernate02.util.HibernateUtil;
import com.alice.hibernate02.vo.Customer;
import com.alice.hibernate02.vo.Order;

//测试 一对多关系
public class ManyTest03 {
    @Test
    //inverse:false
        //cascade: delete-orphan 孤儿删除 => 当没有任何外键引用Order时,order 会被删除
    public void test02(){
        Session session = HibernateUtil.openSession();
        Transaction tran = session.beginTransaction();

        Customer cus = (Customer) session.get(Customer.class, 4);
        Iterator<Order> iter = cus.getOrders().iterator();
        //注意: 删除Customer下的订单时,不能使用 c.setOrders(null); c.setOrders(new HashSet());
        while(iter.hasNext()){// 遍历Customer下的订单,并将订单删除 => 维护关系
            iter.next();
            iter.remove();
        }
        //cascade: all-delete-orphan => 相当于配置 save-update,delete,delete-orphan

    }
    //cascade: all-delete-orphan => 相当于配置 save-update,delete,delete-orphan
    @Test
    public void fun1(){
        Session session = HibernateUtil.openSession();
        Transaction tran = session.beginTransaction();
        //------------------------------------------------
        Customer c = new Customer();
        c.setName("tom");

        Order o1 = new Order();
        o1.setName("肥皂");

        Order o2 = new Order();
        o2.setName("蜡烛");

        c.getOrders().add(o1);//维护关系
        c.getOrders().add(o2); //维护关系

        session.save(c);
        //------------------------------------------------
            session.getTransaction().commit();
            session.close(); // 游离状态
    }
}