hibernate单向多对一映射

 n21:

1.new 两个实体类，一个代表"多"的一端，一个代表"一"的一端.

Customer类：

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

Order类：

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

2.生成关于这两个类的xml文件：

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="n21">

    <!-- 映射类和数据表 -->
    <class name="Order" table="ORDERS">
        <!-- 映射OID和数据表的主键 -->
        <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>

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 package="n21">

    <!-- 映射类和数据表 -->
    <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>
    </class>
</hibernate-mapping>

3.hibernate.cfg.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
    
        <!-- hibernate的基本信息 -->
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql:///hibernate</property>
    
        <!-- hibernate的基本配置 -->
        
        <!-- hibernate使用的数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        
        <!-- 运行时是否打印sql语句 -->
        <property name="show_sql">true</property>
        
        <!-- 运行时是否格式化sql -->
        <property name="format_sql">true</property>
        
        <!-- 生成数据表的策略  这里是更新-->
        <property name="hbm2ddl.auto">update</property>
        
        <!-- 设置hibernate的事务隔离级别 -->
        <property name="connection.isolation">2</property>
        
        <!-- 需要关联的hibernate映射文件 .hbm.xml -->
        <!-- 
        <mapping resource="n21/Customer.hbm.xml"/>
        <mapping resource="n21/Order.hbm.xml"/>
         -->
        <mapping resource="n21/both/Customer.hbm.xml"/>
        <mapping resource="n21/both/Order.hbm.xml"/>
        
        
    </session-factory>
</hibernate-configuration>

4.Hibernate测试类：

package n21;

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 {

    //生产环境中Session和Transaction是不能作为成员变量的,因为可能有并发的问题
    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;
    
    @Before
    public void init(){
        //1.创建一个SessionFactory对象
        //1).创建Configuration对象：对应hibernate的基本配置信息和对象关系映射信息
        Configuration configuration=new Configuration().configure();
        //2).创建一个ServiceRegistry对象：hibernate 4.x新添加的对象
        //hibernate的任何配置和服务都需要在该对象中注册后才能有效.
        ServiceRegistry serviceRegistry=
                new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                                               .buildServiceRegistry();
        //3).获得到SessionFactory对象
        sessionFactory=configuration.buildSessionFactory(serviceRegistry);
        //2.创建一个Session对象
        session=sessionFactory.openSession();
        //3.开启事务
        transaction=session.beginTransaction();
    }
    
    @After
    public void destroy(){
        //5.提交事务
        transaction.commit();
        //6.关闭Session
        session.close();
        //7.关闭SessionFactory对象
        sessionFactory.close();
    }
    
    @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 testManyToOneGet(){
        //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对象是一个代理对象！
    }
    
    @Test
    public void testManyToOneSave(){
        Customer customer=new Customer();
        customer.setCustomerName("AA");
        
        Order order1=new Order();
        order1.setOrderName("ORDER-1");
        
        Order order2=new Order();
        order2.setOrderName("ORDER-2");
        
        //设置关联关系
        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);
    }
}