hibernate学习(二)

　　　　　　　　　　　　　　　　　　　　　　　　　　hibernate 单向一对多映射

一.数据表设计

　　数据库名：hibernate5

　　数据表:　　①表名：CUSTOMERS            

　　　　　　　　字段： CUSTOMER_ID

　　　　　　　　　　　 CUSTOMER_NAME

                      ②表名:ORDERS

　　　　　　　　  字段：ORDER_ID

　　　　　　　　　　　　ORDER_NUMBER

　　　　　　　　　　　　CUSTOMER_ID(关联CUSTOMERS表的CUSTOMER_ID,构成单向一对多关系)

二.建立数据表对应的持久化类

　　1.Customers.java

　　　　

package com.hjj.hibernate.entities.n21;
public class Customer {
    private Integer customerId;
    private String customerName;
    
    
    public Customer(String customerName) {
        super();
        this.customerName = customerName;
    }
    
    public Customer() {
        super();
    }

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

    @Override
    public String toString() {
        return "Customer [customerId=" + customerId + ", customerName=" + customerName + "]";
    }    
}

　　2.Orders.java

　　　　

package com.hjj.hibernate.entities.n21;
public class Order {
    private Integer orderId;
    private Customer customer;
    private  Integer  orderNumber;

    public Order() {
    
    }
    public Order(Customer customer, Integer orderNumber) {
        super();
        this.customer = customer;
        this.orderNumber = orderNumber;
    }
    public Integer getOrderId() {
        return orderId;
    }
    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }
    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
    public Integer getOrderNumber() {
        return orderNumber;
    }
    public void setOrderNumber(Integer orderNumber) {
        this.orderNumber = orderNumber;
    }
    @Override
    public String toString() {
        return "Order [orderId=" + orderId + ", customer=" + customer + ", orderNumber=" + orderNumber + "]";
    }
        
}

三.添加对象关系映射文件

　　1.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 2016-3-12 14:51:58 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.hjj.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>

　　

　　2. 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 2016-3-12 14:51:58 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.hjj.hibernate.entities.n21.Order" table="ORDERS">
        <id name="orderId" type="java.lang.Integer">
            <column name="ORDER_ID" />
            <generator class="native" />
        </id>
      
        <property name="orderNumber" type="java.lang.Integer">
            <column name="ORDER_NUMBER" />
        </property>
        
        <!--     name:属性名  所对应的 class:实体类                              -->
        <!-- name: 多这一端关联的 一 那一端的属性的名字
            class:一的那端的类名
            column:一的那端的数据表字段名
        
         -->
        <many-to-one name="customer" class="com.hjj.hibernate.entities.n21.Customer" >
            <column name="CUSTOMER_ID" />
        </many-to-one>
    </class>
</hibernate-mapping>

四.配置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>
    <property name="connection.password">000000</property>
    <property name="connection.username">root</property>
    <property name="connection.url">jdbc:mysql:///hibernate5</property>
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
   
    <property name="dialect"> org.hibernate.dialect.MySQL5InnoDBDialect </property>
    <property name="hbm2ddl.auto">update</property>
    <property name="format_sql">true</property>
    <property name="show_sql">true</property>
  
    <!--  指定关联的 .hbm.xml  -->
    <mapping resource="com/hjj/hibernate/entities/n21/Customer.hbm.xml"/>
    <mapping resource="com/hjj/hibernate/entities/n21/Order.hbm.xml"/>
   
   
    </session-factory>
</hibernate-configuration>

　五.编写访问数据库的代码(使用单元测试类)。

　　1.关于注解@Test @After @Before

　　@Test:

　　　　@Test注解的public void方法将会被当做测试用例,JUnit每次都会创建一个新的测试实例，然后调用@Test注解方法

　　@Arter:

　　　　使用@After注解一个public void方法会使该方法在@Test注解方法执行后被执行

　　@Before

　　　　使用@Before注解一个public void 方法会使该方法在@Test注解方法被执行前执行

　　2. @After和@Before所做的事

　　　　

package com.hjj.hibernate.entities.n21;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class HibernateTest {
    private Session session ;
    private SessionFactory sessionFactory ;
    private Transaction transaction;
    @Before
    public void init(){
        Configuration configuration = new Configuration().configure();
        sessionFactory = configuration.buildSessionFactory();
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
        
    }
    
    @After
    public void destory(){
        transaction.commit();
        session.close();
        sessionFactory.close();
    }
}

　　3.@Test测试用例之save操作

　　　　①第一种save方法:先save customers关联对象(即先save一端),在save多端。

      　@Test
        public void testSave(){
            
            Customer customer = new Customer();
            customer.setCustomerName("BB");
            
            Order order1 = new Order();
            order1.setOrderNumber(11111);
            
            Order order2 = new Order();
            order2.setOrderNumber(22222);
            //设定关联关系
            order1.setCustomer(customer);
            order2.setCustomer(customer);
    
            session.save(customer);
            session.save(order1);
            session.save(order2);
            
        }           

　　　　

　　控制台发送三条insert语句

Hibernate: 
    insert 
    into
        CUSTOMERS
        (CUSTOMER_NAME) 
    values
        (?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NUMBER, CUSTOMER_ID) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NUMBER, CUSTOMER_ID) 
    values
        (?, ?)

　　　　②。第二种save方法:先save order(即先save多端),在save一端。

　　

　　　　@Test
        public void testSave(){
            
            Customer customer = new Customer();
            customer.setCustomerName("BB");
            
            Order order1 = new Order();
            order1.setOrderNumber(11111);
            
            Order order2 = new Order();
            order2.setOrderNumber(22222);
            //设定关联关系
            order1.setCustomer(customer);
            order2.setCustomer(customer);
    
            //save操作：先插入多的一端 在插入一的一端
            
            session.save(order1);
            session.save(order2);
            session.save(customer);
                
        }

　　　控制台会发送三条insert语句，两条update语句.

Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NUMBER, CUSTOMER_ID) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NUMBER, CUSTOMER_ID) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        CUSTOMERS
        (CUSTOMER_NAME) 
    values
        (?)
Hibernate: 
    update
        ORDERS 
    set
        ORDER_NUMBER=?,
        CUSTOMER_ID=? 
    where
        ORDER_ID=?
Hibernate: 
    update
        ORDERS 
    set
        ORDER_NUMBER=?,
        CUSTOMER_ID=? 
    where
        ORDER_ID=?

　　　　③两种save方法的比较，可以明显的出第二种效率不如第一种.因此应该使用第一种save方式

　　　　④以上两种操作数据库表为下:

　　　　　　CUSTOMERS表

　　　　　　

　　　　　　

　　　　　　ORDERS表

　　　　　　

　　4.@Test测试用例之get操作

　　　　①正常编写代码

　　@Test
    public void testGet(){
            Order order = (Order) session.get(Order.class, 1);
            System.out.println(order.getOrderNumber());    
    }

　　　　控制台:

Hibernate:
select
　　order0_.ORDER_ID as ORDER_ID1_2_0_,
　　order0_.ORDER_NUMBER as ORDER_NU2_2_0_,
　　order0_.CUSTOMER_ID as CUSTOMER3_2_0_
from
　　ORDERS order0_
where
　　order0_.ORDER_ID=?

order.getOrderNumber:11111

　　　　可以看出来这里并没有去查询order关联的customer对象。

　　　　②.当使用到的关联对象  或者 关联对象 的属性的时候才会去查询

　　　　

　　@Test
    public void testGet(){
            Order order = (Order) session.get(Order.class, 1);
            System.out.println("order.getOrderNumber:"+order.getOrderNumber());
            Customer customer = order.getCustomer();
            System.out.println(customer);
    
    }

　　　　

　　　　控制台　　

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_2_0_,
        order0_.ORDER_NUMBER as ORDER_NU2_2_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_2_0_ 
    from
        ORDERS order0_ 
    where
        order0_.ORDER_ID=?
order.getOrderNumber:11111
Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Customer [customerId=1, customerName=AAAAA]

　　　　

　　　　　　③对于关联对象hibernate采用的是懒加载:对于 关联的对象 得到的是代理对象

　　@Test
    public void testGet(){
            Order order = (Order) session.get(Order.class, 1);
            System.out.println("order.getOrderNumber:"+order.getOrderNumber());
            System.out.println(order.getCustomer().getClass().getName());
            
    
    }

　　　控制台:

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_2_0_,
        order0_.ORDER_NUMBER as ORDER_NU2_2_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_2_0_ 
    from
        ORDERS order0_ 
    where
        order0_.ORDER_ID=?
com.hjj.hibernate.entities.n21.Customer_$$_jvst392_0   //代理对象

　　5.@Test测试用例之update操作

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

　　控制台打印sql语句且数据库表中字段的记录也会相应的改变:

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_2_0_,
        order0_.ORDER_NUMBER as ORDER_NU2_2_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_2_0_ 
    from
        ORDERS order0_ 
    where
        order0_.ORDER_ID=?
    Hibernate: 
        select
            customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
            customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
        from
            CUSTOMERS customer0_ 
        where
            customer0_.CUSTOMER_ID=?
    Hibernate: 
        update
            CUSTOMERS 
        set
            CUSTOMER_NAME=? 
        where
            CUSTOMER_ID=?

　　6..@Test测试用例之delete操作

　　

1　　 @Test
    public void testMany2OneDelete(){
            Customer customer = session.get(Customer.class,1);
            session.delete(customer);
    
    }

　　这样是会抛出异常:org.hibernate.exception.ConstraintViolationException: could not execute statement

　　因为有多端的对象对它还有引用。因此不能直接删除这个对象.