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类：

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

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

Order.hbm.xml:

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 5 
 6 <hibernate-mapping package="n21">
 7 
 8     <!-- 映射类和数据表 -->
 9     <class name="Order" table="ORDERS">
10         <!-- 映射OID和数据表的主键 -->
11         <id name="orderId" type="java.lang.Integer">
12             <column name="ORDER_ID"/>
13             <!-- 指定主键的生成方式 -->
14             <generator class="native"/>
15         </id>
16         
17         <!-- 映射属性和字段 -->
18         <property name="orderName" type="java.lang.String">
19             <column name="ORDER_NAME"/>
20         </property>
21         
22         <!-- 
23             映射多对一的关联关系.使用many-to-one来映射多对一的关联关系
24             name:多这一端关联的一那一端的属性的名字
25             class:多这一端的属性对应一那一端的类名
26             column:一那一端在多的一端对应的数据表中的外键的名字
27          -->
28         <many-to-one name="customer" class="Customer" column="CUSTOMER_ID"></many-to-one>
29     </class>
30 </hibernate-mapping>

Customer.hbm.xml:

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 5 
 6 <hibernate-mapping package="n21">
 7 
 8     <!-- 映射类和数据表 -->
 9     <class name="Customer" table="CUSTOMERS">
10         <!-- 映射OID和数据表的主键 -->
11         <id name="customerId" type="java.lang.Integer">
12             <column name="CUSTOMER_ID"/>
13             <!-- 指定主键的生成方式 -->
14             <generator class="native"/>
15         </id>
16         
17         <!-- 映射属性和字段 -->
18         <property name="customerName" type="java.lang.String">
19             <column name="CUSTOMER_NAME"/>
20         </property>
21     </class>
22 </hibernate-mapping>

3.hibernate.cfg.xml:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 5 <hibernate-configuration>
 6     <session-factory>
 7     
 8         <!-- hibernate的基本信息 -->
 9         <property name="connection.username">root</property>
10         <property name="connection.password">root</property>
11         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
12         <property name="connection.url">jdbc:mysql:///hibernate</property>
13     
14         <!-- hibernate的基本配置 -->
15         
16         <!-- hibernate使用的数据库方言 -->
17         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
18         
19         <!-- 运行时是否打印sql语句 -->
20         <property name="show_sql">true</property>
21         
22         <!-- 运行时是否格式化sql -->
23         <property name="format_sql">true</property>
24         
25         <!-- 生成数据表的策略  这里是更新-->
26         <property name="hbm2ddl.auto">update</property>
27         
28         <!-- 设置hibernate的事务隔离级别 -->
29         <property name="connection.isolation">2</property>
30         
31         <!-- 需要关联的hibernate映射文件 .hbm.xml -->
32         <!-- 
33         <mapping resource="n21/Customer.hbm.xml"/>
34         <mapping resource="n21/Order.hbm.xml"/>
35          -->
36         <mapping resource="n21/both/Customer.hbm.xml"/>
37         <mapping resource="n21/both/Order.hbm.xml"/>
38         
39         
40     </session-factory>
41 </hibernate-configuration>

4.Hibernate测试类：

  1 package n21;
  2 
  3 import org.hibernate.LazyInitializationException;
  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     //生产环境中Session和Transaction是不能作为成员变量的,因为可能有并发的问题
 17     private SessionFactory sessionFactory;
 18     private Session session;
 19     private Transaction transaction;
 20     
 21     @Before
 22     public void init(){
 23         //1.创建一个SessionFactory对象
 24         //1).创建Configuration对象：对应hibernate的基本配置信息和对象关系映射信息
 25         Configuration configuration=new Configuration().configure();
 26         //2).创建一个ServiceRegistry对象：hibernate 4.x新添加的对象
 27         //hibernate的任何配置和服务都需要在该对象中注册后才能有效.
 28         ServiceRegistry serviceRegistry=
 29                 new ServiceRegistryBuilder().applySettings(configuration.getProperties())
 30                                                .buildServiceRegistry();
 31         //3).获得到SessionFactory对象
 32         sessionFactory=configuration.buildSessionFactory(serviceRegistry);
 33         //2.创建一个Session对象
 34         session=sessionFactory.openSession();
 35         //3.开启事务
 36         transaction=session.beginTransaction();
 37     }
 38     
 39     @After
 40     public void destroy(){
 41         //5.提交事务
 42         transaction.commit();
 43         //6.关闭Session
 44         session.close();
 45         //7.关闭SessionFactory对象
 46         sessionFactory.close();
 47     }
 48     
 49     @Test
 50     public void testDelete(){
 51         //在不设定级联关系的情况下,且1这一端的对象有n那一端的对象在引用,不能直接删除1这一端的对象
 52         Customer customer=(Customer) session.get(Customer.class, 1);
 53         session.delete(customer);
 54     }
 55     
 56     @Test
 57     public void testUpdate(){
 58         Order order=(Order) session.get(Order.class, 1);
 59         order.getCustomer().setCustomerName("AAA");
 60     }
 61     
 62     @Test
 63     public void testManyToOneGet(){
 64         //1.若查询多的一端的一个对象,则默认情况下,只查询了多的一端的对象,而没有查询关联的
 65         //一的那一端的对象！--(延迟加载)？
 66         Order order=(Order) session.get(Order.class, 1);
 67         System.out.println(order.getOrderName());
 68         
 69         System.out.println(order.getCustomer().getClass().getName());
 70         
 71         //session.close();
 72         
 73         //2.在需要使用到关联的对象时,才发送对应的SQL语句. 也叫懒加载
 74         Customer customer=order.getCustomer();
 75         System.out.println(customer.getCustomerName());
 76         
 77         //3.在查询Customer对象时,由多的一端导航到1的一端时,
 78         //若此时session已经被关闭,则默认情况下
 79         //会发生LazyInitializationException 异常
 80         
 81         //4.获取Order对象时,默认情况下,其关联的Customer对象是一个代理对象！
 82     }
 83     
 84     @Test
 85     public void testManyToOneSave(){
 86         Customer customer=new Customer();
 87         customer.setCustomerName("AA");
 88         
 89         Order order1=new Order();
 90         order1.setOrderName("ORDER-1");
 91         
 92         Order order2=new Order();
 93         order2.setOrderName("ORDER-2");
 94         
 95         //设置关联关系
 96         order1.setCustomer(customer);
 97         order2.setCustomer(customer);
 98         
 99         //执行save操作:先插入Customer,再插入Order.3条INSERT
100         //先插入1的一端,再插入n的一端,只有INSERT语句
101         session.save(customer);
102         session.save(order1);
103         session.save(order2);
104         
105         //先插入Order,再插入Customer.3条INSERT,2条UPDATE
106         //先插入n的一端,再插入1的一端,会多出UPDATE语句！
107         //原因：因为在插入多的一端时,无法确定1的那端的外键值.所以只能等1的那端插入后,再额外发送UPDATE语句.
108         //推荐先插入1的一端,后插入n的一端
109 //        session.save(order1);
110 //        session.save(order2);
111 //        
112 //        session.save(customer);
113     }
114 }