hibernate之关联关系（一对多）

什么是关联(association)？

 关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。例如:
class B{
private String name;
}
public class A{
private B b = new B;
public A(){}
}

关联的分类：关联可以分为一对一、一对多/多对一、多对多关联

关联是有方向的

Hibrnate一对多实现

数据库t_hibernate_order_item

t_hibernate_order

实现类和实现类配置

订单实体类

public class Order {
    private Integer orderId;
    private String orderNo;
    //建立了关联关系 一个订单对应着多个订单
    private List<OrderItem> orderItems=new ArrayList<>();
    private Integer initChildren =0;//0是懒加载 1：false
    
    
    public Integer getInitChildren() {
        return initChildren;
    }
    public void setInitChildren(Integer initChildren) {
        this.initChildren = initChildren;
    }
    public List<OrderItem> getOrderItems() {
        return orderItems;
    }
    public void setOrderItems(List<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;
    }
    @Override
    public String toString() {
        return "Order [orderId=" + orderId + ", orderNo=" + orderNo + "]";
    }
    

}

订单实体类配置

<hibernate-mapping>
  
    <class name="three.entity.Order" table="t_hibernate_order">
        <id name="orderId" type="java.lang.Integer" column="order_id">
            <generator class="increment" />
        </id>
        <property name="orderNo" type="java.lang.String" column="order_no">
        </property>
        <!-- 
             bag标签：是否横加载，默认是懒加载的 true    懒汉模式
             name:类的关联属性名
             cascade： 级联关系  级联新增与修改
             inverse: 关联关系交给对方控制默认true，当前类不维护关联关系
             
             
             子标签key:
             colunn:主表的主键：从表的外键
             子标签one—to-many:
             class:外检对应的实体类             
         -->
        <bag lazy="false" name="orderItems" cascade="save-update" inverse="true" >
           <key column="oid"></key>
           <one-to-many class="three.entity.OrderItem"/>
        </bag>
        
    </class>

</hibernate-mapping>

订单项实体类

public class OrderItem {
    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;
    }
    @Override
    public String toString() {
        return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity
                + ", oid=" + oid + "]";
    }
    

}

订单项配置

<hibernate-mapping>
    <class name="three.entity.OrderItem" table="t_hibernate_order_item">
        <id name="orderItemId" type="java.lang.Integer" column="order_item_id">
            <generator class="increment" />
        </id>
        <property name="productId" type="java.lang.Integer" column="product_id">
        </property>
        <property name="quantity" type="java.lang.Integer" column="quantity">
        </property>
        <property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false">
        </property>
        <many-to-one name="order" class="three.entity.Order" column="oid"></many-to-one>
    </class>
</hibernate-mapping>

dao方法

public class DemoDao {
    /**
     * 为了测试关系型映射文件配置准确
     *     讲解insert=false，update=false的用途
     * @param order
     * @return
     */
    public Integer addOrder(Order order) {
        Session session = SessionFactoryUtils.openSession();
        Transaction transaction = session.beginTransaction();
        Integer oid = (Integer)session.save(order);
        transaction.commit();
        session.close();
        return oid;
    }
    
    public Integer addOrderItem(OrderItem orderItem) {
        Session session = SessionFactoryUtils.openSession();
        Transaction transaction = session.beginTransaction();
        Integer otid = (Integer)session.save(orderItem);
        transaction.commit();
        session.close();
        return otid;
    }
    
    
    
    /**
     * 为了讲解懒加载的问题（hibernate3.0后所有查询方式默认采用的是懒加载方式）
     *     1、查单个时存在问题，代理对象已经关闭
     *     2、查多个存在问题，有性能的问题
     * @param order
     * @return
     */
    public Order getOrder(Order order) {
        Session session = SessionFactoryUtils.openSession();
        Transaction transaction = session.beginTransaction();
        Order o = session.get(Order.class, order.getOrderId());
        if(o != null && new Integer(1).equals(order.getInitChildren())) {
            //强制加载关联对象
            Hibernate.initialize(o.getOrderItems());
//            System.out.println(o.getOrderItems());
        }
        transaction.commit();
        session.close();
        return o;
    }
    
    public List<Order> getOrderList() {
        Session session = SessionFactoryUtils.openSession();
        Transaction transaction = session.beginTransaction();
        List<Order> list = session.createQuery("from Order").list();
        transaction.commit();
        session.close();
        return list;
    }
    
    /**
     * z主表的数据不能随便删除，得先删除从表中对应信息，才能删除主表的信息。
     * @param order
     */
    public void delOrder(Order order) {
        Session session = SessionFactoryUtils.openSession();
        Transaction transaction = session.beginTransaction();
        Order order2 = session.get(Order.class, order.getOrderId());
        for (OrderItem oi : order2.getOrderItems()) {
            session.delete(oi);
        }
        session.delete(order2);
//        session.delete(order);
        transaction.commit();
        session.close();
    }

}

DemoDaoTest junit测试类

public class DemoDaoTest {
    
    private DemoDao demoDao =new DemoDao();
    

//    @Before
//    public void setUp() throws Exception {
//        System.out.println("加载资源的");
//    }
//
//    @After
//    public void tearDown() throws Exception {
//        System.out.println("释放资源的");
//    }

    @Test
    public void testAddOrder() {
        Order order=new Order();
        order.setOrderNo("P20");
        OrderItem orderItem=null;
        for(int i=0;i<6;i++) {
            orderItem =new OrderItem();
            orderItem.setProductId(10+i);
            orderItem.setQuantity(20+i);
            //维护关联关系
            orderItem.setOrder(order);
            order.getOrderItems().add(orderItem);
        }
        demoDao.addOrder(order);
    }

    @Test
    public void testAddOrderItem() {
        OrderItem orderItem=null;
        for(int i=0;i<6;i++) {
            orderItem =new OrderItem();
            orderItem.setProductId(10+i);
            orderItem.setQuantity(20+i);
            //维护关联关系
            Order order=new Order();
            order.setOrderId(3);
            order.getOrderItems().add(orderItem);
            orderItem.setOrder(order);
            demoDao.addOrderItem(orderItem);
            
        }
    }

    @Test
    public void testGetOrder() {
        Order order=new Order();
        order.setOrderId(4);
        order.setInitChildren(1);
        Order o=this.demoDao.getOrder(order);
        //failed to lazily initialize a collection of role:
        //three.entity.Order.orderItems,
        //could not initialize proxy - no Session
        //原因， 操作了两次数据库，当lazy=false的时候，会让hibernate执行完两次操作，session才会关闭
        //当lazy=true 的时候，会让hibernate执行完一次操作，session就会关闭
        //从上面看lazy=false更好  但是为什么hibernate默认让他等于true
        //出于性能的考虑  所以hibernate3.0出现lazy这个属性，并让他默认等于true，也就是说不加载关联属性
        List<OrderItem> orderItems=o.getOrderItems();
        for(OrderItem orderItem : orderItems) {
            System.out.println(orderItem);
        }
        System.out.println(o);
    }

    @Test
    public void testGetOrderList() {
        List<Order> orderList=this.demoDao.getOrderList();
        for(Order order : orderList) {
            for(OrderItem orderItem : order.getOrderItems()) {
                System.out.println(orderItem);
            }
            System.out.println(order);
        }    }

    @Test
    public void testDelOrder() {
        Order order=new Order();
        order.setOrderId(4);
        this.demoDao.delOrder(order);
    }

}

以上有详细的代码，大家可以去测试测试

hibernate框架一对多 的执行原理:

hibernate框架一对多 的执行原理:

      1、对hibernate. cfg. xml进行建模，等到sessionfactory对象2、并且拿到mapping resource里 的内容3、拿到了Order . hbm . xm1配置文佳

      4、可以再次建模，拿到了three . entity. Order,以及t_ hibernate_ order

      类属性、以及表列段

      5、生成动态的sql. select  orderId, orderNo from t_hibernate_order;

      孰行sql最終得到meterDat a源数据模型

      orderId, orderNo
      1  P15  
      5  P67  
      7  P78  
      8  P1019 
      9  P20

      6、Order o1 = Class. forName( "three . entity . Order") . newInstance(0):

      o1. setOrderId(1);
      o1. setOrderNo(p1)

             最終得到:
      List<Order> list = new ArrayList();1ist.add(o1);
            最終1ist中的所有order突例都有値了; (这里只是出来里面的非外键列段，原理完全跟basedao一样)
      7.处理关联关系：orderIems 哦i的three.entity.OrderItem 
        
                通过one-to-many这个标签以及class对应的全路径名会找对   应的全路径名队员的专属类
                也就是找到了Order.item.xml这个文件，拿到了他之后就可以拿到table t_hibernate_order_item
      8.select * from t_hibernate_order_item;
      
                最终得到了一个list<OrderItem> orderItems
      9.给order的关联关系属性赋值
            List<Order> List=new  ArrayList();
                 for(Order o : list){
                o.setOrderItems(orderItems);
                }