Hibernate多对多
以下使用订单(order)和产品(product)的例子，订单-产品关联保存在表orderitem中
1.使用many-to-many单向关联
<class name="com.tazi.domin.Orders" table="orders" catalog="hib">
<id name="id" type="java.lang.Integer">
<column name="id" />
<generator class="identity" />
</id>
<property name="address" type="java.lang.String">
<column name="address" length="100" />
</property>
<property name="realname" type="java.lang.String">
<column name="realname" length="20" />
</property>
<set name="products" table="orderitem" cascade="save-update">
<key column="order_id" />
<many-to-many class="com.tazi.domin.Product" column="product_id"/>
</set>
</class>
<class name="com.tazi.domin.Product" table="product" catalog="hib" >
<id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="identity" />
</id>
<property name="name" type="java.lang.String">
<column name="NAME" length="200" not-null="true" />
</property>
<property name="price" type="java.lang.Float">
<column name="PRICE" precision="12" scale="0" />
</property>
<property name="description" type="java.lang.String">
<column name="DESCRIPTION" length="2000" />
</property>
</class>
(1).保存数据。
维护关系的一方(order)负责维护关系表orderitem,不负责维护另一方(product).比如session.save(order),就order本身而言，只会生成如下语句：
Hibernate:
insert
into
hib.orders
(address, realname)
values
(?, ?)
Hibernate:
insert
into
orderitem
(order_id, product_id)
values
(?, ?)
所以如果order中的product没有事先和数据库中的记录建立关系的话，执行结果会报错。如果在维护关系的一方(order)的many-to-many中设置了cascade="save-update"等，则由于session.save(order)其实也会导致session.save(product),所以结果正确，如下（orders中有两个products）。
Hibernate:
insert
into
hib.orders
(address, realname)
values
(?, ?)
Hibernate:
insert
into
hib.product
(NAME, PRICE, DESCRIPTION)
values
(?, ?, ?)
Hibernate:
insert
into
hib.product
(NAME, PRICE, DESCRIPTION)
values
(?, ?, ?)
Hibernate:
insert
into
orderitem
(order_id, product_id)
values
(?, ?)
Hibernate:
insert
into
orderitem
(order_id, product_id)
values
(?, ?)
(2).加载数据执行Orders order=(Orders)session.get(Orders.class, 2);
Hibernate:
select
orders0_.id as id5_0_,
orders0_.address as address5_0_,
orders0_.realname as realname5_0_
from
hib.orders orders0_
where
orders0_.id=?
当程序中需要用到order的products成员或设置了lazy="false"后，
Hibernate:
select
orders0_.id as id5_0_,
orders0_.address as address5_0_,
orders0_.realname as realname5_0_
from
hib.orders orders0_
where
orders0_.id=?
Hibernate:
select
products0_.order_id as order1_1_,
products0_.product_id as product2_1_,
product1_.ID as ID4_0_,
product1_.NAME as NAME4_0_,
product1_.PRICE as PRICE4_0_,
product1_.DESCRIPTION as DESCRIPT4_4_0_
from
orderitem products0_
left outer join
hib.product product1_
on products0_.product_id=product1_.ID
where
products0_.order_id=?
使用左连接，从关联表(orderitem)再连到另一方的表(product) .
(3).使用双向关联。即在product的映射配置中增加
<set name="orders" table="orderitem" cascade="save-update" >
<key column="product_id" />
<many-to-many class="com.tazi.domin.Orders" column="order_id"/>
</set>
则如下保存的代码运行会报错：
Product product=new Product();
product.setName("台灯");
product.setPrice(262.3f);
Orders order=new Orders();
order.setRealname("tazi");
order.setAddress("苏州");
order.getProducts().add(product);
order.getProducts().add(product2);
product.getOrders().add(order);
session.save(order);
//执行的sql语句如下
Hibernate:
insert
into
hib.orders
(address, realname)
values
(?, ?)
Hibernate:
insert
into
hib.product
(NAME, PRICE, DESCRIPTION)
values
(?, ?, ?)
Hibernate:
insert
into
orderitem
(order_id, product_id)
values
(?, ?)
Hibernate:
insert
into
orderitem
(product_id, order_id)
values
(?, ?)
可见，同一个order和product的对应关系试图在关联表(orderitem)中保存两次。这是因为多对多的双方地位是相同的，而每一方都会去维护关系。解决办法是在其中一方的many-to-many中加上inverse="true",取消维护关系(即修改或插入orderitem)的行为，此时另一方必须担负起维护关系的责任。运行结果如下：
Hibernate:
insert
into
hib.orders
(address, realname)
values
(?, ?)
Hibernate:
insert
into
hib.product
(NAME, PRICE, DESCRIPTION)
values
(?, ?, ?)
Hibernate:
insert
into
orderitem
(order_id, product_id)
values
(?, ?)
(4).双向关联时，如果双方lazy都为false,则执行加载语句
Product product=(Product)session.get(Product.class, 8);执行的结果是很多select语句，而且语句的个数是无法事先估算的，除非知道数据库表中的数据。因为加载原始product，加载原始product对应的orders,然后每个order都要分别加载对应的product,而新加载出来的对象都要考虑关联对象，直到所有关联对象都已经在session中。
2.分解多对多为两个一对多关联。使用many-to-many的缺点就是无法保存多余的数据(如orderitem中的数量，购买价等)。(推荐)
MyEclipse自动生成的对应于关联表(orderitem)的类和映射文件如下：
类OrderitemId 成员Orders orders;(其实是一个产品，因为order是数据库关键字，表名取为orders，自动生成的类和对象也带了s)Product product;
类Orderitem 成员OrderitemId id;（id为复合主键，组件形式）Integer quantity;(多余的属性)
类Orders 中Set orderItems= new HashSet(0);
<class name="com.tazi.domin.Orderitem" table="orderitem" catalog="hib">
<composite-id name="id" class="com.tazi.domin.OrderitemId">
<key-many-to-one name="orders" class="com.tazi.domin.Orders">
<column name="order_id" />
</key-many-to-one>
<key-many-to-one name="product" class="com.tazi.domin.Product">
<column name="product_id" />
</key-many-to-one>
</composite-id>
<property name="quantity" type="java.lang.Integer">
<column name="quantity" />
</property>
</class>
Product中不保存关联关系。Order中保存one-to-many关系与orderitem关联。在orderitem中保存与Product和Order的关系，这就足够了。另外，为了把维护关系的责任全权托付给orderitem,在Order的one-to-many上加上inverse.如下
<set name="orderItems" cascade="save-update" inverse="true">
<key column="order_id" />
<one-to-many class="com.tazi.domin.OrderItem" />
</set>
保存如下：
Product product=new Product();
product.setName("台灯");
product.setPrice(262.3f);
Orders order=new Orders();
order.setRealname("tazi");
order.setAddress("苏州");
OrderitemId id=new OrderitemId(order, product);
Orderitem orderitem=new Orderitem(id,12);
session.save(order);
session.save(product);
session.save(orderitem);
如果orderitem中的数据是从数据库中事先加载的，则在试图保存orderitem时会先检查数据库中是否已经存在这条(order-product)对应的记录。
Product product=(Product)session.get(Product.class, 11); Orders order=(Orders)session.get(Orders.class, 15); OrderitemId id=new OrderitemId(order, product); Orderitem orderitem=new Orderitem(id,12); order.getOrderItems().add(orderitem);
即使没有save语句，但当session关闭或事务提交时，会自动检查是否有需要更新到数据库的。执行sql语句如下：
Hibernate:
select
product0_.ID as ID4_0_,
product0_.NAME as NAME4_0_,
product0_.PRICE as PRICE4_0_,
product0_.DESCRIPTION as DESCRIPT4_4_0_
from
hib.product product0_
where
product0_.ID=?
Hibernate:
select
orders0_.id as id5_0_,
orders0_.address as address5_0_,
orders0_.realname as realname5_0_
from
hib.orders orders0_
where
orders0_.id=?
Hibernate:
select
orderitems0_.order_id as order1_1_,
orderitems0_.product_id as product2_1_,
orderitems0_.order_id as order1_6_0_,
orderitems0_.product_id as product2_6_0_,
orderitems0_.quantity as quantity6_0_
from
hib.orderitem orderitems0_
where
orderitems0_.order_id=?
Hibernate:
select
orderitem_.order_id,
orderitem_.product_id,
orderitem_.quantity as quantity6_
from
hib.orderitem orderitem_
where
orderitem_.order_id=?
and orderitem_.product_id=?
如果不存在对应关系，则插入到关联表中
Hibernate:
insert
into
hib.orderitem
(quantity, order_id, product_id)
values
(?, ?, ?)
否则报错。
浙公网安备 33010602011771号