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

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