微服务拆分策略：DDD 驱动设计原则

DDD 领域驱动设计

战略设计

1. 识别限界上下文

// 限界上下文：用户上下文
@ContextSpec
public class UserContext {
    @Context
    private String currentUserId;
    
    @Context
    private Set<String> permissions;
    
    @Context
    private String tenantId;
}
​

2. 识别聚合根

// 聚合根：用户
@AggregateRoot
public class User {
    @Embedded
    private UserId userId;
    
    @Embedded
    private UserName name;
    
    @Email
    @Embedded
    EmailAddress email;
    
    @OneToMany(mappedBy = "user")
    private Set<Order> orders;
    
    public void addOrder(Order order) {
        this.orders.add(order);
    }
}
​

战术设计

值对象（Value Object）

public class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    private Money(BigDecimal amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
    }
    
    public Money add(Money other) {
        if (other == null || other.currency != this.currency) {
            throw new IllegalArgumentException("Currency mismatch");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
}
​

实体（Entity）

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Embedded
    private OrderId orderId;
    
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
    
    @Embedded
    OrderStatus status;
    
    @Embedded
    ShippingInfo shippingInfo;
    
    @OneToMany(mappedBy = "order")
    private List<OrderItem> items;
}
​

拆分策略

1. 按业务能力拆分

# 拆分原则
服务应该：
- 单一职责
- 高内聚低耦合
- 独立部署
- 拥有独立的数据存储
​

用户服务

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User findById(UserId userId) {
        return userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException(userId));
    }
    
    public User create(User user) {
        return userRepository.save(user);
    }
}
​

订单服务

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private UserService userService;
    
    public Order createOrder(OrderRequest request) {
        User user = userService.findById(request.getUserId());
        
        Order order = new Order(user, request);
        return orderRepository.save(order);
    }
}
​

2. 按领域拆分

订单域

@Domain
public class Order {
    public Order place(OrderCommand command) {
        // 业务逻辑
        OrderId orderId = command.getOrderId();
        UserId userId = command.getUserId();
        
        // 验证订单
        validateOrder(command);
        
        // 创建订单
        Order order = new Order(userId, orderId);
        
        // 发布领域事件
        publishOrderCreated(order);
        
        return order;
    }
    
    private void validateOrder(OrderCommand command) {
        // 业务规则验证
        if (command.getTotalAmount().isNegative()) {
            throw new InvalidOrderException("金额不能为负");
        }
    }
}
​

服务通信

1. 同步通信（REST）

@Service
public class OrderController {
    @Autowired
    private ProductService productService;
    
    @PostMapping("/orders/{order}/items")
    @ResponseStatus(HttpStatus.CREATED)
    ItemInfo addItem(@PathVariable("order") Order order, 
                      @RequestBody AddItemRequest request) {
        // 调用商品服务
        Product product = productService.getProduct(request.getProductId());
        
        // 添加订单项
        order.addItem(request.getProductId(), request.getQuantity());
        
        return ItemInfo.of(product);
    }
}
​

2. 异步通信（消息队列）

事件驱动架构

@Component
public class OrderEventPublisher {
    @Autowired
    ApplicationEventPublisher eventPublisher;
    
    public void publishOrderCreated(Order order) {
        OrderCreatedEvent event = new OrderCreatedEvent(order);
        
        eventPublisher.publishEvent(event);
    }
}

@Component
class InventoryService {
    @EventListener
    void handleOrderCreated(OrderCreatedEvent event) {
        // 库存扣减
        inventoryService.deduct(event.getOrderId(), event.getItems());
    }
}
​

数据管理

1. 每个服务一个数据库

``yaml

Order Service

spring:
datasource:
url: jdbc:postgresql://localhost:5432/order_db
username: order_user
password: order_pass
jpa:
hibernate:
ddl-auto: update
show-sql: false

### 2. 共享数据库（需要精心设计）

```sql
-- 按前缀分离表
CREATE TABLE users (
    id BIGSERIAL PRIMARY KEY,
    username VARCHAR(50),
    ...
);

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    user_id BIGINT,
    ...
    FOREIGN KEY (user_id) REFERENCES users(id)
);
​

3. 数据一致性

// Saga 模式
@SagaOrchestration(
    saga = "OrderCreationSaga"
)
public class OrderCreationSaga {
    
    @SagaStep(name = "createOrder", compensate = "deleteOrder")
    OrderCreated createOrder(CreateOrderCommand command) {
        // 创建订单
        Order order = orderService.create(command);
        return new OrderCreated(order.getId());
    }
    
    @SagaStep(name = "reserveInventory", compensate = "releaseInventory")
    Void reserveInventory(OrderCreated event) {
        inventoryService.reserve(event.getOrderId(), event.getItems());
    }
    
    @SagaStep(name = "processPayment", compensate = "refundPayment")
    Void processPayment(OrderCreated event) {
        paymentService.charge(event.getUserId(), event.getAmount());
    }
}
​

实战案例

电商订单系统

内容管理系统

总结

微服务拆分要点：

1. DDD 设计：领域驱动、边界清晰
2. 通信模式：同步 vs 异步
   3.数据管理**：独立数据库 vs 共享数据库
3. 数据一致性：Saga 模式、事件驱动
4. 持续集成：CI/CD、自动化测试

从单体到微服务，平滑演进！