Hibernate----学习（10）----单向多对一映射

1. 单向 n-1 关联只需从 n 的一端可以访问 1 的一端

2.域模型: 从 Order 到 Customer 的多对一单向关联需要在Order 类中定义一个 Customer 属性,

                而在 Customer 类中无需定义存放 Order 对象的集合属性

3.关系数据模型:ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的主键

 4.示例。

   4.1 目录结构。 

 4.2 Customer 类

package com.lishenhuan.hibernate.enety.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;
    }
}

 4.3 Order类

package com.lishenhuan.hibernate.enety.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;
	}
}

4.4  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">
<hibernate-mapping>
    <class name="com.lishenhuan.hibernate.enety.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>

4.5 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">
<hibernate-mapping package="com.lishenhuan.hibernate.enety.n21">
    <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：多这一端关联的一那一端的属性名字
             class：一那一端的属性对应的类类名
             column：一那一端在多的一端的对应的数据表中的外键的名字。
         -->
        <many-to-one name="customer" class="Customer"    column="CUSTOMER_ID"></many-to-one>
    </class>
</hibernate-mapping>

4.6 测试关联类之间的增删改查

package com.lishenhuan.hibernate.enety.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 TestNews {

	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 testN21() {
		Customer customer = new Customer();
		customer.setCustomerName("bb");

		Order order1 = new Order();
		order1.setOrderName("order3");

		Order order2 = new Order();
		order2.setOrderName("order4");

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

		/*
		 * 执行save(先插入1（customer）的一端，再插入n的一端（order）)会执行3条insert语句
		 */
		session.save(customer);
		session.save(order1);
		session.save(order2);

		/*
		 * 执行save(先插入n的一端（order），再插入1（customer）的一端)会执行3条insert语句，再执行2条update语句
		 * 原因：先执行order插入时候，关联的customer还没创建customerId 先为null，创建后会再进行update操作
		 */
		session.save(order1);
		session.save(order2);
		session.save(customer);
	}

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

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

	@Test
	public void testMany2OneGet() {
		// 1. 若查询多的一端的一个对象, 则默认情况下, 只查询了多的一端的对象. 而没有查询关联的
		// 1 的那一端的对象!
		Order order = (Order) session.get(Order.class, 1);
		System.out.println(order.getOrderName());

		System.out.println(order.getCustomer().getClass().getName());

		session.close();

		// 2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句.
		Customer customer = order.getCustomer();
		System.out.println(customer.getCustomerName());

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

		// 4. 获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!

	}

}