什么是關聯(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之关联关系（一对多）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。