Many relationship of hibernate

1. What is the association (Association)
1.1 association refers references between classes. If the class associated with the class A B, then the referenced class B to class A are defined as attributes of. For example:
public class A {
Private new new B B = B;
public A () {}
}
1.2 Classification association: association can be divided into one to one, one to many / many to one, many-association
correlation direction is

Now we are talking about many

The entities and profile import

Order

/ ** 
 * Hibernate association 
 * many: a plurality of line items corresponding to the order 
 * many-: an order corresponding to the plurality of line items (Note: a line corresponding to a line item) 
 * @author Administrator 
 * 
 * / 
public  class the Order the implements Serializable {
     // order the above mentioned id 
    Private Integer orderId;
     // order number 
    Private String OrderNo; 
    
    // 1.1 refers to the associated reference relationships between classes. If the Order is associated with the class OrderItem,
     // then referenced OrderItem will be defined as the property of the Order. For example: 
    Private the Set <the OrderItem> = OrderItems new new HashSet <the OrderItem> (); 
    
    
    
    
    
    
    public the Set <the OrderItem> getOrderitems () {
        return orderitems;
    }
    public void setOrderitems(Set<OrderItem> orderitems) {
        this.orderitems = orderitems;
    }
    public Integer getOrderId() {
        return orderId;
    }
    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }
    public String getOrderNO() {
        return orderNO;
    }
    public void setOrderNO(String orderNO) {
        this.orderNO = orderNO;
    }
    public Order() {
        super();
    }
    @Override
    public String toString() {
        return "Order [orderId=" + orderId + ", orderNO=" + orderNO + ", orderitems=" + orderitems + "]";
    }
    
    
    
    
}

Order.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
   <class name="com.hmc.hibernate02.entity.Order" table="t_order_hb">
    <id name="orderId" type="java.lang.Integer" column="order_id">
    <!--native:identity(标识列)+sequence(序列)  -->
    <generator class="native"></Generator > 
    </ ID > 
    < Property name = "orderNo" type = "java.lang.String" column = "order_no" /> 
   <-! master key is one of the multi-foreign key   -> 
   <! -  
   .. SELECT * O, O OI * Inner t_order_hb from the Join t_order_item_hb OI 
   ON o.order_id = oi.oid 
    -> 
         
   <-! established relationship   -> 
   <-! 
   name: the entity name attribute defined in the class, multi point 
   cassade: persistent object is used to control how the associated 
   
     -> 
   < SET name = "OrderItems" Cascade = "Save-Update" inverse = "to true" table="t_order_item_hb"  > 
   <! - the specified connection of multi-foreign key column -> 
    < Key column = "OID" > </ Key > 
    <! - the association between the designated entities: one to many   -> 
    <! - - class: the multi-point full path name of the entity class   -> 
    < One-to-MANY class = "com.hmc.hibernate02.entity.OrderItem" /> 
   </ SET > 
   </ class >  
    
    
</ hibernate- Mapping >

 

 

OrderItem

/ ** 
 * corresponding to a plurality of order line items (Note: a line item corresponding to a single line) 
 * @author Administrator 
 * 
 * / 
public  class the OrderItem   the implements the Serializable {
     // line item ID 
    Private Integer OrderItemId;
     // item ID 
    Private Integer the productId;
     // number 
    Private Integer quantity;
     // foreign key column 
    Private Integer OID; 
    
    
    // 1.1 association refers references between classes. If OrderItem associated with the class Order,
     // then referenced Order will be defined as the property OrderItem. For example: 
    Private the Order Order; 
    
    public the Order getOrder () {
        return order;
    }
    public void setOrder(Order order) {
        this.order = order;
    }
    public Integer getOrderItemId() {
        return orderItemId;
    }  
    public void setOrderItemId(Integer orderItemId) {
        this.orderItemId = orderItemId;
    }
    public Integer getProductId() {
        return productId;
    }
    public void setProductId(Integer productId) {
        this.productId = productId;
    }
    public Integer getQuantity() {
        return quantity;
    }
    public void setQuantity(Integer quantity) {
        this.quantity = quantity;
    }
    public Integer getOid() {
        return oid;
    }
    public void setOid(Integer oid) {
        this.oid = oid;
    }
    @Override
    public String toString() {
        return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity
                + ", oid=" + oid + "]";
    }
    
    

 

 

OrderItem.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
   <class name="com.hmc.hibernate02.entity.OrderItem" table="t_order_item_hb">
    <id name="orderItemId" type="java.lang.Integer" column="order_item_id">
    <!--native:identity (identity column) + sequence (Sequence)  = "Native"classGenerator<->
    ></generator>
    </id>
    <property name="productId" type="java.lang.Integer" column="product_id"/>
    <property name="quantity" type="java.lang.Integer" column="quantity"/>
    <property insert="false" update="false" name="oid" type="java.lang.Integer" column="oid"/>
  <!- ->   Name: attribute name of the entity defined in the class, pointing in one direction<-!->establish relationships  
 
  < MANY One-to- name = "Order" Cascade = "Save-Update" class = "com.hmc.hibernate02.entity.Order" > 
  <-! Foreign key column in the multi-party database table, pointing in one direction   - > 
  < column name = "OID" > </ column > 
  </ MANY-to-One > 
  
   </ class >  
    
    
</ Hibernate-Mapping >

 

OrderDao

 public void add(Order order) {
         Session session = SessionFactoryUtils.openSession();
         Transaction transaction = session.beginTransaction();
         session.save(order);
         transaction.commit();
         SessionFactoryUtils.closeSession();
     }
     
     
     public Order get(Order order) {
         Session session = SessionFactoryUtils.openSession();
         Transaction transaction = session.beginTransaction();
          Order o = session.get(Order.class, order.getOrderId());
        //处理懒加载
            if(null!=o) {
                Hibernate.initialize(o.getOrderitems());
            }
         transaction.commit();
         SessionFactoryUtils.closeSession();
         return o;
     }
     
     public void update(Order order){
        
         Session session = SessionFactoryUtils.openSession();
         Transaction transaction = session.beginTransaction();
        //先查，再更新
         Order o = session.get(Order.class, order.getOrderId());
         if(null!=o) {
             //拿到多方
             Set<OrderItem> orderitems = o.getOrderitems();
      
             OrderItem orderItem=null; 
             for (int i = 0; i <=2; i++) {
                 orderItem=new OrderItem();
                 orderItem.setProductId(i);
                 orderItem.setQuantity(i+2);
                 
                 //建立关联关系
                 orderItem.setOrder(o);
                 o.getOrderitems().add(orderItem);
            }
         session.update(o);
         }
         transaction.commit();
         SessionFactoryUtils.closeSession (); 
         
         
     } 
     
     
     
     // cascade delete 
     public  void Delete (Order the Order) { 
         the Session the Session = SessionFactoryUtils.openSession (); 
          the Transaction the Transaction = session.beginTransaction ();
          // first query, delete 
          Order o = Session. GET (. the Order class , order.getOrderId ());
           IF ( null ! = O) { 
              
              / ** 
               * releasing association: first deleted from the table, and then delete the main table 
               * 1) disable cascade delete 
               * 2) first cut from the table, and then delete the main table 
               * 3) maintenance manual Code 
               * / 
              the Set<OrderItem> orderitems = o.getOrderitems();
              for (OrderItem orderItem : orderitems) {
                Session.delete(orderItem);
            }
              Session.delete(o);
          }
          
         
          Transaction.commit();
          SessionFactoryUtils.closeSession();
     }
     

 

Test class for testing OrderDaoTest

Hibernate: 
    select
        order0_.order_id as order_id1_0_0_,
        order0_.order_no as order_no2_0_0_ 
    from
        t_order_hb order0_ 
    where
        order0_.order_id=?
Hibernate: 
    select
        orderitems0_.oid as oid4_1_0_,
        orderitems0_.order_item_id as order_it1_1_0_,
        orderitems0_.order_item_id as order_it1_1_1_,
        orderitems0_.product_id as product_2_1_1_,
        orderitems0_.quantity as quantity3_1_1_,
        orderitems0_.oid as oid4_1_1_ 
    from
        t_order_item_hb orderitems0_ 
    where
        orderitems0_.oid=?
Hibernate: 
    delete 
    from
        t_order_item_hb 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_order_item_hb 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_order_item_hb 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_order_hb 
    where
        order_id=?