微服务设计原则
核心原则
1. 单一职责
定义：
- 每个服务只负责一个业务功能
- 保持服务小而专注
- 避免服务过大
好处：
- 易于理解和维护
- 独立开发和部署
- 快速迭代
示例：
好的设计：
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 用户服务 │ │ 订单服务 │ │ 支付服务 │
│ User │ │ Order │ │ Payment │
└─────────────┘ └─────────────┘ └─────────────┘
不好的设计：
┌─────────────────────────────────────────────┐
│ 单体服务 │
│ User + Order + Payment + Inventory + ... │
└─────────────────────────────────────────────┘实践：
// 好的服务设计
@Service
public class UserService {
// 只处理用户相关业务
public User createUser(CreateUserRequest request) { }
public User getUserById(Long id) { }
public void updateUser(Long id, UpdateUserRequest request) { }
}
// 不好的服务设计
@Service
public class MonolithicService {
// 处理太多业务
public User createUser() { }
public Order createOrder() { }
public Payment processPayment() { }
// ...
}2. 服务自治
定义：
- 服务独立运行
- 服务独立部署
- 服务独立扩展
好处：
- 降低耦合
- 提高可用性
- 快速故障恢复
实践：
# 独立部署
apiVersion: apps/v1
kind: Deployment
metadata:
name: user-service
spec:
replicas: 3
template:
spec:
containers:
- name: user-service
image: user-service:1.0.0
---
# 独立数据库
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: user-service-db
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi3. 去中心化治理
定义：
- 允许不同服务使用不同技术栈
- 服务选择最适合的技术
- 避免技术强制统一
好处：
- 技术多样性
- 团队自主权
- 快速采用新技术
实践：
技术栈选择：
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 用户服务 │ │ 订单服务 │ │ AI 服务 │
│ Java │ │ Go │ │ Python │
│ Spring │ │ Gin │ │ FastAPI │
│ MySQL │ │ PostgreSQL │ │ MongoDB │
└─────────────┘ └─────────────┘ └─────────────┘4. 容错设计
定义：
- 服务具备故障隔离能力
- 服务具备自愈能力
- 避免级联故障
好处：
- 提高系统可用性
- 减少故障影响范围
- 快速恢复
实践：
// 熔断器
@Service
public class OrderService {
@Autowired
private UserService userService;
@SentinelResource(
value = "getUser",
fallback = "getUserFallback"
)
public User getUser(Long userId) {
return userService.getUserById(userId);
}
// 降级方法
public User getUserFallback(Long userId, Throwable ex) {
log.error("获取用户失败", ex);
return User.getDefault();
}
}
// 超时配置
@Configuration
public class FeignConfig {
@Bean
public Request.Options requestOptions() {
return new Request.Options(5000, 10000, true);
}
}服务拆分
1. 按业务领域拆分
领域驱动设计（DDD）：
战略设计：
┌─────────────────────────────────────────────┐
│ 限界上下文 │
│ ┌───────────┐ ┌───────────┐ ┌─────────┐ │
│ │ 用户域 │ │ 订单域 │ │ 支付域 │ │
│ │ │ │ │ │ │ │
│ │ - 用户管理│ │ - 订单管理│ │ - 支付 │ │
│ │ - 权限 │ │ - 购物车 │ │ - 退款 │ │
│ └───────────┘ └───────────┘ └─────────┘ │
└─────────────────────────────────────────────┘实践：
// 用户域
@Entity
@Table(name = "user")
public class User {
@Id
private Long id;
private String username;
private String email;
// ...
}
// 订单域
@Entity
@Table(name = "orders")
public class Order {
@Id
private Long id;
private Long userId;
private BigDecimal amount;
// ...
}2. 按功能拆分
功能模块：
┌─────────────────────────────────────────────┐
│ 电商平台 │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────────┐ │
│ │ 商品 │ │ 订单 │ │ 用户 │ │
│ │ - 搜索 │ │ - 创建 │ │ - 注册 │ │
│ │ - 详情 │ │ - 支付 │ │ - 登录 │ │
│ │ - 库存 │ │ - 物流 │ │ - 权限 │ │
│ └─────────┘ └─────────┘ └─────────────┘ │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────────┐ │
│ │ 营销 │ │ 客服 │ │ 数据分析 │ │
│ │ - 优惠券│ │ - 工单 │ │ - 报表 │ │
│ │ - 活动 │ │ - 投诉 │ │ - 用户画像 │ │
│ └─────────┘ └─────────┘ └─────────────┘ │
└─────────────────────────────────────────────┘3. 按数据拆分
数据库私有化：
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 用户服务 │ │ 订单服务 │ │ 商品服务 │
│ │ │ │ │ │
│ ┌─────────┐ │ │ ┌─────────┐ │ │ ┌─────────┐ │
│ │ 用户 DB │ │ │ │ 订单 DB │ │ │ │ 商品 DB │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ │ users │ │ │ │ orders │ │ │ │ products│ │
│ └─────────┘ │ │ └─────────┘ │ │ └─────────┘ │
└─────────────┘ └─────────────┘ └─────────────┘实践：
# 用户服务数据源
spring:
datasource:
url: jdbc:mysql://mysql-user:3306/user_db
username: user_app
password: user_pwd
# 订单服务数据源
spring:
datasource:
url: jdbc:mysql://mysql-order:3306/order_db
username: order_app
password: order_pwd服务通信
1. 同步通信
REST API：
// 定义接口
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping("/{id}")
public Result<User> getUser(@PathVariable Long id) {
User user = userService.findById(id);
return Result.success(user);
}
}
// 调用服务
@FeignClient(name = "user-service")
public interface UserClient {
@GetMapping("/api/users/{id}")
Result<User> getUser(@PathVariable("id") Long id);
}gRPC：
// 定义服务
service UserService {
rpc GetUser (UserRequest) returns (UserResponse);
}
message UserRequest {
int64 id = 1;
}
message UserResponse {
int64 id = 1;
string username = 2;
string email = 3;
}2. 异步通信
消息队列：
// 发布事件
@Service
public class OrderProducer {
@Autowired
private KafkaTemplate<String, Object> kafkaTemplate;
public void sendOrderCreated(Order order) {
kafkaTemplate.send("order-created", order);
}
}
// 消费事件
@Component
public class OrderConsumer {
@KafkaListener(topics = "order-created")
public void consume(Order order) {
// 处理订单创建事件
processOrder(order);
}
}事件驱动：
// 发布领域事件
@Service
public class OrderService {
@Autowired
private ApplicationEventPublisher eventPublisher;
@Transactional
public Order createOrder(CreateOrderRequest request) {
Order order = orderRepository.save(request.toOrder());
// 发布事件
eventPublisher.publishEvent(new OrderCreatedEvent(this, order));
return order;
}
}
// 监听事件
@Component
public class OrderEventListener {
@EventListener
@Async
public void handleOrderCreated(OrderCreatedEvent event) {
// 发送通知
notificationService.send(event.getOrder());
// 扣减库存
inventoryService.decrease(event.getOrder().getItems());
}
}数据一致性
1. 最终一致性
** Saga 模式**：
订单创建流程：
1. 创建订单 (Order Service)
↓
2. 扣减库存 (Inventory Service)
↓
3. 发起支付 (Payment Service)
↓
4. 订单完成 (Order Service)
如果步骤 3 失败：
1. 取消支付 (Payment Service)
↓
2. 恢复库存 (Inventory Service)
↓
3. 取消订单 (Order Service)实践：
@Service
public class OrderSaga {
@Autowired
private OrderService orderService;
@Autowired
private InventoryService inventoryService;
@Autowired
private PaymentService paymentService;
@GlobalTransactional
public void createOrder(CreateOrderRequest request) {
try {
// 1. 创建订单
Order order = orderService.create(request);
// 2. 扣减库存
inventoryService.decrease(order.getItems());
// 3. 发起支付
paymentService.pay(order);
} catch (Exception e) {
// 补偿
compensate(request);
throw e;
}
}
private void compensate(CreateOrderRequest request) {
orderService.cancel(request.getOrderId());
inventoryService.increase(request.getItems());
}
}2. 事件溯源
事件存储：
@Entity
@Table(name = "event_store")
public class EventStore {
@Id
@GeneratedValue
private Long id;
private String aggregateId;
private String aggregateType;
private String eventType;
private String eventData;
private Integer version;
private LocalDateTime timestamp;
}聚合根重建：
public class Order {
private Long id;
private OrderStatus status;
private List<OrderItem> items;
// 从事件重建
public static Order reconstruct(List<EventStore> events) {
Order order = new Order();
for (EventStore event : events) {
order.apply(event);
}
return order;
}
private void apply(EventStore event) {
switch (event.getEventType()) {
case "OrderCreated":
apply((OrderCreated) parseEvent(event));
break;
case "OrderPaid":
apply((OrderPaid) parseEvent(event));
break;
}
}
}最佳实践
1. API 设计
版本控制：
/api/v1/users
/api/v2/users统一响应格式：
@Data
public class Result<T> {
private Integer code;
private String message;
private T data;
private Long timestamp;
public static <T> Result<T> success(T data) {
Result<T> result = new Result<>();
result.setCode(200);
result.setMessage("success");
result.setData(data);
result.setTimestamp(System.currentTimeMillis());
return result;
}
public static <T> Result<T> fail(String message) {
Result<T> result = new Result<>();
result.setCode(500);
result.setMessage(message);
result.setTimestamp(System.currentTimeMillis());
return result;
}
}2. 错误处理
统一异常处理：
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(ResourceNotFoundException.class)
public Result<Void> handleResourceNotFound(ResourceNotFoundException e) {
return Result.fail("资源不存在：" + e.getMessage());
}
@ExceptionHandler(BusinessException.class)
public Result<Void> handleBusinessException(BusinessException e) {
return Result.fail("业务异常：" + e.getMessage());
}
@ExceptionHandler(Exception.class)
public Result<Void> handleException(Exception e) {
log.error("系统异常", e);
return Result.fail("系统异常");
}
}3. 文档规范
OpenAPI 规范：
openapi: 3.0.0
info:
title: User Service API
version: 1.0.0
paths:
/users/{id}:
get:
summary: 获取用户信息
parameters:
- name: id
in: path
required: true
schema:
type: integer
responses:
'200':
description: 成功
content:
application/json:
schema:
$ref: '#/components/schemas/User'4. 测试策略
测试金字塔：
/\
/ \
/ E2E\ 端到端测试（少量）
/------\
/ \
/Integration\ 集成测试（适量）
/--------------\
/ \
/ Unit Test \ 单元测试（大量）
/--------------------\总结
微服务设计原则是构建高质量微服务架构的基础，包括单一职责、服务自治、去中心化治理、容错设计等核心原则。
合理的服务拆分、服务通信和数据处理，可以构建高可用、可扩展的微服务系统。
遵循最佳实践，持续优化改进，可以提高微服务架构的质量和可维护性。