从顶层抽象到底层实现，构建高内聚、低耦合的代码体系

本篇文章目录：

一、顶层设计：结构化分解四步法，化繁为简

1. 业务全景拆解——从流程到模块
2. 分层架构设计——明确边界，隔离变化
3. 接口契约先行——定义清晰的协作协议
4. 核心流程伪代码——用技术语言描述业务

二、底层实现：面向对象建模三原则，精准抽象

1. 领域对象识别——实体、值对象、聚合根的提炼
2. 富领域模型——拒绝贫血，内聚业务逻辑
3. 模式与原则——策略、状态、依赖倒置的实战应用

三、融合之道：打通分层架构与领域模型的协作链路

1. 依赖倒置原则——领域层与技术实现的解耦
2. 事件驱动架构——用领域事件串联业务流程
3. 防腐层设计——隔离外部依赖，保护核心模型

四、质量保障：可维护代码的四个关键实践

1. 单元测试——以用例驱动领域逻辑验证
2. 模块化约束——用ArchUnit守护架构分层
3. 代码坏味道重构——过长参数、重复逻辑的治理
4. 文档即代码——Swagger + JavaDoc + PlantUML全景呈现

五、演进策略：复杂系统的生长式设计

1. 小步迭代——每次变更只影响单一模块
2. 模式识别——何时引入CQRS、Saga等高级模式
3. 技术债管理——明确重构优先级与边界

一、自上而下的结构化分解（Top-Down Design）

目标：将复杂业务拆解为可管理的模块，定义清晰的系统边界和交互关系。

1.业务领域建模

• 示例：电商订单系统
• 核心流程：下单 → 支付 → 库存扣减 → 物流通知
• 关键模块：订单服务、支付服务、库存服务、物流服务

2.分层架构设计

java

复制

// 分层示例（以订单服务为例）
├── controller         // 表现层：接收HTTP请求，参数校验
│   └── OrderController
├── service           // 应用服务层：编排业务流程
│   └── OrderAppService
├── domain            // 领域层：核心业务逻辑
│   ├── Order         // 聚合根
│   ├── OrderItem     // 值对象
│   └── OrderStatus   // 枚举
└── infrastructure    // 基础设施层：DB、消息队列等实现
    └── OrderRepositoryImpl

3.接口契约先行

java

// 定义服务接口（自顶向下设计）
public interface PaymentService {
    PaymentResult pay(Order order, PaymentRequest request);
}

二、自下而上的面向对象分析（Bottom-Up OO Analysis）

目标：从具体业务场景出发，通过对象建模实现高内聚、低耦合的代码。

1.识别领域对象

• 实体（Entity）：具有唯一标识的对象（如 Order）
• 值对象（Value Object）：无标识，通过属性定义（如 Money）
• 领域服务（Domain Service）：跨实体的业务逻辑（如 OrderValidator）

2.领域模型设计（以订单为例）

// 富领域模型（避免贫血模型）
public class Order {
    private OrderId id;
    private List<OrderItem> items;
    private OrderStatus status;

    // 业务方法内聚到实体中
    public void cancel() {
        if (status != OrderStatus.PAID) {
            throw new IllegalStateException("Only paid orders can be canceled");
        }
        this.status = OrderStatus.CANCELLED;
        this.addDomainEvent(new OrderCancelledEvent(this.id));
    }
}

3.应用设计模式

// 策略模式：支付方式选择
public interface PaymentStrategy {
    void executePayment(Order order, BigDecimal amount);
}

@Component
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void executePayment(Order order, BigDecimal amount) {
        // 调用支付宝API
    }
}

三、关键结合点：分层与对象的协作

1.依赖倒置原则（DIP）

// 领域层定义接口，基础设施层实现
// 领域层
public interface OrderRepository {
    Order findById(OrderId id);
}

// 基础设施层
@Repository
public class JpaOrderRepository implements OrderRepository {
    // 使用JPA实现
}

2.领域事件驱动

// 领域对象发布事件
public class Order {
    private List<DomainEvent> domainEvents;

    public void complete() {
        this.status = OrderStatus.COMPLETED;
        this.domainEvents.add(new OrderCompletedEvent(this.id));
    }
}

// 应用层处理事件
@Service
public class OrderEventHandler {
    @EventListener
    public void handleOrderCompleted(OrderCompletedEvent event) {
        logisticsService.scheduleDelivery(event.getOrderId());
    }
}

四、代码质量保障

1. 单元测试
2. java
3. 复制

@Test 
public void shouldCancelPaidOrder()
{ 
    Order order = new Order(OrderStatus.PAID);                                           
    order.cancel();
   assertEquals(OrderStatus.CANCELLED, order.getStatus()); 
}

1. 模块化约束
2. java
3. 复制

// 使用ArchUnit验证架构分层 
@ArchTest public static final ArchRule domain_layer_rule = classes() .
that().resideInAPackage("..domain..") .should().onlyBeAccessed().
byAnyPackage("..service..", "..domain..");

五、演进式设计

1. 小步迭代：每次需求变更仅修改局部模块（如新增支付方式只需添加PaymentStrategy实现）。
2. 重构信号：
3. 当方法参数超过3个时，考虑封装为值对象。
4. 当if-else逻辑重复时，用策略模式或状态模式重构。

最终目标：通过结构化分解管理复杂度，通过面向对象分析实现灵活扩展，最终形成高内聚、低耦合、易测试的业务代码。