202｜分层架构与六边形架构：依赖方向、端口适配器和领域隔离

// ===== 领域层：定义接口 =====
// 文件：domain/repository/OrderRepository.java
package com.example.domain.repository;

import com.example.domain.model.Order;

public interface OrderRepository {
    Order findById(String orderId);
    void save(Order order);
}

// ===== 领域层：使用接口 =====
// 文件：domain/service/OrderService.java
package com.example.domain.service;

import com.example.domain.model.Order;
import com.example.domain.repository.OrderRepository;

public class OrderService {
    private final OrderRepository orderRepository;
    
    // 依赖注入——只需依赖接口，不关心实现
    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
    
    public void placeOrder(Order order) {
        // 领域逻辑...
        orderRepository.save(order);
    }
}

// ===== 基础设施层：实现接口 =====
// 文件：infrastructure/persistence/JdbcOrderRepository.java
package com.example.infrastructure.persistence;

import com.example.domain.model.Order;
import com.example.domain.repository.OrderRepository; // 依赖"倒过来了"
import org.springframework.jdbc.core.JdbcTemplate;

public class JdbcOrderRepository implements OrderRepository {
    private final JdbcTemplate jdbcTemplate;
    
    @Override
    public Order findById(String orderId) {
        // JDBC 实现细节...
    }
    
    @Override
    public void save(Order order) {
        // JDBC 实现细节...
    }
}

# 使用 JDepend 或 ArchUnit 进行依赖检查
# ArchUnit 示例——领域层不应依赖基础设施层
ArchRule domainRule = classes()
    .that().resideInAPackage("..domain..")
    .should().onlyDependOnClassesThat()
    .resideInAnyPackage(
        "..domain..",      // 自身
        "java..",          // JDK
        "jakarta.."        // 标准 API
    );

com.example.order/
├── domain/                          # 领域核心（不依赖任何框架）
│   ├── model/
│   │   ├── Order.java               # 聚合根
│   │   ├── OrderItem.java           # 实体
│   │   ├── Money.java               # 值对象
│   │   └── OrderStatus.java         # 枚举
│   ├── service/
│   │   └── OrderService.java        # 领域服务
│   ├── port/
│   │   ├── driving/                 # 主端口——谁来驱动我
│   │   │   └── PlaceOrderUseCase.java
│   │   └── driven/                  # 从端口——我需要什么
│   │       ├── OrderRepository.java
│   │       ├── PaymentGateway.java
│   │       └── NotificationService.java
│   └── exception/
│       └── InsufficientStockException.java
│
├── application/                     # 应用层（用例编排）
│   └── service/
│       └── PlaceOrderService.java   # 实现 PlaceOrderUseCase
│
├── adapter/                         # 适配器层
│   ├── in/                          # 入站适配器（Driving Adapter）
│   │   ├── web/
│   │   │   └── OrderController.java
│   │   └── consumer/
│   │       └── OrderEventConsumer.java
│   └── out/                         # 出站适配器（Driven Adapter）
│       ├── persistence/
│       │   ├── JpaOrderRepository.java
│       │   └── OrderEntity.java     # JPA 实体（与领域模型分离）
│       ├── payment/
│       │   └── AlipayGateway.java
│       └── notification/
│           └── DingTalkNotificationService.java
│
└── config/                          # 依赖注入配置
    └── BeanConfiguration.java

// ===== 领域模型（纯 POJO，无框架注解）=====
package com.example.order.domain.model;

public class Order {
    private OrderId id;
    private CustomerId customerId;
    private Money totalAmount;
    private OrderStatus status;
    private List<OrderItem> items;
    
    // 业务方法——不关心如何持久化
    public void pay(PaymentDetail payment) {
        if (this.status != OrderStatus.PENDING) {
            throw new IllegalStateException("订单状态不允许支付");
        }
        this.status = OrderStatus.PAID;
        // 发布领域事件
        this.domainEvents.add(new OrderPaidEvent(this.id, payment));
    }
}

// ===== 持久化模型（JPA 实体，仅在基础设施层）=====
package com.example.order.adapter.out.persistence;

@Entity
@Table(name = "orders")
public class OrderEntity {
    @Id
    private String id;
    private String customerId;
    private BigDecimal totalAmount;
    
    @Enumerated(EnumType.STRING)
    private OrderStatusEntity status;
    
    // 工厂方法：领域模型 → 持久化模型
    public static OrderEntity from(Order order) {
        OrderEntity entity = new OrderEntity();
        entity.id = order.getId().getValue();
        entity.customerId = order.getCustomerId().getValue();
        entity.totalAmount = order.getTotalAmount().getValue();
        entity.status = OrderStatusEntity.valueOf(order.getStatus().name());
        return entity;
    }
    
    // 转换方法：持久化模型 → 领域模型
    public Order toDomain() {
        return Order.reconstitute(
            new OrderId(this.id),
            new CustomerId(this.customerId),
            new Money(this.totalAmount),
            OrderStatus.valueOf(this.status.name())
        );
    }
}

// 应用服务——编排用例
public class PlaceOrderService implements PlaceOrderUseCase {
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    private final PaymentGateway paymentGateway;
    
    @Transactional
    public OrderId execute(PlaceOrderCommand command) {
        // 1. 加载聚合
        Order order = Order.create(command.getCustomerId(), command.getItems());
        
        // 2. 调用领域逻辑
        order.validate(inventoryService);
        order.calculateTotal();
        
        // 3. 持久化
        orderRepository.save(order);
        
        // 4. 调用外部服务
        PaymentResult result = paymentGateway.charge(order.getTotalAmount());
        order.confirmPayment(result);
        orderRepository.save(order);
        
        return order.getId();
    }
}

// 反模式：贫血模型
public class Order {
    private String id;
    private OrderStatus status;
    // 只有 getter/setter ... 
}

// 业务逻辑"泄漏"到 Service 中
public class OrderService {
    public void pay(Order order) {
        if (order.getStatus() != OrderStatus.PENDING) { ... }
        order.setStatus(OrderStatus.PAID);
    }
}

// 充血模型
public class Order {
    public void pay() {
        if (this.status != OrderStatus.PENDING) {
            throw new OrderStateException("...");
        }
        this.status = OrderStatus.PAID;
    }
}

@Test
public void domainLayerShouldNotDependOnInfrastructure() {
    JavaClasses classes = new ClassFileImporter()
        .importPackages("com.example.order");
    
    ArchRule rule = classes()
        .that().resideInAPackage("..domain..")
        .should().onlyDependOnClassesThat()
        .resideInAnyPackage(
            "..domain..",
            "java..",
            "jakarta.inject.."
        );
    
    rule.check(classes);
}

@Test
public void domainModelShouldNotHaveFrameworkAnnotations() {
    JavaClasses classes = new ClassFileImporter()
        .importPackages("com.example.order.domain.model");
    
    ArchRule rule = noClasses()
        .should().beAnnotatedWith(Entity.class)
        .orShould().beAnnotatedWith(Table.class);
    
    rule.check(classes);
}