J2EE模式---组合实体模式

组合实体模式基础概念

组合实体模式（Composite Entity Pattern）是一种企业级设计模式，属于 J2EE 模式的一种，其核心思想是将多个实体对象组合成一个更高层次的对象（组合实体），以简化客户端与这些实体的交互。这种模式常用于 EJB（Enterprise JavaBeans）架构中，通过封装业务实体之间的关系，提供统一的接口给客户端，降低系统复杂度。

组合实体模式的核心组件

1. 组合实体（Composite Entity）

   • 表示高层实体，封装了多个子实体
   • 提供统一的接口给客户端，隐藏内部实体的复杂性
   • 负责管理子实体的生命周期和一致性

2. 粗粒度对象（Coarse-Grained Object）

   • 组合实体的主要实现，包含业务逻辑
   • 协调多个细粒度对象（依赖实体）完成业务操作

3. 依赖实体（Dependent Entity）

   • 细粒度实体，是组合实体的组成部分
   • 通常是持久化对象（如数据库表的映射）
   • 不独立存在，依赖于组合实体

4. 策略（Strategy）

   • 可选组件，定义组合实体的实现策略
   • 允许在运行时切换不同的实现方式

组合实体模式的工作流程

1. 客户端请求：客户端通过组合实体的接口发起业务请求
2. 组合实体协调：组合实体接收请求，调用粗粒度对象处理
3. 粗粒度对象操作：粗粒度对象协调多个依赖实体完成业务逻辑
4. 依赖实体交互：依赖实体执行具体的数据操作（如数据库读写）
5. 结果返回：组合实体将处理结果返回给客户端

组合实体模式的实现

下面通过一个简单的 Java 示例展示组合实体模式的实现：

// 1. 依赖实体 - 地址
class AddressEntity {
    private String street;
    private String city;
    private String zipCode;
    
    public AddressEntity(String street, String city, String zipCode) {
        this.street = street;
        this.city = city;
        this.zipCode = zipCode;
    }
    
    // Getters and setters
    public String getStreet() { return street; }
    public void setStreet(String street) { this.street = street; }
    
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
    
    public String getZipCode() { return zipCode; }
    public void setZipCode(String zipCode) { this.zipCode = zipCode; }
}

// 2. 依赖实体 - 账户
class AccountEntity {
    private String accountId;
    private double balance;
    
    public AccountEntity(String accountId, double balance) {
        this.accountId = accountId;
        this.balance = balance;
    }
    
    // Getters and setters
    public String getAccountId() { return accountId; }
    public void setAccountId(String accountId) { this.accountId = accountId; }
    
    public double getBalance() { return balance; }
    public void setBalance(double balance) { this.balance = balance; }
}

// 3. 粗粒度对象
class CustomerCoarseGrainedObject {
    private AddressEntity address;
    private AccountEntity account;
    
    public CustomerCoarseGrainedObject(String street, String city, String zipCode, 
                                      String accountId, double balance) {
        this.address = new AddressEntity(street, city, zipCode);
        this.account = new AccountEntity(accountId, balance);
    }
    
    // 业务方法 - 更新客户信息
    public void updateCustomer(String street, String city, String zipCode, double newBalance) {
        // 更新地址信息
        address.setStreet(street);
        address.setCity(city);
        address.setZipCode(zipCode);
        
        // 更新账户余额
        account.setBalance(newBalance);
        
        // 持久化到数据库（示例中省略具体实现）
        System.out.println("客户信息已更新到数据库");
    }
    
    // 获取客户信息
    public String getCustomerInfo() {
        return "地址: " + address.getStreet() + ", " + address.getCity() + ", " + address.getZipCode() +
               "\n账户: " + account.getAccountId() + ", 余额: " + account.getBalance();
    }
}

// 4. 组合实体接口
interface CompositeEntity {
    void setData(String street, String city, String zipCode, String accountId, double balance);
    void updateData(String street, String city, String zipCode, double newBalance);
    String getInfo();
}

// 5. 组合实体实现
class CustomerCompositeEntity implements CompositeEntity {
    private CustomerCoarseGrainedObject cgObject;
    
    @Override
    public void setData(String street, String city, String zipCode, String accountId, double balance) {
        cgObject = new CustomerCoarseGrainedObject(street, city, zipCode, accountId, balance);
    }
    
    @Override
    public void updateData(String street, String city, String zipCode, double newBalance) {
        cgObject.updateCustomer(street, city, zipCode, newBalance);
    }
    
    @Override
    public String getInfo() {
        return cgObject.getCustomerInfo();
    }
}

// 6. 客户端代码
public class CompositeEntityPatternDemo {
    public static void main(String[] args) {
        // 创建组合实体
        CompositeEntity customer = new CustomerCompositeEntity();
        
        // 设置客户数据
        customer.setData("123 Main St", "New York", "10001", "ACC12345", 1000.0);
        
        // 获取客户信息
        System.out.println("初始客户信息:");
        System.out.println(customer.getInfo());
        
        // 更新客户信息
        customer.updateData("456 Elm St", "Los Angeles", "90210", 2000.0);
        
        // 获取更新后的信息
        System.out.println("\n更新后的客户信息:");
        System.out.println(customer.getInfo());
    }
}

组合实体模式的应用场景

1. EJB 架构 - 在企业级 Java 应用中，封装多个 Entity Bean 为一个粗粒度对象
2. 数据库事务管理 - 将多个相关实体的操作封装在一个事务中
3. 复杂业务实体 - 当业务实体由多个子实体组成时，简化客户端交互
4. 数据访问层 - 在 ORM 框架（如 Hibernate）中，封装多个实体的查询和操作
5. 分布式系统 - 减少远程调用次数，将多个细粒度服务封装为粗粒度服务
6. 缓存管理 - 将相关实体作为一个整体进行缓存，提高性能

组合实体模式的优缺点

优点：

1. 简化客户端接口 - 客户端只需与组合实体交互，无需了解内部实体的细节
2. 降低耦合度 - 内部实体的变化不会影响客户端代码
3. 提高性能 - 通过批量操作减少数据库访问次数
4. 事务一致性 - 便于管理多个实体之间的事务一致性
5. 集中控制 - 业务逻辑集中在粗粒度对象中，便于维护
6. 支持复用 - 组合实体可以被多个客户端复用

缺点：

1. 过度设计风险 - 对于简单业务场景，使用组合实体模式可能增加复杂度
2. 维护困难 - 粗粒度对象可能变得庞大，包含过多业务逻辑
3. 灵活性降低 - 组合实体的接口一旦确定，修改可能影响多个客户端
4. 性能问题 - 如果组合实体包含过多子实体，可能导致不必要的数据加载
5. 调试复杂 - 多层封装可能增加调试难度
6. 不适合动态变化场景 - 组合实体的结构相对固定，难以适应频繁变化的需求

使用组合实体模式的最佳实践

1. 合理划分组合实体 - 根据业务相关性和内聚性划分组合实体
2. 保持接口简洁 - 组合实体的接口应简洁明了，避免暴露内部细节
3. 控制粒度 - 避免组合实体过于庞大，保持适当的粒度
4. 事务管理 - 在粗粒度对象中实现事务边界控制
5. 懒加载机制 - 对于复杂组合实体，使用懒加载减少不必要的数据加载
6. 缓存策略 - 对频繁访问的组合实体实现缓存机制
7. 与其他模式结合 - 通常与数据访问对象模式（DAO）、策略模式等结合使用
8. 单元测试 - 对组合实体和粗粒度对象进行充分的单元测试

总结

组合实体模式通过将多个相关实体封装为一个更高层次的对象，简化了客户端与这些实体的交互，降低了系统复杂度。它在企业级应用中特别有用，尤其是在需要管理多个实体之间的事务一致性和提高性能的场景。在实际开发中，合理使用组合实体模式可以帮助我们构建更加清晰、高效的系统架构，但需要注意避免过度设计，确保组合实体的结构和接口符合业务需求。