hibernate双向一对多映射

 双向多对一 ：Customer类------------》一的一端   Order类-----------》多的一端

Customer类：（省略set（）、get（）和构造方法）

　　private Integer customerId;
    private String customerName;
    
    private Set<Order> order = new HashSet<>();

Order类：（省略set（）、get（）和构造方法）

 private Integer orderId;

private String orderName;

private Customer customer; 

 

Customer类的映射文件：

<!-- 映射类和数据表 -->
    <class name="Customer" table="CUSTOMERS">
        <!-- 映射OID和数据表的主键 -->
        <id name="customerId" type="java.lang.Integer">
            <column name="CUSTOMER_ID"/>
            <!-- 指定主键的生成方式 -->
            <generator class="native"/>
        </id>
        
        <!-- 映射属性和字段 -->
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME"/>
        </property>
        
        <!-- 映射 1对多的那个集合属性-->
        <!-- set:映射set类型的属性,table:set中的元素对应的记录放在哪一个数据表中.该值需要和多对一的多的那个表的名字一致 -->
        <!-- inverse:指定由哪一方来维护关联关系,通常设置为true,以指定由多的一端来维护关联关系 -->
        <!-- cascade：设定级联操作.值为delete时删除一的这端时会把多的那端的对应记录也删除.delete-orphan解除关系(删除孤儿).save-update级联保存
             开发时不建议设定该属性.建议使用手工的方式来处理 -->
        <!-- order-by:在查询时对集合中的元素进行排序,order-by中使用的是表的字段名,而不是持久化类的属性名 -->
        
　　　　　　<set name="order" table="ORDERS" inverse="true" order-by="ORDER_NAME DESC"><!-- 对应那个表inverse反转,放弃维护关联关系 -->
            <!-- 指定多的表中的外键列的名字 -->
            <key column="CUSTOMER_ID"></key><!-- 外键名 -->
            <one-to-many class="Order"/><!-- 指定映射的类型 -->
        </set> 

Order类的映射文件：

<class name="Order" table="ORDERS">
        <id name="orderId" type="java.lang.Integer">
            <column name="ORDER_ID" />
            <generator class="native" />
        </id>
       
        <property name="orderName" type="java.lang.String">
            <column name="ORDER_NAME" />
        </property>
        
        <many-to-one name="customer" class="com.nzx.hibernate2.n21.both.Customer" column="CUSTOMER_ID">
            
        </many-to-one>
        

junit类：

package com.nzx.hibernate2.n21.both;

import static org.junit.Assert.*;

import org.hibernate.LazyInitializationException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class HibernateTest {

    

    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;

    @Before
    public void init() {

        // 读取hibernate.cfg.xml文件
        Configuration cfg = new Configuration().configure();

        ServiceRegistry serviceRigestry = new ServiceRegistryBuilder()
                .applySettings(cfg.getProperties()).buildServiceRegistry();

        sessionFactory = cfg.buildSessionFactory(serviceRigestry);

        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }

    @After
    public void destroy() {

        // 关闭session、sessionFactory

        transaction.commit();
        session.close();
        sessionFactory.close();
    }
    
    @Test
    public void testMany2One(){
        Customer customer = new Customer();
        customer.setCustomerName("BB");
        
        Order order1 = new Order();
        order1.setOrderName("ORDER_9");
        
        Order order2 = new Order();
        order2.setOrderName("ORDER_7");
        
        
        //设定关联关系
        order1.setCustomer(customer);
        order2.setCustomer(customer);
        
        customer.getOrder().add(order1);
        customer.getOrder().add(order2);
        
        /*
         * 先插入一的一端
         */
        session.save(customer);
        session.save(order1);
        session.save(order2);
        
        /*
         * 先插入多的一端
         * 
         */
//        session.save(order1);
//        session.save(order2);
//        session.save(customer);
    }
    
    

}