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);
     }

 }