private Integer customerId;

     private String customerName;

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

 <!-- 映射类和数据表 -->

     <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> 

 <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>
         

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

     }

 }