结构型模式聚焦于对象间的组合关系，通过优化类与对象的装配方式，实现系统的灵活性与可扩展性。在分布式系统中，由于多节点协作、跨网络通信及异构环境集成等特性，传统结构型模式需进行适应性改造，以应对分布式特有的复杂性（如网络延迟、节点故障、协议异构）。本文系统解析适配器、桥接、组合、装饰器、外观、享元、代理七大结构型模式在分布式场景下的演化与实践。
一、适配器模式：异构系统的桥梁
1.1 模式核心与分布式适配场景
适配器模式通过封装不同接口，使不兼容的类可以协同工作。在分布式系统中，该模式常用于异构系统集成（如多注册中心适配、跨协议通信）。
1. 多注册中心适配（Nacos/Eureka/Consul）
// 目标接口：统一服务发现接口 public interface ServiceDiscovery { List<String> getServiceInstances(String serviceName); }
// 适配者1：Nacos客户端 public class NacosServiceDiscovery { public List<Instance> getInstances(String serviceName) { // Nacos SDK调用逻辑 } }
// 适配者2：Eureka客户端 public class EurekaServiceDiscovery { public List<InstanceInfo> getInstances(String serviceName) { // Eureka SDK调用逻辑 } }
// 适配器：Nacos适配器 public class NacosAdapter implements ServiceDiscovery {
private NacosServiceDiscovery nacosDiscovery;
@Override public List<String> getServiceInstances(String serviceName) { List<Instance> nacosInstances = nacosDiscovery.getInstances(serviceName); // 转换为统一格式（IP:端口） return nacosInstances.stream() .map(inst -> inst.getIp() + ":" + inst.getPort()) .collect(Collectors.toList()); } }
// 客户端使用 public class ServiceConsumer { private ServiceDiscovery discovery; // 通过配置注入具体适配器（NacosAdapter/EurekaAdapter） public ServiceConsumer(ServiceDiscovery discovery) { this.discovery = discovery; }
public void invokeService(String serviceName) {
List<String> instances = discovery.getServiceInstances(serviceName);
// 负载均衡调用 } }
复制代码
2. 关键价值
二、桥接模式：分布式服务的抽象与实现分离
2.1 模式核心与分布式应用
桥接模式通过分离抽象层与实现层，使二者可独立演化。在分布式系统中，该模式常用于解耦业务逻辑与底层通信协议（如 HTTP/RPC/Kafka）。
1. 消息发送的桥接设计
// 抽象层：消息发送器 public abstract class MessageSender {
protected MessageChannel channel; // 桥接的实现层 public MessageSender(MessageChannel channel) { this.channel = channel; }
public abstract void send(Message message); }
// 具体抽象：业务消息发送器 public class BusinessMessageSender extends MessageSender {
public BusinessMessageSender(MessageChannel channel) { super(channel); }
@Override public void send(Message message) { // 业务逻辑：添加统一消息头 message.addHeader("type", "business"); channel.send(message); // 委托给实现层 } }
// 实现层接口：消息通道 public interface MessageChannel {
void send(Message message); }
// 具体实现：Kafka通道 public class KafkaChannel implements MessageChannel {
@Override public void send(Message message) {
// Kafka SDK发送逻辑 } }
// 具体实现：RabbitMQ通道 public class RabbitMqChannel implements MessageChannel {
@Override public void send(Message message) {
// RabbitMQ SDK发送逻辑 } }
// 使用示例 public class MessageService {
public void sendOrderMessage(Message message) {
// 桥接：业务逻辑与通信协议分离 MessageSender sender = new BusinessMessageSender(new KafkaChannel());
sender.send(message); } }
复制代码
2. 分布式场景优势
三、组合模式：分布式集群的树形结构管理
3.1 模式核心与集群管理
组合模式通过树形结构统一处理单个对象与对象集合，在分布式系统中常用于集群节点管理、服务拓扑维护等场景。
1. 集群节点的组合设计
// 抽象组件：集群节点 public abstract class ClusterNode {
protected String nodeId; protected String address;
public ClusterNode(String nodeId, String address) {
this.nodeId = nodeId; this.address = address;
}
public abstract void start(); public abstract void stop();
public abstract List<ClusterNode> getChildren();
}
// 叶子节点：单个服务实例 public class ServiceNode extends ClusterNode {
public ServiceNode(String nodeId, String address) {
super(nodeId, address); }
@Override public void start() {
// 启动单个服务实例（如调用API启动容器） }
@Override public void stop() {
// 停止单个实例 }
@Override public List<ClusterNode> getChildren() {
return Collections.emptyList(); // 叶子节点无children } }
// 组合节点：节点组（如机房/机架） public class NodeGroup extends ClusterNode {
private List<ClusterNode> children = new ArrayList<>();
public NodeGroup(String nodeId, String address) {
super(nodeId, address); }
public void addNode(ClusterNode node) { children.add(node); }
@Override public void start() {
// 递归启动所有子节点 children.forEach(ClusterNode::start); }
@Override public void stop() {
// 递归停止所有子节点 children.forEach(ClusterNode::stop); }
@Override public List<ClusterNode> getChildren() { return children; } }
// 使用示例：管理跨机房集群 public class ClusterManager {
public void manageCluster() {
// 构建树形结构：机房1 -> 机架1 -> 服务实例1/2 ClusterNode rack1 = new NodeGroup("rack-1", "dc1-rack1"); rack1.addNode(new ServiceNode("service-1", "10.0.0.1:8080")); rack1.addNode(new ServiceNode("service-2", "10.0.0.2:8080")); ClusterNode dc1 = new NodeGroup("dc-1", "datacenter-1"); dc1.addNode(rack1); // 启动整个机房的节点 dc1.start(); } }
复制代码
2. 分布式场景价值
四、装饰器模式：分布式服务的动态增强
4.1 模式核心与服务增强
装饰器模式通过包装对象动态添加功能，在分布式系统中常用于服务调用的横切逻辑增强（如日志、监控、熔断）。
1. 服务调用的装饰器链
// 核心接口：服务调用器 public interface ServiceInvoker {
Object invoke(String serviceName, String method, Object[] params) throws Exception;
}
// 基础实现：REST调用器 public class RestInvoker implements ServiceInvoker {
@Override public Object invoke(String serviceName, String method, Object[] params) {
// 调用REST API的逻辑 return restTemplate.postForObject("/" + serviceName + "/" + method, params, Object.class);
} }
// 装饰器1：日志装饰器 public class LoggingDecorator implements ServiceInvoker {
private ServiceInvoker invoker; public LoggingDecorator(ServiceInvoker invoker) { this.invoker = invoker; }
@Override public Object invoke(String serviceName, String method, Object[] params) throws Exception {
long start = System.currentTimeMillis(); log.info("调用开始：{}#{}", serviceName, method);
try { Object result = invoker.invoke(serviceName, method, params); log.info("调用成功，耗时：{}ms", System.currentTimeMillis() - start);
return result; } catch (Exception e) { log.error("调用失败", e); throw e; } } }
// 装饰器2：熔断装饰器 public class CircuitBreakerDecorator implements ServiceInvoker {
private ServiceInvoker invoker; private CircuitBreaker circuitBreaker;
public CircuitBreakerDecorator(ServiceInvoker invoker) {
this.invoker = invoker; this.circuitBreaker = CircuitBreaker.ofDefaults("serviceInvoker");
}
@Override public Object invoke(String serviceName, String method, Object[] params) throws Exception {
return Try.ofSupplier(() -> invoker.invoke(serviceName, method, params)).recover(circuitBreaker, e -> fallback(serviceName, method)).get();
}
private Object fallback(String serviceName, String method) {
return "服务暂时不可用，请稍后重试"; } }
// 使用示例：构建装饰器链 public class InvokerClient { public ServiceInvoker buildInvoker() { // 基础调用器 -> 日志装饰器 -> 熔断装饰器 return new CircuitBreakerDecorator(new LoggingDecorator(new RestInvoker()) ); } }
复制代码
2. 分布式场景优势
五、外观模式：分布式系统的统一入口
5.1 模式核心与网关设计
外观模式通过提供统一接口封装子系统复杂性，在分布式系统中常用于 API 网关、服务聚合等场景。
1. 订单服务的外观设计
// 子系统1：库存服务 public class InventoryService {
public boolean deduct(Long productId, int quantity) { /* 扣减库存 */ } }
// 子系统2：支付服务 public class PaymentService {
public String pay(Long orderId, BigDecimal amount) { /* 发起支付 */ }
}
// 子系统3：物流服务 public class LogisticsService {
public void createDelivery(Long orderId, String address) { /* 创建物流单 */ }
}
// 外观类：订单流程管理器 public class OrderFacade {
private InventoryService inventoryService; private PaymentService paymentService; private LogisticsService logisticsService;
// 封装复杂流程为简单接口 public OrderResult createOrder(OrderDTO order) { // 1. 扣减库存 boolean inventoryOk = inventoryService.deduct(order.getProductId(), order.getQuantity()); if (!inventoryOk) { return OrderResult.fail("库存不足"); } // 2. 创建订单记录（本地事务） Long orderId = orderRepository.save(order).getId();
// 3. 发起支付 String payResult = paymentService.pay(orderId, order.getAmount());
if (!"SUCCESS".equals(payResult)) { // 支付失败，回滚库存 inventoryService.refund(order.getProductId(), order.getQuantity()); return OrderResult.fail("支付失败"); } // 4. 创建物流单 logisticsService.createDelivery(orderId, order.getAddress()); return OrderResult.success(orderId); } }
// 客户端使用 public class OrderController {
@Autowired private OrderFacade orderFacade;
@PostMapping("/orders") public OrderResult createOrder(@RequestBody OrderDTO order) {
// 调用外观接口，无需关注子系统细节 return orderFacade.createOrder(order); } }
复制代码
2. 分布式场景价值
六、享元模式：分布式资源的高效复用
6.1 模式核心与连接池设计
享元模式通过共享细粒度对象减少资源消耗，在分布式系统中常用于连接池、线程池、缓存池等场景。
1. 数据库连接池的享元实现
// 享元接口：数据库连接 public interface DbConnection { void execute(String sql); void close(); // 归还到池，而非真正关闭 boolean isActive(); }
// 具体享元：MySQL连接 public class MySqlConnection implements DbConnection {
private Connection connection; // 实际JDBC连接 private boolean inUse; // 是否被占用 public MySqlConnection(Connection connection) { this.connection = connection; }
@Override public void execute(String sql) { /* 执行SQL */ }
@Override public void close() { this.inUse = false; // 标记为可用，归还到池 }
@Override public boolean isActive() { /* 检查连接是否有效 */ }
// 内部状态设置（由连接池管理） public void setInUse(boolean inUse) { this.inUse = inUse; } }
// 享元工厂：连接池 public class ConnectionPool {
private List<DbConnection> connections = new ArrayList<>(); private String url; private String username; private String password; private int maxSize = 10; // 最大连接数 public ConnectionPool(String url, String username, String password) {
this.url = url; this.username = username; this.password = password; initialize(); }
// 初始化连接池 private void initialize() { for (int i = 0; i < maxSize; i++) { Connection jdbcConn = DriverManager.getConnection(url, username, password); connections.add(new MySqlConnection(jdbcConn)); } }
// 获取连接（享元模式核心：复用现有连接） public synchronized DbConnection getConnection() throws Exception {
// 查找可用连接 for (DbConnection conn : connections) { if (!conn.isActive()) { conn.setInUse(true); return conn; } }
// 无可用连接，若未达上限则创建新连接 if (connections.size() < maxSize) { DbConnection newConn = new MySqlConnection(DriverManager.getConnection(url, username, password));
newConn.setInUse(true); connections.add(newConn); return newConn; } throw new Exception("连接池已满"); } }
复制代码
2. 分布式场景价值
七、代理模式：分布式服务的透明代理
7.1 模式核心与远程代理
代理模式通过代理对象控制对目标对象的访问，在分布式系统中常用于远程代理（RPC 调用）、安全代理（权限控制）等场景。
1. RPC 服务的动态代理实现
// 服务接口 public interface UserService {
User getUser(Long id); }
// 远程代理：客户端代理 public class RpcProxy implements InvocationHandler {
private String serviceUrl; // 服务端地址 public RpcProxy(String serviceUrl) { this.serviceUrl = serviceUrl; }
// 创建代理实例 public <T> T createProxy(Class<T> serviceInterface) {
return (T) Proxy.newProxyInstance( serviceInterface.getClassLoader(), new Class[]{serviceInterface}, this ); }
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 1. 封装RPC请求（服务名、方法名、参数） RpcRequest request = new RpcRequest( method.getDeclaringClass().getName(), method.getName(), args );
// 2. 发送请求到服务端 RpcClient client = new RpcClient(serviceUrl); RpcResponse response = client.send(request); // 3. 处理响应 if (response.hasError()) { throw response.getError(); } return response.getResult(); } }
// 客户端使用 public class Client {
public static void main(String[] args) { // 创建代理对象 RpcProxy proxy = new RpcProxy("http://user-service:8080/rpc"); UserService userService = proxy.createProxy(UserService.class);
// 透明调用远程服务（仿佛调用本地方法） User user = userService.getUser(1L); } }
复制代码
2. 分布式场景价值
八、面试高频问题深度解析
8.1 基础概念类问题
Q：适配器模式与代理模式的核心区别？在分布式服务集成中如何选择？
A：
集成异构系统（如不同协议、不同 API 的服务）时用适配器模式；需要透明访问远程服务或添加横切逻辑（如超时控制）时用代理模式。
Q：装饰器模式与代理模式都能增强对象功能，如何区分使用场景？
A：
装饰器模式：强调动态组合功能（如为服务调用添加日志 + 熔断 + 监控，组合顺序可调整），核心是 “增强”。
代理模式：强调控制访问（如远程代理控制远程服务的访问，安全代理控制权限），核心是 “控制”。
分布式场景示例：
为 RPC 调用添加日志和监控 → 装饰器模式（功能组合）。
限制只有管理员能调用敏感接口 → 代理模式（访问控制）。
8.2 实战设计类问题
Q：如何用外观模式设计一个电商订单的分布式事务协调器？
A：
1、子系统：订单服务、库存服务、支付服务、物流服务，每个服务有独立的本地事务。
2、外观类：OrderTransactionFacade，提供createOrder()方法封装完整流程。
3、协调逻辑：
4、客户端：只需调用facade.createOrder()，无需感知分布式事务细节。
Q：分布式缓存系统中，如何用享元模式优化缓存节点的资源占用？
A：
享元对象：缓存连接（如 Redis 连接），将连接的 “主机 / 端口” 作为内部状态，“是否可用” 作为外部状态。
享元工厂：CacheConnectionPool，维护连接池，复用空闲连接（而非每次创建新连接）。
资源控制：通过maxConnections限制总连接数，避免缓存服务器连接过载。
回收机制：定期检测空闲连接，关闭超过阈值的闲置连接（如 5 分钟未使用）。
总结：结构型模式的分布式设计原则
核心选型策略
分布式环境的设计要点
网络容错：所有模式实现需考虑网络延迟、超时和重试（如代理模式中添加 RPC 超时控制）。
状态一致性：组合模式和享元模式需处理分布式状态同步（如集群节点状态的一致性）。
性能权衡：代理、适配器等模式可能引入额外开销，需避免过度设计（如轻量级场景可简化模式实现）。
通过掌握结构型模式在分布式系统中的演化与实践，不仅能在面试中清晰解析架构设计问题，更能在实际项目中构建松耦合、可扩展的分布式架构，体现高级程序员的系统设计能力。
文章转载自：晴空月明
原文链接：https://www.cnblogs.com/dayue-bc/p/18996788
体验地址：http://www.jnpfsoft.com/?from=001YH
评论