什么是关联(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

实现类和实现类配置

订单实体类

 1 public class Order {
 2     private Integer orderId;
 3     private String orderNo;
 4     //建立了关联关系 一个订单对应着多个订单
 5     private List<OrderItem> orderItems=new ArrayList<>();
 6     private Integer initChildren =0;//0是懒加载 1：false
11
12
13     public Integer getInitChildren() {
14         return initChildren;
15     }
16     public void setInitChildren(Integer initChildren) {
17         this.initChildren = initChildren;
18     }
19     public List<OrderItem> getOrderItems() {
20         return orderItems;
21     }
22     public void setOrderItems(List<OrderItem> orderItems) {
23         this.orderItems = orderItems;
24     }
25     public Integer getOrderId() {
26         return orderId;
27     }
28     public void setOrderId(Integer orderId) {
29         this.orderId = orderId;
30     }
31     public String getOrderNo() {
32         return orderNo;
33     }
34     public void setOrderNo(String orderNo) {
35         this.orderNo = orderNo;
36     }
37     @Override
38     public String toString() {
39         return "Order [orderId=" + orderId + ", orderNo=" + orderNo + "]";
40     }
41
42
43 }

订单实体类配置

 1 <hibernate-mapping>
 2
 3     <class name="three.entity.Order" table="t_hibernate_order">
 4         <id name="orderId" type="java.lang.Integer" column="order_id">
 5             <generator class="increment" />
 6         </id>
 7         <property name="orderNo" type="java.lang.String" column="order_no">
 8         </property>
 9         <!--
10              bag标签：是否横加载，默认是懒加载的 true    懒汉模式
11              name:类的关联属性名
12              cascade： 级联关系  级联新增与修改
13              inverse: 关联关系交给对方控制默认true，当前类不维护关联关系
14
15
16              子标签key:
17              colunn:主表的主键：从表的外键
18              子标签one—to-many:
19              class:外检对应的实体类
20          -->
21         <bag lazy="false" name="orderItems" cascade="save-update" inverse="true" >
22            <key column="oid"></key>
23            <one-to-many class="three.entity.OrderItem"/>
24         </bag>
25
26     </class>
27
28 </hibernate-mapping>

订单项实体类

 1 public class OrderItem {
 2     private Integer orderItemId;
 3     private Integer productId;
 4     private Integer quantity;
 5     private Integer oid;
 6     //建立关联关系   一个订单对应的是一个订单
 7     private Order order;
 8
 9
10     public Order getOrder() {
11         return order;
12     }
13     public void setOrder(Order order) {
14         this.order = order;
15     }
16     public Integer getOrderItemId() {
17         return orderItemId;
18     }
19     public void setOrderItemId(Integer orderItemId) {
20         this.orderItemId = orderItemId;
21     }
22     public Integer getProductId() {
23         return productId;
24     }
25     public void setProductId(Integer productId) {
26         this.productId = productId;
27     }
28     public Integer getQuantity() {
29         return quantity;
30     }
31     public void setQuantity(Integer quantity) {
32         this.quantity = quantity;
33     }
34     public Integer getOid() {
35         return oid;
36     }
37     public void setOid(Integer oid) {
38         this.oid = oid;
39     }
40     @Override
41     public String toString() {
42         return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity
43                 + ", oid=" + oid + "]";
44     }
45
46
47 }

订单项配置

 1 <hibernate-mapping>
 2     <class name="three.entity.OrderItem" table="t_hibernate_order_item">
 3         <id name="orderItemId" type="java.lang.Integer" column="order_item_id">
 4             <generator class="increment" />
 5         </id>
 6         <property name="productId" type="java.lang.Integer" column="product_id">
 7         </property>
 8         <property name="quantity" type="java.lang.Integer" column="quantity">
 9         </property>
10         <property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false">
11         </property>
12         <many-to-one name="order" class="three.entity.Order" column="oid"></many-to-one>
13     </class>
14 </hibernate-mapping>

dao方法

 1 public class DemoDao {
 2     /**
 3      * 为了测试关系型映射文件配置准确
 4      *     讲解insert=false，update=false的用途
 5      * @param order
 6      * @return
 7      */
 8     public Integer addOrder(Order order) {
 9         Session session = SessionFactoryUtils.openSession();
10         Transaction transaction = session.beginTransaction();
11         Integer oid = (Integer)session.save(order);
12         transaction.commit();
13         session.close();
14         return oid;
15     }
16
17     public Integer addOrderItem(OrderItem orderItem) {
18         Session session = SessionFactoryUtils.openSession();
19         Transaction transaction = session.beginTransaction();
20         Integer otid = (Integer)session.save(orderItem);
21         transaction.commit();
22         session.close();
23         return otid;
24     }
25
26
27
28     /**
29      * 为了讲解懒加载的问题（hibernate3.0后所有查询方式默认采用的是懒加载方式）
30      *     1、查单个时存在问题，代理对象已经关闭
31      *     2、查多个存在问题，有性能的问题
32      * @param order
33      * @return
34      */
35     public Order getOrder(Order order) {
36         Session session = SessionFactoryUtils.openSession();
37         Transaction transaction = session.beginTransaction();
38         Order o = session.get(Order.class, order.getOrderId());
39         if(o != null && new Integer(1).equals(order.getInitChildren())) {
40             //强制加载关联对象
41             Hibernate.initialize(o.getOrderItems());
42 //            System.out.println(o.getOrderItems());
43         }
44         transaction.commit();
45         session.close();
46         return o;
47     }
48
49     public List<Order> getOrderList() {
50         Session session = SessionFactoryUtils.openSession();
51         Transaction transaction = session.beginTransaction();
52         List<Order> list = session.createQuery("from Order").list();
53         transaction.commit();
54         session.close();
55         return list;
56     }
57
58     /**
59      * z主表的数据不能随便删除，得先删除从表中对应信息，才能删除主表的信息。
60      * @param order
61      */
62     public void delOrder(Order order) {
63         Session session = SessionFactoryUtils.openSession();
64         Transaction transaction = session.beginTransaction();
65         Order order2 = session.get(Order.class, order.getOrderId());
66         for (OrderItem oi : order2.getOrderItems()) {
67             session.delete(oi);
68         }
69         session.delete(order2);
70 //        session.delete(order);
71         transaction.commit();
72         session.close();
73     }
74
75 }

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("释放资源的");
//    }
@Testpublic 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);}@Testpublic 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);}}@Testpublic 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);}@Testpublic 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);}    }@Testpublic void testDelOrder() {Order order=new Order();order.setOrderId(4);this.demoDao.delOrder(order);}}

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

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

 1 hibernate框架一对多 的执行原理:
 2
 3       1、对hibernate. cfg. xml进行建模，等到sessionfactory对象2、并且拿到mapping resource里 的内容3、拿到了Order . hbm . xm1配置文佳
 4
 5       4、可以再次建模，拿到了three . entity. Order,以及t_ hibernate_ order
 6
 7       类属性、以及表列段
 8
 9       5、生成动态的sql. select  orderId, orderNo from t_hibernate_order;
10
11       孰行sql最終得到meterDat a源数据模型
12
13       orderId, orderNo
14       1  P15
15       5  P67
16       7  P78
17       8  P1019
18       9  P20
19
20       6、Order o1 = Class. forName( "three . entity . Order") . newInstance(0):
21
22       o1. setOrderId(1);
23       o1. setOrderNo(p1)
24
25              最終得到:
26       List<Order> list = new ArrayList();1ist.add(o1);
27             最終1ist中的所有order突例都有値了; (这里只是出来里面的非外键列段，原理完全跟basedao一样)
28       7.处理关联关系：orderIems 哦i的three.entity.OrderItem
29
30                 通过one-to-many这个标签以及class对应的全路径名会找对   应的全路径名队员的专属类
31                 也就是找到了Order.item.xml这个文件，拿到了他之后就可以拿到table t_hibernate_order_item
32       8.select * from t_hibernate_order_item;
33
34                 最终得到了一个list<OrderItem> orderItems
35       9.给order的关联关系属性赋值
36             List<Order> List=new  ArrayList();
37                  for(Order o : list){
38                 o.setOrderItems(orderItems);
39                 }

转载于:https://www.cnblogs.com/AluoKa/p/11191455.html

hibernate之关联关系（一对多）相关推荐

Hibernate 实体关联关系映射----总结
http://lavasoft.blog.51cto.com/62575/39398 Hibernate 实体关联关系映射----总结花了三天的业余时间,终于写完了Hibernate关联关系映射的所 ...
（转）Hibernate关联映射——一对多（多对一）
http://blog.csdn.net/yerenyuan_pku/article/details/70152173 Hibernate关联映射--一对多(多对一) 我们以客户(Customer)与 ...
框架之 hibernate之关联关系映射
案例:完成CRM的联系人的保存操作需求分析 1. 因为客户和联系人是一对多的关系,在有客户的情况下,完成联系人的添加保存操作技术分析之Hibernate的关联关系映射之一对多映射(重点) 1. J ...
Hibernate 一对一关联关系
双向一对一关联关系: 域模型: 例如,部门只有一个部门经理,一个经理也只能管理一个部门.即,Department 中有一个Manager的引用,Manager 中又有一个Department 的引用. ...
Hibernate 注解实现一对多
首先,我们知道,班级与学生是一对多关系.笔者就以此来编写Hibernate注解实现一对多关系. 先上[班级]类:Clazz.java (这里千万不要用class,否则你懂得...),代码如下: pac ...
hibernate关联关系(一对多)
什么是关联(association) 关联指的是类之间的引用关系.如果类A与类B关联,那么被引用的类B将被定义为类A的属性.例如: class B{private String name;}publi ...
（转）Hibernate框架基础——一对多关联关系映射
http://blog.csdn.net/yerenyuan_pku/article/details/52746413 上一篇文章Hibernate框架基础--映射集合属性详细讲解的是值类型的集合(即 ...
Hibernate中双向一对多关联关系
前边我们讲过了单向多对一的关联关系,即在Java代码-hbm.xml配置文件-数据库表格中只是描述了一种类中多个对象可以对应一个其他类对象的关联关系.我们需要在一个类中含有另一个类的引用变量,然后在包 ...
Hibernate的关联关系映射
系统设计的实体间关系分别为:一对一,一对多(多对一),多对多一.一对多(多对一) 一对多,多对一其实一样,只是站在不同的角度看,这种情况在多的一方添加一的一方的主键为外键.以学生Student和班级 ...

hibernate之关联关系（一对多）

Hibrnate一对多实现

实现类和实现类配置

hibernate之关联关系（一对多）相关推荐

最新文章

热门文章