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

浏览数：24 / 时间：2015年06月09日

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

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

代码如下：

 1 package com.yl.hibernate.entities.n21;
 2 
 3 public class Customer {
 4     
 5     private Integer customerId;
 6     private String customerName;
 7     public Integer getCustomerId() {
 8         return customerId;
 9     }
10     public void setCustomerId(Integer customerId) {
11         this.customerId = customerId;
12     }
13     public String getCustomerName() {
14         return customerName;
15     }
16     public void setCustomerName(String customerName) {
17         this.customerName = customerName;
18     }
19     
20     
21 }

 1 package com.yl.hibernate.entities.n21;
 2 
 3 public class Order {
 4     
 5     private Integer orderId;
 6     private String orderName;
 7     
 8     private Customer customer;
 9 
10     public Integer getOrderId() {
11         return orderId;
12     }
13 
14     public void setOrderId(Integer orderId) {
15         this.orderId = orderId;
16     }
17 
18     public String getOrderName() {
19         return orderName;
20     }
21 
22     public void setOrderName(String orderName) {
23         this.orderName = orderName;
24     }
25 
26     public Customer getCustomer() {
27         return customer;
28     }
29 
30     public void setCustomer(Customer customer) {
31         this.customer = customer;
32     }
33     
34     
35 }

Customer.hbm.xml

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2014-11-26 19:19:40 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping>
 6     <class name="com.yl.hibernate.entities.n21.Customer" table="CUSTOMERS">
 7         <id name="customerId" type="java.lang.Integer">
 8             <column name="CUSTOMER_ID" />
 9             <generator class="native" />
10         </id>
11         <property name="customerName" type="java.lang.String">
12             <column name="CUSTOMER_NAME" />
13         </property>
14     </class>
15 </hibernate-mapping>

Order.hbm.xml

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2014-11-26 19:19:40 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping>
 6     <class name="com.yl.hibernate.entities.n21.Order" table="ORDERS">
 7         <id name="orderId" type="java.lang.Integer">
 8             <column name="ORDER_ID" />
 9             <generator class="native" />
10         </id>
11         <property name="orderName" type="java.lang.String">
12             <column name="ORDER_NAME" />
13         </property>
14         <!-- 映射多对一的映射关系。使用many-to-one 来映射多对一的关联关系
15             name：多这一端关联的一那一端的属性的名字
16             class：一那一端的属性对应的类名
17             column：一那一端在多的一端对应的数据表中的外键的名字
18          -->
19         <many-to-one name="customer" class="com.yl.hibernate.entities.n21.Customer" column="CUSTOMER_ID">
20         </many-to-one>
21        
22     </class>
23 </hibernate-mapping>

测试类：

  1 package com.yl.hibernate.entities.n21;
  2 
  3 
  4 import org.hibernate.Session;
  5 import org.hibernate.SessionFactory;
  6 import org.hibernate.Transaction;
  7 import org.hibernate.cfg.Configuration;
  8 import org.hibernate.service.ServiceRegistry;
  9 import org.hibernate.service.ServiceRegistryBuilder;
 10 import org.junit.After;
 11 import org.junit.Before;
 12 import org.junit.Test;
 13 
 14 public class HibernateTest {
 15 
 16     private SessionFactory sessionFactory;
 17     private Session session;
 18     private Transaction transaction;
 19     
 20     @Before
 21     public void init() {
 22         Configuration configuration = new Configuration().configure();
 23         ServiceRegistry serviceRegistry = 
 24                 new ServiceRegistryBuilder().applySettings(configuration.getProperties())
 25                                             .buildServiceRegistry();
 26 
 27         sessionFactory = configuration.buildSessionFactory(serviceRegistry);
 28         
 29         session = sessionFactory.openSession();
 30 
 31         transaction = session.beginTransaction();
 32     }
 33     @After
 34     public void destory() {
 35         transaction.commit();
 36         
 37         session.close();
 38         
 39         sessionFactory.close();
 40     }
 41     
 42     @Test
 43     public void testMany2OneSave() {
 44         Customer customer = new Customer();
 45         customer.setCustomerName("BB");
 46         
 47         Order order1 = new Order();
 48         order1.setOrderName("ORDER-3");
 49         
 50         Order order2 = new Order();
 51         order2.setOrderName("ORDER-4");
 52         
 53         //设定关联关系
 54         order1.setCustomer(customer);
 55         order2.setCustomer(customer);
 56         
 57         //执行save操作：先插入Customer，再插入Order，3条INSERT
 58         //先插入1的一端，再插入n的一端，只有INSERT语句
 59         /*session.save(customer);
 60         
 61         session.save(order1);
 62         session.save(order2);*/
 63         
 64         //先插入Order，在插入Customer. 3条INSERT, 2条UPDATE
 65         //先插入n的一端，再插入1的一端，会多出UPDATE语句
 66         //因为在插入多的一端时，无法确定1的一端的外键值，所以只能等1的一端插入后，在额外发送UPDATE语句
 67         //推荐先插入1的一端，再插入n的一端
 68         session.save(order1);
 69         session.save(order2);
 70         
 71         session.save(customer);
 72     }
 73     
 74     @Test
 75     public void testMany2OneGet() {
 76         //1.若查询多的一端的一个对象，则默认情况下，只查询了多的一端的对象，而没有查询关联的1的那一端的对象！
 77         Order order = (Order) session.get(Order.class, 2);
 78         System.out.println(order.getOrderName());
 79         //2.在需要使用到关联的对象时，才发送对应的SQL语句
 80         Customer customer = order.getCustomer();
 81         System.out.println(customer.getCustomerName());
 82         
 83         //3.在查询Customer对象时，由多的一端导航到1的一端时，
 84         //若此时，session已被关闭，则默认情况下
 85         //会发生懒加载异常
 86         
 87         //4.获取Order对象时，默认情况下，其关联的Customer对象时一个代理对象！
 88     }
 89     
 90     @Test
 91     public void testUpdate() {
 92         Order order = (Order) session.get(Order.class, 2);
 93         order.getCustomer().setCustomerName("AAA");
 94     }
 95     
 96     @Test
 97     public void testDelete() {
 98         //在不设定级联关系的情况下，且1这一端的对象有 n 的对象在引用， 则不能直接删除1这一端的对象
 99         Customer customer = (Customer) session.get(Customer.class, 1);
100         session.delete(customer);
101     }
102     
103     
104     
105 }