多家互联网大厂的分布式系统架构经验，系统梳理23种核心分布式设计模式。从理论基础 到实战应用 ，从一致性算法 到容错机制 ，每个模式都配有真实业务场景的代码实现。无论你是分布式系统初学者还是资深架构师，都能在这里找到有价值的设计思路和解决方案。建议⭐收藏⭐，构建分布式系统时随时参考！
🏗️ 分布式系统模式全景图
分布式系统模式 数据一致性模式 容错模式 通信模式 扩展模式 共识算法 事务模式 复制模式 熔断器 重试模式 限流模式 服务发现 消息队列 RPC模式 分片模式 缓存模式 负载均衡
一、🔐 数据一致性模式
1.1 共识算法模式 - Raft实现
java
/**
* Raft共识算法核心实现
* 适用于分布式系统Leader选举和日志复制
*/
@Component
public class RaftConsensus {
private volatile RaftState state = RaftState.FOLLOWER;
private volatile long currentTerm = 0;
private volatile String votedFor = null;
private volatile String leaderId = null;
private final Map<Long, LogEntry> log = new ConcurrentHashMap<>();
private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
// 心跳超时检测
private volatile long lastHeartbeatTime = System.currentTimeMillis();
public enum RaftState {
FOLLOWER, CANDIDATE, LEADER
}
@Data
public static class LogEntry {
private long term;
private long index;
private String command;
private byte[] data;
}
/**
* 请求投票RPC - 候选人发起选举
*/
public VoteResult requestVote(VoteRequest request) {
synchronized (this) {
// 1. 检查任期号
if (request.getTerm() < currentTerm) {
return new VoteResult(currentTerm, false);
}
// 2. 检查日志新旧程度
if (votedFor == null || votedFor.equals(request.getCandidateId())) {
long lastLogIndex = getLastLogIndex();
long lastLogTerm = getLastLogTerm();
if (request.getLastLogTerm() > lastLogTerm ||
(request.getLastLogTerm() == lastLogTerm &&
request.getLastLogIndex() >= lastLogIndex)) {
votedFor = request.getCandidateId();
resetElectionTimeout();
return new VoteResult(currentTerm, true);
}
}
return new VoteResult(currentTerm, false);
}
}
/**
* 追加条目RPC - Leader复制日志
*/
public AppendEntriesResult appendEntries(AppendEntriesRequest request) {
synchronized (this) {
// 重置选举超时
resetElectionTimeout();
// 1. 任期检查
if (request.getTerm() < currentTerm) {
return new AppendEntriesResult(currentTerm, false);
}
// 2. 转换为Follower
if (request.getTerm() > currentTerm || state != RaftState.FOLLOWER) {
currentTerm = request.getTerm();
state = RaftState.FOLLOWER;
leaderId = request.getLeaderId();
}
// 3. 日志一致性检查
long prevLogIndex = request.getPrevLogIndex();
long prevLogTerm = request.getPrevLogTerm();
if (prevLogIndex > 0) {
LogEntry prevEntry = log.get(prevLogIndex);
if (prevEntry == null || prevEntry.getTerm() != prevLogTerm) {
return new AppendEntriesResult(currentTerm, false);
}
}
// 4. 追加新日志
for (LogEntry newEntry : request.getEntries()) {
log.put(newEntry.getIndex(), newEntry);
}
// 5. 更新提交索引
if (request.getLeaderCommit() > getCommitIndex()) {
setCommitIndex(Math.min(request.getLeaderCommit(), getLastLogIndex()));
}
return new AppendEntriesResult(currentTerm, true);
}
}
/**
* Leader心跳机制
*/
@Scheduled(fixedRate = 150) // 150ms心跳间隔
public void sendHeartbeat() {
if (state != RaftState.LEADER) return;
for (String follower : clusterNodes) {
if (!follower.equals(nodeId)) {
// 异步发送心跳
CompletableFuture.runAsync(() -> {
AppendEntriesRequest request = buildHeartbeatRequest();
try {
raftClient.appendEntries(follower, request);
} catch (Exception e) {
handleHeartbeatFailure(follower, e);
}
});
}
}
}
private void resetElectionTimeout() {
lastHeartbeatTime = System.currentTimeMillis();
}
@Scheduled(fixedRate = 100)
public void checkElectionTimeout() {
if (state == RaftState.LEADER) return;
long now = System.currentTimeMillis();
long electionTimeout = 300 + ThreadLocalRandom.current().nextInt(150);
if (now - lastHeartbeatTime > electionTimeout) {
startElection();
}
}
private void startElection() {
synchronized (this) {
state = RaftState.CANDIDATE;
currentTerm++;
votedFor = nodeId;
// 请求其他节点投票
requestVotesFromCluster();
}
}
}1.2 分布式事务模式 - Saga模式
java
/**
* Saga分布式事务模式
* 通过补偿机制保证最终一致性
*/
@Service
@Slf4j
public class SagaTransactionManager {
@Autowired
private SagaTransactionRepository repository;
@Autowired
private TransactionCoordinator coordinator;
/**
* 执行Saga事务
*/
public <T> SagaResult<T> executeSaga(String businessId, List<SagaStep<T>> steps) {
SagaTransaction transaction = new SagaTransaction();
transaction.setTransactionId(generateTransactionId());
transaction.setBusinessId(businessId);
transaction.setStatus(SagaStatus.STARTED);
transaction.setSteps(new ArrayList<>());
try {
// 保存事务记录
repository.save(transaction);
// 顺序执行各个步骤
T result = executeStepsSequentially(steps, transaction);
transaction.setStatus(SagaStatus.COMPLETED);
repository.update(transaction);
return SagaResult.success(result);
} catch (SagaException e) {
// 执行补偿操作
compensateSteps(transaction);
return SagaResult.failure(e.getMessage());
}
}
private <T> T executeStepsSequentially(List<SagaStep<T>> steps,
SagaTransaction transaction) {
T context = null;
for (int i = 0; i < steps.size(); i++) {
SagaStep<T> step = steps.get(i);
SagaStepRecord stepRecord = new SagaStepRecord();
stepRecord.setStepName(step.getName());
stepRecord.setOrder(i);
try {
log.info("执行Saga步骤: {}", step.getName());
// 执行正向操作
context = step.execute(context);
stepRecord.setStatus(StepStatus.SUCCEEDED);
} catch (Exception e) {
log.error("Saga步骤执行失败: {}", step.getName(), e);
stepRecord.setStatus(StepStatus.FAILED);
stepRecord.setErrorMessage(e.getMessage());
transaction.getSteps().add(stepRecord);
repository.update(transaction);
throw new SagaException("步骤执行失败: " + step.getName(), e);
}
transaction.getSteps().add(stepRecord);
repository.update(transaction);
}
return context;
}
/**
* 补偿操作 - 逆向执行已完成步骤
*/
private void compensateSteps(SagaTransaction transaction) {
List<SagaStepRecord> steps = transaction.getSteps();
// 逆序执行补偿
for (int i = steps.size() - 1; i >= 0; i--) {
SagaStepRecord step = steps.get(i);
if (step.getStatus() == StepStatus.SUCCEEDED) {
try {
log.info("执行补偿操作: {}", step.getStepName());
// 调用补偿接口
coordinator.compensate(step.getStepName(), transaction.getBusinessId());
step.setStatus(StepStatus.COMPENSATED);
} catch (Exception e) {
log.error("补偿操作执行失败: {}", step.getStepName(), e);
step.setStatus(StepStatus.COMPENSATE_FAILED);
// 记录但继续补偿其他步骤
}
}
}
transaction.setStatus(SagaStatus.FAILED);
repository.update(transaction);
}
@Data
public static class SagaStep<T> {
private String name;
private Function<T, T> executeFunction;
private Consumer<String> compensateFunction;
public T execute(T context) {
return executeFunction.apply(context);
}
public void compensate(String businessId) {
compensateFunction.accept(businessId);
}
}
// 使用示例：订单创建Saga
public SagaResult<Order> createOrder(OrderRequest request) {
List<SagaStep<Order>> steps = Arrays.asList(
new SagaStep<Order>("验证库存",
order -> {
inventoryService.checkStock(request.getItems());
return null;
},
businessId -> {
// 补偿操作：释放库存预留
inventoryService.releaseStock(businessId);
}),
new SagaStep<Order>("创建订单",
order -> {
Order newOrder = orderService.createOrder(request);
return newOrder;
},
businessId -> {
// 补偿操作：取消订单
orderService.cancelOrder(businessId);
}),
new SagaStep<Order>("扣减库存",
order -> {
inventoryService.deductStock(order.getOrderId(), order.getItems());
return order;
},
businessId -> {
// 补偿操作：恢复库存
inventoryService.restoreStock(businessId);
})
);
return executeSaga(request.getOrderId(), steps);
}
}二、🛡️ 容错模式
2.1 熔断器模式 - Circuit Breaker
java
/**
* 熔断器模式实现
* 防止级联故障，提高系统弹性
*/
@Component
@Slf4j
public class CircuitBreaker {
private final String name;
private final int failureThreshold;
private final long timeoutDuration;
private final long resetTimeout;
private volatile State state = State.CLOSED;
private volatile int failureCount = 0;
private volatile long lastFailureTime = 0;
private volatile long lastAttemptTime = 0;
private final Object lock = new Object();
public enum State {
CLOSED, // 正常状态，请求可以通过
OPEN, // 熔断状态，请求被拒绝
HALF_OPEN // 半开状态，尝试放行部分请求
}
public CircuitBreaker(String name, int failureThreshold, long timeoutDuration, long resetTimeout) {
this.name = name;
this.failureThreshold = failureThreshold;
this.timeoutDuration = timeoutDuration;
this.resetTimeout = resetTimeout;
}
/**
* 执行受保护的操作
*/
public <T> T execute(Supplier<T> protectedCode, Supplier<T> fallback) {
if (!allowRequest()) {
log.warn("熔断器[{}]处于OPEN状态，请求被拒绝", name);
return fallback.get();
}
long startTime = System.currentTimeMillis();
lastAttemptTime = startTime;
try {
T result = protectedCode.get();
onSuccess();
return result;
} catch (Exception e) {
onFailure();
log.error("熔断器[{}]执行失败", name, e);
// 执行降级逻辑
return fallback.get();
}
}
private boolean allowRequest() {
synchronized (lock) {
switch (state) {
case CLOSED:
return true;
case OPEN:
// 检查是否应该进入HALF_OPEN状态
if (System.currentTimeMillis() - lastFailureTime > resetTimeout) {
state = State.HALF_OPEN;
log.info("熔断器[{}]从OPEN进入HALF_OPEN状态", name);
return true; // 允许少量请求通过进行测试
}
return false;
case HALF_OPEN:
// 在HALF_OPEN状态下只允许少量请求通过
return System.currentTimeMillis() - lastAttemptTime > 1000; // 每秒一个测试请求
default:
return false;
}
}
}
private void onSuccess() {
synchronized (lock) {
failureCount = 0;
if (state == State.HALF_OPEN) {
// 半开状态下请求成功，恢复为关闭状态
state = State.CLOSED;
log.info("熔断器[{}]从HALF_OPEN恢复为CLOSED状态", name);
}
}
}
private void onFailure() {
synchronized (lock) {
failureCount++;
lastFailureTime = System.currentTimeMillis();
if (state == State.HALF_OPEN) {
// 半开状态下请求失败，重新进入熔断状态
state = State.OPEN;
log.info("熔断器[{}]从HALF_OPEN回到OPEN状态", name);
} else if (state == State.CLOSED && failureCount >= failureThreshold) {
// 关闭状态下失败次数达到阈值，进入熔断状态
state = State.OPEN;
log.warn("熔断器[{}]达到失败阈值，进入OPEN状态", name);
}
}
}
/**
* 获取熔断器状态快照
*/
public CircuitBreakerStats getStats() {
synchronized (lock) {
return new CircuitBreakerStats(
name, state, failureCount,
lastFailureTime, lastAttemptTime
);
}
}
}
// 使用示例
@Service
public class OrderService {
private final CircuitBreaker paymentCircuitBreaker;
public OrderService() {
this.paymentCircuitBreaker = new CircuitBreaker(
"payment-service",
5, // 5次失败后熔断
5000, // 5秒超时
30000 // 30秒后尝试恢复
);
}
public OrderResult createOrder(OrderRequest request) {
return paymentCircuitBreaker.execute(
() -> {
// 调用支付服务
PaymentResult payment = paymentService.processPayment(request);
return buildOrderResult(payment);
},
() -> {
// 降级逻辑：返回排队中状态
log.warn("支付服务不可用，订单进入排队状态");
return OrderResult.queued("系统繁忙，订单已进入处理队列");
}
);
}
}2.2 重试模式 - 指数退避重试
java
/**
* 指数退避重试模式
* 避免重试风暴，提高重试成功率
*/
@Component
@Slf4j
public class ExponentialBackoffRetry {
private final int maxAttempts;
private final long initialInterval;
private final long maxInterval;
private final double multiplier;
public ExponentialBackoffRetry(int maxAttempts, long initialInterval,
long maxInterval, double multiplier) {
this.maxAttempts = maxAttempts;
this.initialInterval = initialInterval;
this.maxInterval = maxInterval;
this.multiplier = multiplier;
}
/**
* 执行带指数退避的重试
*/
public <T> T execute(RetryableTask<T> task) {
long currentInterval = initialInterval;
int attempt = 0;
Exception lastException = null;
while (attempt < maxAttempts) {
try {
attempt++;
log.debug("执行重试尝试，第{}次", attempt);
return task.execute();
} catch (RetryableException e) {
lastException = e;
if (attempt >= maxAttempts) {
log.warn("达到最大重试次数{}", maxAttempts);
break;
}
// 计算下次重试间隔
long sleepTime = Math.min(
(long) (currentInterval * Math.pow(multiplier, attempt - 1)),
maxInterval
);
log.warn("操作失败，{}ms后进行第{}次重试", sleepTime, attempt + 1);
try {
Thread.sleep(sleepTime);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
throw new RuntimeException("重试被中断", ie);
}
currentInterval = sleepTime;
}
}
throw new MaxRetriesExceededException("超过最大重试次数", lastException);
}
/**
* 带结果验证的重试
*/
public <T> T executeWithValidation(RetryableTask<T> task, Predicate<T> validator) {
return execute(() -> {
T result = task.execute();
if (!validator.test(result)) {
throw new RetryableException("结果验证失败");
}
return result;
});
}
@FunctionalInterface
public interface RetryableTask<T> {
T execute() throws RetryableException;
}
// 使用示例
public void sendOrderToShipping(Order order) {
ExponentialBackoffRetry retry = new ExponentialBackoffRetry(5, 1000, 30000, 2.0);
try {
retry.execute(() -> {
// 调用物流服务
ShippingResponse response = shippingService.createShipping(order);
if (response.getStatus() != ShippingStatus.SUCCESS) {
throw new RetryableException("物流服务返回失败状态");
}
return response;
});
} catch (MaxRetriesExceededException e) {
log.error("物流服务调用失败，订单转入人工处理", e);
manualProcessingService.queueForManualProcess(order);
}
}
}三、📡 通信模式
3.1 服务发现模式
java
/**
* 客户端服务发现模式
* 支持负载均衡和健康检查
*/
@Component
@Slf4j
public class ClientSideServiceDiscovery {
@Autowired
private ServiceRegistry registry;
@Autowired
private HealthChecker healthChecker;
private final Map<String, List<ServiceInstance>> serviceCache = new ConcurrentHashMap<>();
private final Map<String, AtomicInteger> roundRobinCounters = new ConcurrentHashMap<>();
/**
* 发现可用服务实例
*/
public ServiceInstance discoverService(String serviceName, LoadBalanceStrategy strategy) {
List<ServiceInstance> instances = getHealthyInstances(serviceName);
if (instances.isEmpty()) {
throw new ServiceNotFoundException("未找到可用服务实例: " + serviceName);
}
return selectInstance(instances, strategy);
}
/**
* 获取健康实例列表
*/
private List<ServiceInstance> getHealthyInstances(String serviceName) {
// 先从缓存获取
List<ServiceInstance> cachedInstances = serviceCache.get(serviceName);
if (cachedInstances != null && !cachedInstances.isEmpty()) {
return cachedInstances.stream()
.filter(instance -> healthChecker.isHealthy(instance))
.collect(Collectors.toList());
}
// 缓存不存在或为空，从注册中心获取
List<ServiceInstance> freshInstances = registry.getInstances(serviceName);
updateServiceCache(serviceName, freshInstances);
return freshInstances.stream()
.filter(instance -> healthChecker.isHealthy(instance))
.collect(Collectors.toList());
}
/**
* 根据策略选择实例
*/
private ServiceInstance selectInstance(List<ServiceInstance> instances,
LoadBalanceStrategy strategy) {
switch (strategy) {
case ROUND_ROBIN:
return roundRobinSelect(instances);
case RANDOM:
return randomSelect(instances);
case WEIGHTED:
return weightedSelect(instances);
case LEAST_CONNECTION:
return leastConnectionSelect(instances);
default:
return randomSelect(instances);
}
}
/**
* 轮询选择
*/
private ServiceInstance roundRobinSelect(List<ServiceInstance> instances) {
String serviceName = instances.get(0).getServiceName();
AtomicInteger counter = roundRobinCounters.computeIfAbsent(
serviceName, k -> new AtomicInteger(0)
);
int index = Math.abs(counter.getAndIncrement() % instances.size());
return instances.get(index);
}
/**
* 基于权重的选择
*/
private ServiceInstance weightedSelect(List<ServiceInstance> instances) {
int totalWeight = instances.stream()
.mapToInt(ServiceInstance::getWeight)
.sum();
int randomWeight = ThreadLocalRandom.current().nextInt(totalWeight);
int currentWeight = 0;
for (ServiceInstance instance : instances) {
currentWeight += instance.getWeight();
if (randomWeight < currentWeight) {
return instance;
}
}
return instances.get(0);
}
/**
* 定时更新服务缓存
*/
@Scheduled(fixedRate = 30000) // 30秒更新一次
public void refreshServiceCache() {
for (String serviceName : serviceCache.keySet()) {
try {
List<ServiceInstance> freshInstances = registry.getInstances(serviceName);
updateServiceCache(serviceName, freshInstances);
} catch (Exception e) {
log.error("刷新服务缓存失败: {}", serviceName, e);
}
}
}
private void updateServiceCache(String serviceName, List<ServiceInstance> instances) {
serviceCache.put(serviceName, instances);
log.debug("更新服务缓存: {} -> {}个实例", serviceName, instances.size());
}
}
// 使用示例
@Service
public class OrderProcessingService {
@Autowired
private ClientSideServiceDiscovery serviceDiscovery;
public void processOrder(Order order) {
// 发现库存服务实例
ServiceInstance inventoryInstance = serviceDiscovery.discoverService(
"inventory-service",
LoadBalanceStrategy.WEIGHTED
);
// 构建请求URL
String url = String.format("http://%s:%d/api/inventory",
inventoryInstance.getHost(), inventoryInstance.getPort());
// 调用服务
InventoryResponse response = restTemplate.postForObject(url, order, InventoryResponse.class);
if (!response.isSuccess()) {
throw new InventoryException("库存操作失败");
}
}
}四、📊 扩展模式
4.1 分片模式 - 数据分片
java
/**
* 数据分片模式
* 支持水平扩展和负载分布
*/
@Component
@Slf4j
public class ShardingManager {
private final List<Shard> shards;
private final ShardingStrategy strategy;
public ShardingManager(List<Shard> shards, ShardingStrategy strategy) {
this.shards = new ArrayList<>(shards);
this.strategy = strategy;
}
/**
* 根据分片键选择分片
*/
public Shard selectShard(String shardKey) {
int shardIndex = strategy.calculateShardIndex(shardKey, shards.size());
return shards.get(shardIndex);
}
/**
* 批量获取分片映射
*/
public Map<Shard, List<String>> batchSelectShards(List<String> shardKeys) {
return shardKeys.stream()
.collect(Collectors.groupingBy(
this::selectShard,
Collectors.toList()
));
}
/**
* 执行跨分片查询
*/
public <T> List<T> executeCrossShardQuery(ShardQuery<T> query) {
List<CompletableFuture<List<T>>> futures = shards.stream()
.map(shard -> CompletableFuture.supplyAsync(() -> {
try {
return query.executeOnShard(shard);
} catch (Exception e) {
log.error("分片查询失败: {}", shard.getId(), e);
return Collections.emptyList();
}
}))
.collect(Collectors.toList());
// 等待所有查询完成
CompletableFuture<Void> allFutures = CompletableFuture.allOf(
futures.toArray(new CompletableFuture[0])
);
return allFutures.thenApply(v ->
futures.stream()
.map(CompletableFuture::join)
.flatMap(List::stream)
.collect(Collectors.toList())
).join();
}
/**
* 分片再平衡
*/
public void rebalanceShards() {
log.info("开始分片再平衡...");
// 1. 分析当前负载分布
Map<Shard, LoadStats> loadStats = analyzeLoadDistribution();
// 2. 计算目标分布
Map<Shard, TargetDistribution> targetDistribution = calculateTargetDistribution(loadStats);
// 3. 执行数据迁移
executeDataMigration(loadStats, targetDistribution);
log.info("分片再平衡完成");
}
private Map<Shard, LoadStats> analyzeLoadDistribution() {
return shards.stream()
.collect(Collectors.toMap(
shard -> shard,
shard -> new LoadStats(
shard.getDataSize(),
shard.getRequestCount(),
shard.getConnectionCount()
)
));
}
}
/**
* 一致性哈希分片策略
*/
@Component
public class ConsistentHashSharding implements ShardingStrategy {
private final HashFunction hashFunction;
private final SortedMap<Integer, Shard> circle = new TreeMap<>();
private final int virtualNodeCount;
public ConsistentHashSharding(int virtualNodeCount) {
this.hashFunction = Hashing.murmur3_32();
this.virtualNodeCount = virtualNodeCount;
}
@Override
public void initialize(List<Shard> shards) {
for (Shard shard : shards) {
addShardToCircle(shard);
}
}
@Override
public int calculateShardIndex(String shardKey, int shardCount) {
int hash = hashFunction.hashString(shardKey, StandardCharsets.UTF_8).asInt();
if (circle.isEmpty()) {
throw new IllegalStateException("分片环未初始化");
}
// 找到第一个大于等于该哈希值的分片
SortedMap<Integer, Shard> tailMap = circle.tailMap(hash);
int nodeHash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
return circle.get(nodeHash).getIndex();
}
private void addShardToCircle(Shard shard) {
for (int i = 0; i < virtualNodeCount; i++) {
String virtualNodeKey = shard.getId() + "#" + i;
int hash = hashFunction.hashString(virtualNodeKey, StandardCharsets.UTF_8).asInt();
circle.put(hash, shard);
}
}
public void removeShard(Shard shard) {
for (int i = 0; i < virtualNodeCount; i++) {
String virtualNodeKey = shard.getId() + "#" + i;
int hash = hashFunction.hashString(virtualNodeKey, StandardCharsets.UTF_8).asInt();
circle.remove(hash);
}
}
}
// 使用示例
@Service
public class UserService {
@Autowired
private ShardingManager shardingManager;
public User getUser(String userId) {
// 根据用户ID选择分片
Shard shard = shardingManager.selectShard(userId);
// 在特定分片上执行查询
return userRepository.findOnShard(shard, userId);
}
public List<User> searchUsers(String keyword) {
// 跨分片查询
return shardingManager.executeCrossShardQuery(shard -> {
return userRepository.searchOnShard(shard, keyword);
});
}
}五、🎯 模式选择指南
5.1 模式选择决策树
java
/**
* 分布式模式选择决策器
* 根据业务场景推荐合适的模式
*/
@Component
@Slf4j
public class PatternSelector {
/**
* 根据业务需求推荐模式
*/
public List<DesignPattern> recommendPatterns(SystemRequirements requirements) {
List<DesignPattern> patterns = new ArrayList<>();
// 数据一致性需求
if (requirements.isStrongConsistencyRequired()) {
patterns.add(DesignPattern.CONSENSUS);
patterns.add(DesignPattern.TWO_PHASE_COMMIT);
} else if (requirements.isEventualConsistencyAcceptable()) {
patterns.add(DesignPattern.SAGA);
patterns.add(DesignPattern.EVENT_SOURCING);
}
// 容错需求
if (requirements.isFaultToleranceRequired()) {
patterns.add(DesignPattern.CIRCUIT_BREAKER);
patterns.add(DesignPattern.RETRY_WITH_BACKOFF);
patterns.add(DesignPattern.BULKHEAD);
}
// 扩展性需求
if (requirements.getExpectedScale() > 1000) {
patterns.add(DesignPattern.SHARDING);
patterns.add(DesignPattern.CACHING);
patterns.add(DesignPattern.LOAD_BALANCING);
}
// 通信模式
if (requirements.isAsyncCommunicationPreferred()) {
patterns.add(DesignPattern.MESSAGE_QUEUE);
patterns.add(DesignPattern.PUBLISH_SUBSCRIBE);
} else {
patterns.add(DesignPattern.SERVICE_DISCOVERY);
patterns.add(DesignPattern.API_GATEWAY);
}
return deduplicateAndSort(patterns);
}
/**
* 模式组合建议
*/
public PatternCombination suggestCombination(BusinessScenario scenario) {
switch (scenario) {
case ECOMMERCE_ORDER:
return new PatternCombination(
Arrays.asList(
DesignPattern.SAGA,
DesignPattern.CIRCUIT_BREAKER,
DesignPattern.SERVICE_DISCOVERY
),
"电商订单系统需要事务一致性和容错能力"
);
case REAL_TIME_ANALYTICS:
return new PatternCombination(
Arrays.asList(
DesignPattern.EVENT_SOURCING,
DesignPattern.PUBLISH_SUBSCRIBE,
DesignPattern.SHARDING
),
"实时分析系统需要高吞吐量和水平扩展"
);
case USER_SESSION_MANAGEMENT:
return new PatternCombination(
Arrays.asList(
DesignPattern.CACHING,
DesignPattern.REPLICATION,
DesignPattern.LOAD_BALANCING
),
"用户会话管理需要低延迟和高可用性"
);
default:
return getDefaultCombination();
}
}
}💎 总结与最佳实践
核心模式速查表
| 模式类别 | 核心模式 | 适用场景 | 复杂度 |
|---|---|---|---|
| 数据一致性 | Raft共识、Saga、2PC | 金融交易、订单处理 | 高 |
| 容错机制 | 熔断器、重试、限流 | 微服务调用、外部依赖 | 中 |
| 通信模式 | 服务发现、消息队列 | 服务治理、异步处理 | 中 |
| 扩展模式 | 分片、缓存、负载均衡 | 高并发系统、大数据 | 中高 |
实施建议
- 循序渐进：从最简单的模式开始，逐步引入复杂模式
- 监控度量：为每个模式建立相应的监控指标
- 容错设计：考虑模式失败时的降级方案
- 测试验证：通过混沌工程验证模式的可靠性
💬 互动话题：你在分布式系统设计中用过哪些模式？遇到过哪些挑战？欢迎在评论区分享经验！
👉 下一篇预告 ：《分布式系统实战：电商平台架构演进》
（点击关注第一时间获取更新通知）
🎁 文末福利
关注+私信回复"分布式模式"获取：
- 📚 完整模式图谱（PDF版）
- 🛠️ 模式实现代码模板
- 📊 模式选择决策树
- 💻 实战项目源码