Hibernate4.x之映射关系--单向一对多

在领域模型中，类与类之间最普遍的关系就是关联关系
在UML中，关联是有方向的
　　以Customer和Order为例：一个用户能发出多个订单，而一个订单只能属于一个客户。从Order到Customer的关联是多对一关联；而从Customer到Order是一对多关联

单向n-1
　　单向n-1关联只需从n的一端可以访问到1的一端
　　域模型：从Order到Customer的多对一单向关联需要在Order类中定义一个Customer属性，而在Customer类中无需定义存放Order对象的集合属性
　　关系数据模型：ORDER表中的CUSTOMER_ID参照CUSTOMER表的主键

代码如下：

 package com.yl.hibernate.entities.n21;

 public class Customer {

     private Integer customerId;
     private String customerName;
     public Integer getCustomerId() {
         return customerId;
     }
     public void setCustomerId(Integer customerId) {
         this.customerId = customerId;
     }
     public String getCustomerName() {
         return customerName;
     }
     public void setCustomerName(String customerName) {
         this.customerName = customerName;
     }

 }

 package com.yl.hibernate.entities.n21;

 public class Order {

     private Integer orderId;
     private String orderName;

     private Customer customer;

     public Integer getOrderId() {
         return orderId;
     }

     public void setOrderId(Integer orderId) {
         this.orderId = orderId;
     }

     public String getOrderName() {
         return orderName;
     }

     public void setOrderName(String orderName) {
         this.orderName = orderName;
     }

     public Customer getCustomer() {
         return customer;
     }

     public void setCustomer(Customer customer) {
         this.customer = customer;
     }

 }

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 2014-11-26 19:19:40 by Hibernate Tools 3.4.0.CR1 -->
 <hibernate-mapping>
     <class name="com.yl.hibernate.entities.n21.Customer" table="CUSTOMERS">
         <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>
     </class>
 </hibernate-mapping>

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 2014-11-26 19:19:40 by Hibernate Tools 3.4.0.CR1 -->
 <hibernate-mapping>
     <class name="com.yl.hibernate.entities.n21.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：多这一端关联的一那一端的属性的名字
             class：一那一端的属性对应的类名
             column：一那一端在多的一端对应的数据表中的外键的名字
          -->
         <many-to-one name="customer" class="com.yl.hibernate.entities.n21.Customer" column="CUSTOMER_ID">
         </many-to-one>

     </class>
 </hibernate-mapping>

测试类：

 package com.yl.hibernate.entities.n21;

 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() {
         Configuration configuration = new Configuration().configure();
         ServiceRegistry serviceRegistry =
                 new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                                             .buildServiceRegistry();

         sessionFactory = configuration.buildSessionFactory(serviceRegistry);

         session = sessionFactory.openSession();

         transaction = session.beginTransaction();
     }
     @After
     public void destory() {
         transaction.commit();

         session.close();

         sessionFactory.close();
     }

     @Test
     public void testMany2OneSave() {
         Customer customer = new Customer();
         customer.setCustomerName("BB");

         Order order1 = new Order();
         order1.setOrderName("ORDER-3");

         Order order2 = new Order();
         order2.setOrderName("ORDER-4");

         //设定关联关系
         order1.setCustomer(customer);
         order2.setCustomer(customer);

         //执行save操作：先插入Customer，再插入Order，3条INSERT
         //先插入1的一端，再插入n的一端，只有INSERT语句
         /*session.save(customer);

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

         //先插入Order，在插入Customer. 3条INSERT, 2条UPDATE
         //先插入n的一端，再插入1的一端，会多出UPDATE语句
         //因为在插入多的一端时，无法确定1的一端的外键值，所以只能等1的一端插入后，在额外发送UPDATE语句
         //推荐先插入1的一端，再插入n的一端
         session.save(order1);
         session.save(order2);

         session.save(customer);
     }

     @Test
     public void testMany2OneGet() {
         //1.若查询多的一端的一个对象，则默认情况下，只查询了多的一端的对象，而没有查询关联的1的那一端的对象！
         Order order = (Order) session.get(Order.class, 2);
         System.out.println(order.getOrderName());
         //2.在需要使用到关联的对象时，才发送对应的SQL语句
         Customer customer = order.getCustomer();
         System.out.println(customer.getCustomerName());

         //3.在查询Customer对象时，由多的一端导航到1的一端时，
         //若此时，session已被关闭，则默认情况下
         //会发生懒加载异常

         //4.获取Order对象时，默认情况下，其关联的Customer对象时一个代理对象！
     }

     @Test
     public void testUpdate() {
         Order order = (Order) session.get(Order.class, 2);
         order.getCustomer().setCustomerName("AAA");
     }

     @Test
     public void testDelete() {
         //在不设定级联关系的情况下，且1这一端的对象有 n 的对象在引用， 则不能直接删除1这一端的对象
         Customer customer = (Customer) session.get(Customer.class, 1);
         session.delete(customer);
     }

 }