hibernate中的一对多的关系映射

这篇文章讲的是hibernate中对数据库进行的连表操作，如有错误或者不当之处，还希望各位大神批评指正。

多对一映射

目标
假设一个客人Customer可以下多个单Order，一个订单只能对应一个客人

类编写

1.Customer类：

//省略get和set方法
public class Customer {
    private Integer id ;
    private String name ;
    private char sex ;

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

2.Order类：

//省略get和set方法
public class Order {
    private Integer id ;
    private String address ;
    private Customer customer ;
}

*hbm.xml配置

1.Customer.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2018-6-20 17:24:51 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.cn.cmc.model.Customer" table="T_CUSTOMER">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="sequence" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="sex" type="char">
            <column name="SEX" />
        </property>
        <!-- 
            一对多的集合映射：
            name:对应类中集合的名字
            table：对应多的一端的表名
            key：对应外键名字
            class：对应多的一端的类
            inverse : 设置为true表示由对方来维护外键,设置为false表示由本方来维护外键;一般由多的一方维护
            cascade : 级联操作  save-update:保存更新，delete:删除     delete-orphan：删除孤儿
            lazy：是否延迟加载
            one-to-many : 描述集合的类型
         -->
        <set name="orders" cascade="delete" table="T_ORDER" inverse="true" lazy="true">
            <key>
                <column name="order_id" />
            </key>
            <one-to-many class="com.cn.cmc.model.Order" />
        </set>
    </class>
</hibernate-mapping>

2.Order.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2018-6-20 17:24:51 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.cn.cmc.model.Order" table="T_ORDER">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="sequence" />
        </id>
        <property name="address" type="java.lang.String">
            <column name="ADDRESS" />
        </property>
         <!-- 
            配置多这一端：
            name:关联的一那一端的名字
            class：一那一段的类名
            column:一那一段外键的列名
         -->
        <many-to-one name="customer"  class="com.cn.cmc.model.Customer">
            <column name="order_id" />
        </many-to-one>
    </class>
</hibernate-mapping>

注：表名不要和ORACLE系统关键字重复，如Order

插入操作

Order order1 = new Order() ;
        order1.setAddress("beijing");

        Order order2 = new Order() ;
        order2.setAddress("zhengzhou");
        Customer customer = new Customer() ;
        customer.setName("cmc");
        customer.setSex('M');
        //注意一的一方不维护外键，因此要给多设置一的对象，否则数据库插入不了外键值
        order1.setCustomer(customer);
        order2.setCustomer(customer);
        //先插入一的一端再插入多的一端
        session.save(customer) ;

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

注：先插入一的一端再插入多的一端，因为如果先插入多的一端无法确定一的一端的外键值，会多出来几条update语句

查询操作

• 仅查询多的对象

//此时仅查询Order表
Order order = (Order) session.get(Order.class, 79) ;
System.out.println(order.getAddress());
//此时查询Customer表
Customer customer = order.getCustomer() ;       
System.out.println(customer.getName());

注：仅查询多的一方的一个对象，则不执行查询对应一的一方，在使用到关于一的一方的操作时才发送查询操作（懒加载）

-更新操作

• 将‘81’号客户的性别改为女

Customer customer = (Customer) session.get(Customer.class, 81) ;
customer.setSex('F');

session.update(customer);

删除操作

• 删除‘80’号顾客

Customer customer = (Customer) session.get(Customer.class, 81) ;
        session.delete(customer);

注：会级联删除Order