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