组合实体模式

组合实体模式（Composite Entity Pattern）是一种企业级设计模式，主要用于 Java EE（J2EE）等企业应用中，用来管理复杂对象之间的依赖关系和数据一致性。它通过将多个相关对象组合成一个单一的实体对象，简化客户端与业务数据的交互，减少数据传输和持久化操作的复杂性。组合实体模式常用于表示复杂的业务对象，如 EJB（Enterprise JavaBeans）中的实体 Bean。

组合实体模式的组成

组合依赖模式通常包含以下几个角色：

1. 组合实体（Composite Entity）：核心对象，代表整个业务实体，包含一组依赖对象，并管理它们的生命周期和数据一致性。
2. 粗粒度对象（Coarse-Grained Object）：组合实体的主要接口，包含对依赖对象的引用，供客户端访问。
3. 依赖对象（Dependent Object）：组合实体内部的细粒度对象，表示业务实体的子部分，通常存储具体数据。
4. 客户端（Client）：通过粗粒度对象访问组合实体，执行业务操作。

工作原理

1. 组合实体作为一个整体，封装了多个依赖对象，维护它们的数据和关系。
2. 客户端通过粗粒度对象与组合实体交互，无需直接操作依赖对象。
3. 组合实体负责同步依赖对象的数据，并处理与持久化层（如数据库）的交互。
4. 当数据发生变化时，组合实体确保所有依赖对象的一致性。

UML 类图

┌────────────────┐
│    Client      │
├────────────────┤
│                │
└────────────────┘
       ↑
       │
┌────────────────┐
│ CompositeEntity│
├────────────────┤
│ coarseGrained  │
│ dependentObjects│
│ setData()      │
│ getData()      │
└────────────────┘
       ↑
       │
┌────────────────┐       ┌────────────────┐
│ CoarseGrained  │       │ DependentObject│
├────────────────┤       ├────────────────┤
│ setData()      │<----->│ data           │
│ getData()      │       └────────────────┘
└────────────────┘

代码示例（以 Java 为例）

以下是一个组合实体模式的实现，模拟一个订单（Order）实体，包含订单详情（OrderDetail）和客户信息（CustomerInfo）：

// 依赖对象：订单详情
class OrderDetail {
    private String itemName;
    private int quantity;

    public OrderDetail(String itemName, int quantity) {
        this.itemName = itemName;
        this.quantity = quantity;
    }

    public String getItemName() {
        return itemName;
    }

    public void setItemName(String itemName) {
        this.itemName = itemName;
    }

    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
}

// 依赖对象：客户信息
class CustomerInfo {
    private String customerName;
    private String address;

    public CustomerInfo(String customerName, String address) {
        this.customerName = customerName;
        this.address = address;
    }

    public String getCustomerName() {
        return customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

// 组合实体
class OrderEntity {
    private OrderDetail orderDetail;
    private CustomerInfo customerInfo;

    public OrderEntity() {
        this.orderDetail = new OrderDetail("默认商品", 1);
        this.customerInfo = new CustomerInfo("默认客户", "默认地址");
    }

    // 设置订单数据
    public void setData(String itemName, int quantity, String customerName, String address) {
        orderDetail.setItemName(itemName);
        orderDetail.setQuantity(quantity);
        customerInfo.setCustomerName(customerName);
        customerInfo.setAddress(address);
        System.out.println("订单数据已更新");
    }

    // 获取订单数据
    public String[] getData() {
        return new String[] {
            "商品: " + orderDetail.getItemName(),
            "数量: " + orderDetail.getQuantity(),
            "客户: " + customerInfo.getCustomerName(),
            "地址: " + customerInfo.getAddress()
        };
    }
}

// 粗粒度对象（通常与组合实体合并，此处为简化直接使用 OrderEntity）
class OrderManager {
    private OrderEntity orderEntity;

    public OrderManager() {
        this.orderEntity = new OrderEntity();
    }

    public void updateOrder(String itemName, int quantity, String customerName, String address) {
        orderEntity.setData(itemName, quantity, customerName, address);
    }

    public void displayOrder() {
        String[] data = orderEntity.getData();
        System.out.println("订单信息：");
        for (String info : data) {
            System.out.println(info);
        }
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        OrderManager orderManager = new OrderManager();

        // 显示初始订单信息
        orderManager.displayOrder();

        // 更新订单信息
        orderManager.updateOrder("手机", 2, "张三", "北京市");
        orderManager.displayOrder();
    }
}

输出：

订单信息：
商品: 默认商品
数量: 1
客户: 默认客户
地址: 默认地址
订单数据已更新
订单信息：
商品: 手机
数量: 2
客户: 张三
地址: 北京市

组合实体模式的特点

• 优点：
• 简化客户端交互：客户端通过粗粒度对象访问组合实体，无需直接操作依赖对象。
• 数据一致性：组合实体管理依赖对象，确保数据同步和一致性。
• 减少网络开销：在分布式系统中，通过粗粒度对象减少远程调用次数。
• 封装复杂性：隐藏依赖对象的创建、更新和持久化逻辑。
• 缺点：
• 设计复杂性增加，特别是在依赖对象较多时。
• 如果业务实体变化频繁，可能需要频繁修改组合实体类。
• 可能导致粗粒度对象过于庞大，职责不够单一。

使用场景

1. 企业级应用中需要管理复杂的业务对象：

• EJB 实体 Bean 中表示复杂的业务实体（如订单、客户）。
• 分布式系统中减少客户端与服务端的交互。

1. 需要确保多个相关对象的数据一致性：

• 订单系统中的订单和订单详情。
• 客户管理系统中的客户信息和联系方式。

1. 需要降低远程调用的开销：

• 在 Java EE 或 SOA（面向服务架构）中，通过粗粒度接口减少网络通信。

注意事项

• 粗粒度与细粒度的平衡：组合实体应合理设计粗粒度接口，避免过于复杂或过于简单。
• 与 DAO 模式的结合：组合实体模式常与数据访问对象（DAO）模式结合，用于处理持久化逻辑。
• 依赖对象的管理：组合实体需负责依赖对象的生命周期管理（如创建、更新、销毁）。
• 适用性：组合实体模式适合复杂的业务实体管理，但在简单系统中可能显得冗余。
• 与 DTO 的区别：
• 组合实体模式关注业务实体的数据一致性和生命周期管理。
• 数据传输对象（DTO）仅用于传输数据，不管理依赖关系。

总结

组合实体模式通过将多个依赖对象组合成一个粗粒度实体，简化了客户端与复杂业务对象的交互，特别适合企业级应用和分布式系统。它通过封装依赖关系和数据一致性逻辑，降低了系统复杂性和网络开销。设计时需注意粗粒度接口的合理性，并结合其他模式（如 DAO）以优化持久化操作。