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

时间：2023-03-09 20:49:29
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(); // 游离状态

    }

}

相关文章