Hibernate关联关系

一、一对多的配置及懒加载查询 1、一对多 1.1、关联指的是类之间的引用关系。

如果类A与类B关联，那么被引用的类B将被定义为类A的属性。

1.2、一对多的关联：

例如：订单和订单项，一个订单有多个订单项，    但是一个订单项只有一个订单；

数据库：主表从表，通过外键关联

类：

class A{

B b;

}

class B{

}

1.3、 示例：Order与Order_item（一个订单对应的多个订单项，但一个订单项只有一个订单） 实体类：Order

//注意：变量属性一定用接口进行接受
    private Set orderItems = new HashSet<>();
    
    private Integer initOrderItems = 0;//0代表懒加载，1代表强制加载

package com.xhy.two.entity;
 
import java.util.HashSet;
import java.util.Set;
 
public class Order {
//    create table t_hibernate_order
//    (
//      order_id int primary key auto_increment,
//      order_no varchar(50) not null
//    );
    private Integer orderId;
    private String orderNo;
    
    //注意：变量属性一定用接口进行接受
    private Set orderItems = new HashSet<>();
    
    private Integer initOrderItems = 0;//0代表懒加载，1代表强制加载
    
    
    public Integer getInitOrderItems() {
        return initOrderItems;
    }
    public void setInitOrderItems(Integer initOrderItems) {
        this.initOrderItems = initOrderItems;
    }
    public Set getOrderItems() {
        return orderItems;
    }
    public void setOrderItems(Set 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;
    }
    
}

实体类 ：OrderItem

package com.xhy.two.entity;
 
public class OrderItem {
//    create table t_hibernate_order_item
//    (
//      order_item_id int primary key auto_increment,
//      product_id int not null,
//      quantity int not null,
//      oid int not null,
//      foreign key(oid) references t_hibernate_order(order_id)
//    );
    private Integer orderItemId;
    private Integer productId;
    private Integer quantity;
    private Integer oid;
    
    private Order order;
    public 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;
    }
    
}

映射文件Order.hbm.xml

对于订单来说属于一对多 使用标签one-to-many  class为订单项的全限定名

 name属性是属性名  key表示外键列 ；

    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">


    
        
    
    
    
    
    
    
        
        
    

2、懒加载 工具类：sessionFactory

package com.zking.util;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 

public class SessionFactoryUtil {
    static SessionFactory sessionFactory;
    static {
        Configuration configure = new Configuration().configure("hibernate.cfg.xml");
        sessionFactory = configure.buildSessionFactory();
    }
    
    public static Session getSession() {
        Session session = sessionFactory.getCurrentSession();
        if(session == null) {
            session = sessionFactory.openSession();
        }
        return session;
    }
    
    public static void main(String[] args) {
        Session session = SessionFactoryUtil.getSession();
//        Calling method 'isConnected' is not valid without an active transaction (Current status: NOT_ACTIVE)
        session.beginTransaction();
        System.out.println(session.isConnected());
        session.close();
        System.out.println(session.isConnected());
    }
}

Dao方法：OrderDao

package com.xhy.two.Dao;
 
import java.util.Iterator;
import java.util.List;
 
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
 
import com.xhy.two.entity.Order;
import com.xhy.two.entity.OrderItem;
import com.zking.util.SessionFactoryUtil;
 
 
 
public class OrderDao {
    public Order get(Order order) {
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        Order o = session.get(Order.class, order.getOrderId());
//        并且想要查询出关联的订单项的数据是，采用强制加载
        if(o != null && new Integer(1).equals(order.getInitOrderItems())) {
            Hibernate.initialize(o.getOrderItems());
//        强制加载订单关联的订单项数据
            Hibernate.initialize(o.getInitOrderItems());
            
        }
        
        transaction.commit();
        session.close();
        return o;
    }
    
    public List list() {
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        List list = session.createQuery("from Order").list();
        for (Order o: list) {
            Hibernate.initialize(o.getOrderItems());
        }
        transaction.commit();
        session.close();
        return list;
    }
    
    public void delete(Order order) {
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        
        Order o = session.get(Order.class, order.getOrderId());
        for(OrderItem oi:o.getOrderItems()) {
            session.delete(oi);
        }
        session.delete(o);
        
        transaction.commit();
        session.close();
    }
}

Dao方法：OrderItemDao

package com.xhy.two.Dao;
 
import org.hibernate.Session;
import org.hibernate.Transaction;
 
import com.xhy.two.entity.OrderItem;
import com.zking.util.SessionFactoryUtil;
 
public class OrderItemDao {
    public OrderItem get(OrderItem orderItem) {
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        OrderItem oi = session.get(OrderItem.class, orderItem.getOrderItemId());
        transaction.commit();
        session.close();
        return oi;
    }
}
 

配置hibernate.cfg.xml

  
         
          
 

测试：OrderDaoTest

package com.xhy.two.Dao;
 
import java.util.List;
import org.junit.Test;
import com.xhy.two.entity.Order;
 
 
public class OrderDaoTest {
    private OrderDao orderDao = new OrderDao();
 
    
    @Test
    public void testGet() {
        Order order = new Order();
        order.setOrderId(7);
//        order.setInitOrderItems(1);
        Order o = this.orderDao.get(order);
        System.out.println(o.getOrderNo());
//        System.out.println(o.getOrderItems());
    }
    
    @Test
    public void testList() {
        List list = this.orderDao.list();
        for (Order o : list) {
            System.out.println(o.getOrderNo());
//            System.out.println(o.getOrderItems().size());
        }
    }
    
    @Test
    public void testDelete() {
        Order order = new Order();
        order.setOrderId(6);
        this.orderDao.delete(order);
    }
 

}

 当运行testGet() 时，正常拿到订单，当解开注解需要一并拿到订单项时会报错

 

报错原因：默认使用懒加载，在执行完上面那个输出时就已经关闭session了，所以会报错，该错误是需要强制加载，就是强制加载与订单关联的订单项数据

解决：解开注释，并设置为  1  ，强制加载，订单关联的订单项数据全部呈现出来：

 order.setInitOrderItems(1);

性能调优（解释了hibernate默认采用懒加载的原因）

实际场景：

        1、只使用订单表的数据——希望懒加载

        2、需要同时使用订单以及当单项表数据——不希望懒加载

二、一对多的子关联

分析（模拟环境：树形菜单）：

一对多的自关联是指自己可以有多个子节点，但父节点只有一个，并且是在自己本身的表里

实体类：TreeNode 

第一个为父节点（父节点只有一个）

第二个为子节点（子节点可能有多个所以用集合包起来）

第三个为懒加载（0为懒加载，1为强制加载）

private TreeNode parent;
    private Set children = new HashSet();
    private Integer initChildren = 0;

package com.zking.two.entity;
 
import java.util.HashSet;
import java.util.Set;
 
public class TreeNode {
    private Integer nodeId;
    private String nodeName;
    private Integer treeNodeType;
    private Integer position;
    private String url;
    private TreeNode parent;
    private Set children = new HashSet();
    private Integer initChildren = 0;
 
    public Integer getNodeId() {
        return nodeId;
    }
 
    public void setNodeId(Integer nodeId) {
        this.nodeId = nodeId;
    }
 
    public String getNodeName() {
        return nodeName;
    }
 
    public void setNodeName(String nodeName) {
        this.nodeName = nodeName;
    }
 
    public Integer getTreeNodeType() {
        return treeNodeType;
    }
 
    public void setTreeNodeType(Integer treeNodeType) {
        this.treeNodeType = treeNodeType;
    }
 
    public Integer getPosition() {
        return position;
    }
 
    public void setPosition(Integer position) {
        this.position = position;
    }
 
    public String getUrl() {
        return url;
    }
 
    public void setUrl(String url) {
        this.url = url;
    }
 
    public TreeNode getParent() {
        return parent;
    }
 
    public void setParent(TreeNode parent) {
        this.parent = parent;
    }
 
    public Set getChildren() {
        return children;
    }
 
    public void setChildren(Set children) {
        this.children = children;
    }
 
    public Integer getInitChildren() {
        return initChildren;
    }
 
    public void setInitChildren(Integer initChildren) {
        this.initChildren = initChildren;
    }
 
//    @Override
//    public String toString() {
//        return "TreeNode [nodeId=" + nodeId + ", nodeName=" + nodeName + ", treeNodeType=" + treeNodeType
//                + ", position=" + position + ", url=" + url + ", children=" + children + "]";
//    }
 
    @Override
    public String toString() {
        return "TreeNode [nodeId=" + nodeId + ", nodeName=" + nodeName + ", treeNodeType=" + treeNodeType
                + ", position=" + position + ", url=" + url + "]";
    }
    
 

}

Dao：TreeNodeDao 

package com.zking.two.dao;
 
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
 
import com.zking.two.entity.TreeNode;
import com.zking.util.SessionFactoryUtil;
 
public class TreeNodeDao {
    public TreeNode load(TreeNode treeNode) {
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        TreeNode t = session.load(TreeNode.class, treeNode.getNodeId());
        if(t != null && new Integer(1).equals(treeNode.getInitChildren())) {
            Hibernate.initialize(t.getChildren());
            Hibernate.initialize(t.getParent());
        }
        transaction.commit();
        session.close();
        return t;
    }

}

映射TreeNode.hbm.xml

    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

    
        
            
        
                     column="tree_node_name">
        
                     column="tree_node_type">
        
                     column="position">
        
                     column="url">
        
        
        
        
        
            
            
        
    

 

配置：hibernate.cfg.xml

   

测试： 

public void testLoad() {
        TreeNode treeNode = new TreeNode();
        treeNode.setNodeId(6);
        treeNode.setInitChildren(1);
        
        TreeNode t = this.treeNodeDao.load(treeNode);
        System.out.println(t);//当前节点
        System.out.println(t.getParent());//父节点
        System.out.println(t.getChildren());//父节点的子节点
    }
 

三、多对多

相当于是两个一对多，中间表里有两个表的外键，两个表分别与中间表都是一个一对多

 table：中间表，中间表的数据由框架维护
        name：关联属性
        inverse：（true）反转，也就是中间表的数据由另一张表维护。

        (false）也就是中间表的数据由自己维护
                        两张表都是false时，数据会产生两条
                        两张表都是true时，数据不会产生
                        一张表为false，一张表为true，数据能够正常维护

        key:当前表的主键在中间表的外键

        many-to-many：当前表的主键在中间表查出另一表的外键

book.hbm.xml

    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

   

       
           
       
                    column="book_name">
       
                    column="price">
       
       
           
           
           
           
       
   

 

category.hbm.xml

    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

   
       
           
       
                    column="tree_node_name">
       
                    column="tree_node_type">
       
                    column="position">
       
                    column="url">