Hibernate：如何映射聚合？

背景

DDD 是在 Hibernate 之后发现的概念，Hibernate 如何映射 DDD 中的聚合呢？本文给出一种思路。

参考资料：DDD：使用EntityFramework的话，如果只为聚合根设计仓储，其它实体如何处理？。

映射聚合

聚合模型

Order

package model;

import java.util.*;

public class Order {
    private Integer orderId;
    private String customer;
    private Set<OrderItem> orderItems = new HashSet<OrderItem>();

    public Integer getOrderId() {
        return orderId;
    }

    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }

    public String getCustomer() {
        return customer;
    }

    public void setCustomer(String customer) {
        this.customer = customer;
    }

    public Set<OrderItem> getOrderItems() {
        return orderItems;
    }

    public void setOrderItems(Set<OrderItem> orderItems) {
        this.orderItems = orderItems;
    }

}

OrderItem

package model;

import java.io.Serializable;

public class OrderItem implements Serializable {
    private static final long serialVersionUID = 8584993780461202406L;
    private Integer orderId;
    private Integer productId;
    private String product;

    public Integer getProductId() {
        return productId;
    }

    public void setProductId(Integer productId) {
        this.productId = productId;
    }

    public String getProduct() {
        return product;
    }

    public void setProduct(String product) {
        this.product = product;
    }

    public Integer getOrderId() {
        return orderId;
    }

    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }
}

映射配置

Order

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2013-10-7 21:33:57 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
 <class name="model.Order" table="Orders">
  <id name="orderId" type="java.lang.Integer">
   <column name="OrderId"/>
   <generator class="identity"/>
  </id>
  <property generated="never" lazy="false" name="customer" type="java.lang.String">
   <column name="Customer"/>
  </property>
  <set cascade="all,delete-orphan" inverse="true" lazy="true"
   name="orderItems" sort="unsorted" table="OrderITems">
   <key>
    <column name="OrderId"/>
   </key>
   <one-to-many class="model.OrderItem"/>
  </set>
 </class>
</hibernate-mapping>

OrderItem

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2013-10-7 21:33:57 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
 <class name="model.OrderItem" table="OrderItems">
  <composite-id>
   <key-property name="orderId">
    <column name="OrderId"/>
   </key-property>
   <key-property name="productId">
    <column name="ProductId"/>
   </key-property>
   <generator class="assigned"/>
  </composite-id>
  <property generated="never" lazy="false" name="product" type="java.lang.String">
   <column name="Product"/>
  </property>
 </class>
</hibernate-mapping>

重点注意：Order 的 set 指定了 cascade="all 和 delete-orphan" inverse="true"，OrderItem 使用了双主键（不是必须的）。

测试

代码

package demo;

import model.*;

import org.hibernate.*;

/*
 * 测试 聚合设计。
 */
public class AggregateDemo implements Demo {

    @Override
    public void run() {
        SessionHelper.execute(new SessionAction() {

            @Override
            public void action(Session session) {
                Order order = new Order();
                order.setCustomer("段光伟");
                session.save(order);
                
                OrderItem item = new OrderItem();
                item.setOrderId(order.getOrderId());
                item.setProductId(1);
                item.setProduct("苹果");
                order.getOrderItems().add(item);
            }

        });

         SessionHelper.execute(new SessionAction() {
        
         @Override
         public void action(Session session) {
         Order order = (Order) session.get(Order.class, new Integer(1));
         order.getOrderItems()
         .remove(order.getOrderItems().toArray()[0]);
         }
        
         });
    }
}

输出SQL

begin transaction
action
Hibernate: 
    /* insert model.Order
        */ insert 
        into
            Orders
            (Customer) 
        values
            (?)
flush and commit
Hibernate: 
    /* get current state model.OrderItem */ select
        orderitem_.OrderId,
        orderitem_.ProductId,
        orderitem_.Product as Product3_16_ 
    from
        OrderItems orderitem_ 
    where
        orderitem_.OrderId=? 
        and orderitem_.ProductId=?
Hibernate: 
    /* insert model.OrderItem
        */ insert 
        into
            OrderItems
            (Product, OrderId, ProductId) 
        values
            (?, ?, ?)
begin transaction
action
Hibernate: 
    /* load model.Order */ select
        order0_.OrderId as OrderId1_17_0_,
        order0_.Customer as Customer2_17_0_ 
    from
        Orders order0_ 
    where
        order0_.OrderId=?
Hibernate: 
    /* load one-to-many model.Order.orderItems */ select
        orderitems0_.OrderId as OrderId1_17_1_,
        orderitems0_.OrderId as OrderId1_16_1_,
        orderitems0_.ProductId as ProductI2_16_1_,
        orderitems0_.OrderId as OrderId1_16_0_,
        orderitems0_.ProductId as ProductI2_16_0_,
        orderitems0_.Product as Product3_16_0_ 
    from
        OrderItems orderitems0_ 
    where
        orderitems0_.OrderId=?
flush and commit
Hibernate: 
    /* delete model.OrderItem */ delete 
        from
            OrderItems 
        where
            OrderId=? 
            and ProductId=?

备注

还有几个问题还没有深入想：

1. 如何聚合的关联层次很大，聚合根之外的实体的主键的数量也需要相应的增加，开发是否方便呢？还无从验证。
2. 是否有必要为聚合根之外的实体引入一个逻辑主键，这种模式只有 Hibernate 支持，EntityFramework 就不支持。
3. 使用 bag + composite-element 是否也可以？效率会不会太低。

希望朋友们多给点建议。