登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›结构型模式-架构解耦与扩展实践

结构型模式-架构解耦与扩展实践

箝德孜 6 天前
结构型模式聚焦于对象间的组合关系，通过优化类与对象的装配方式，实现系统的灵活性与可扩展性。在分布式系统中，由于多节点协作、跨网络通信及异构环境集成等特性，传统结构型模式需进行适应性改造，以应对分布式特有的复杂性（如网络延迟、节点故障、协议异构）。本文系统解析适配器、桥接、组合、装饰器、外观、享元、代理七大结构型模式在分布式场景下的演化与实践。
一、适配器模式：异构系统的桥梁

1.1 模式核心与分布式适配场景

适配器模式通过封装不同接口，使不兼容的类可以协同工作。在分布式系统中，该模式常用于异构系统集成（如多注册中心适配、跨协议通信）。
1. 多注册中心适配（Nacos/Eureka/Consul）
  1. // 目标接口：统一服务发现接口
  2. public interface ServiceDiscovery {
  3.    List<String> getServiceInstances(String serviceName);
  4. }
  6. // 适配者1：Nacos客户端
  7. public class NacosServiceDiscovery {
  8.    public List<Instance> getInstances(String serviceName) {
  9.        // Nacos SDK调用逻辑
  10.    }
  11. }
  13. // 适配者2：Eureka客户端
  14. public class EurekaServiceDiscovery {
  15.    public List<InstanceInfo> getInstances(String serviceName) {
  16.        // Eureka SDK调用逻辑
  17.    }
  18. }
  20. // 适配器：Nacos适配器
  21. public class NacosAdapter implements ServiceDiscovery {
  23.    private NacosServiceDiscovery nacosDiscovery;
  25.    @Override
  26.    public List<String> getServiceInstances(String serviceName) {
  27.        List<Instance> nacosInstances = nacosDiscovery.getInstances(serviceName);
  28.        // 转换为统一格式（IP:端口）
  29.        return nacosInstances.stream()
  30.            .map(inst -> inst.getIp() + ":" + inst.getPort())
  31.            .collect(Collectors.toList());
  32.    }
  33. }
  35. // 客户端使用
  36. public class ServiceConsumer {
  37.    private ServiceDiscovery discovery;
  38.    // 通过配置注入具体适配器（NacosAdapter/EurekaAdapter）
  39.    public ServiceConsumer(ServiceDiscovery discovery) {
  40.        this.discovery = discovery;
  41.    }
  43.    public void invokeService(String serviceName) {
  45.        List<String> instances = discovery.getServiceInstances(serviceName);
  47.        // 负载均衡调用
  48.    }
  49. }
复制代码
2. 关键价值


  • 接口统一：屏蔽不同注册中心的 API 差异，业务代码依赖抽象接口。
  • 平滑迁移：切换注册中心时只需替换适配器，无需修改业务逻辑（如从 Eureka 迁移到 Nacos）。
二、桥接模式：分布式服务的抽象与实现分离

2.1 模式核心与分布式应用

桥接模式通过分离抽象层与实现层，使二者可独立演化。在分布式系统中，该模式常用于解耦业务逻辑与底层通信协议（如 HTTP/RPC/Kafka）。
1. 消息发送的桥接设计
  1. // 抽象层：消息发送器
  2. public abstract class MessageSender {
  4.    protected MessageChannel channel; // 桥接的实现层
  5.    public MessageSender(MessageChannel channel) {
  6.        this.channel = channel;
  7.    }
  9.    public abstract void send(Message message);
  10. }
  12. // 具体抽象：业务消息发送器
  13. public class BusinessMessageSender extends MessageSender {
  15.    public BusinessMessageSender(MessageChannel channel) {
  16.        super(channel);
  17.    }
  19.    @Override
  20.    public void send(Message message) {
  21.        // 业务逻辑：添加统一消息头
  22.        message.addHeader("type", "business");
  23.        channel.send(message); // 委托给实现层
  24.    }
  25. }
  27. // 实现层接口：消息通道
  28. public interface MessageChannel {
  30.    void send(Message message);
  31. }
  34. // 具体实现：Kafka通道
  35. public class KafkaChannel implements MessageChannel {
  37.    @Override
  38.    public void send(Message message) {
  40.        // Kafka SDK发送逻辑
  41.    }
  42. }
  44. // 具体实现：RabbitMQ通道
  45. public class RabbitMqChannel implements MessageChannel {
  47.    @Override
  48.    public void send(Message message) {
  50.        // RabbitMQ SDK发送逻辑
  51.    }
  52. }
  54. // 使用示例
  55. public class MessageService {
  57.    public void sendOrderMessage(Message message) {
  59.        // 桥接：业务逻辑与通信协议分离
  60.        MessageSender sender = new BusinessMessageSender(new KafkaChannel());
  62.        sender.send(message);
  63.    }
  64. }
复制代码
2. 分布式场景优势


  • 多协议适配：同一业务逻辑可通过不同通道发送（如核心消息用 Kafka，普通消息用 RabbitMQ）。
  • 扩展便捷：新增协议（如 RocketMQ）只需实现MessageChannel，无需修改抽象层。
三、组合模式：分布式集群的树形结构管理

3.1 模式核心与集群管理

组合模式通过树形结构统一处理单个对象与对象集合，在分布式系统中常用于集群节点管理、服务拓扑维护等场景。
1. 集群节点的组合设计
  1. // 抽象组件：集群节点
  2. public abstract class ClusterNode {
  4.    protected String nodeId;
  5.    protected String address;
  7.    public ClusterNode(String nodeId, String address) {
  9.        this.nodeId = nodeId;
  10.        this.address = address;
  12.    }
  14.    public abstract void start();
  15.    public abstract void stop();
  17.    public abstract List<ClusterNode> getChildren();
  19. }
  21. // 叶子节点：单个服务实例
  22. public class ServiceNode extends ClusterNode {
  24.    public ServiceNode(String nodeId, String address) {
  26.        super(nodeId, address);
  27.    }
  29.    @Override
  30.    public void start() {
  32.        // 启动单个服务实例（如调用API启动容器）
  33.    }
  35.    @Override
  36.    public void stop() {
  38.        // 停止单个实例
  39.    }
  42.    @Override
  43.    public List<ClusterNode> getChildren() {
  45.        return Collections.emptyList(); // 叶子节点无children
  46.    }
  47. }
  49. // 组合节点：节点组（如机房/机架）
  50. public class NodeGroup extends ClusterNode {
  52.    private List<ClusterNode> children = new ArrayList<>();
  54.    public NodeGroup(String nodeId, String address) {
  56.        super(nodeId, address);
  57.    }
  59.    public void addNode(ClusterNode node) {
  60.        children.add(node);
  61.    }
  64.    @Override
  65.    public void start() {
  67.        // 递归启动所有子节点
  68.        children.forEach(ClusterNode::start);
  69.    }
  72.    @Override
  73.    public void stop() {
  75.        // 递归停止所有子节点
  76.        children.forEach(ClusterNode::stop);
  77.    }
  79.    @Override
  80.    public List<ClusterNode> getChildren() {
  81.        return children;
  82.    }
  83. }
  86. // 使用示例：管理跨机房集群
  87. public class ClusterManager {
  89.    public void manageCluster() {
  91.        // 构建树形结构：机房1 -> 机架1 -> 服务实例1/2
  92.        ClusterNode rack1 = new NodeGroup("rack-1", "dc1-rack1");
  93.        rack1.addNode(new ServiceNode("service-1", "10.0.0.1:8080"));
  94.        rack1.addNode(new ServiceNode("service-2", "10.0.0.2:8080"));
  95.        ClusterNode dc1 = new NodeGroup("dc-1", "datacenter-1");
  96.        dc1.addNode(rack1);
  97.        // 启动整个机房的节点
  98.        dc1.start();
  99.    }
  100. }
复制代码
2. 分布式场景价值


  • 统一操作：对单个节点和节点组执行相同操作（如start()/stop()），简化集群管理。
  • 拓扑可视化：通过getChildren()递归遍历，可生成集群拓扑图（如展示机房 - 机架 - 实例的层级关系）。
四、装饰器模式：分布式服务的动态增强

4.1 模式核心与服务增强

装饰器模式通过包装对象动态添加功能，在分布式系统中常用于服务调用的横切逻辑增强（如日志、监控、熔断）。
1. 服务调用的装饰器链
  1. // 核心接口：服务调用器
  2. public interface ServiceInvoker {
  4.    Object invoke(String serviceName, String method, Object[] params) throws Exception;
  6. }
  9. // 基础实现：REST调用器
  10. public class RestInvoker implements ServiceInvoker {
  12.    @Override
  13.    public Object invoke(String serviceName, String method, Object[] params) {
  15.        // 调用REST API的逻辑
  16.        return restTemplate.postForObject("/" + serviceName + "/" + method, params, Object.class);
  18.    }
  19. }
  22. // 装饰器1：日志装饰器
  23. public class LoggingDecorator implements ServiceInvoker {
  25.    private ServiceInvoker invoker;
  26.    public LoggingDecorator(ServiceInvoker invoker) {
  27.        this.invoker = invoker;
  28.    }
  31.    @Override
  32.    public Object invoke(String serviceName, String method, Object[] params) throws Exception {
  34.        long start = System.currentTimeMillis();
  35.        log.info("调用开始：{}#{}", serviceName, method);
  37.        try {
  38.            Object result = invoker.invoke(serviceName, method, params);
  39.            log.info("调用成功，耗时：{}ms", System.currentTimeMillis() - start);
  41.            return result;
  42.        } catch (Exception e) {
  43.            log.error("调用失败", e);
  44.            throw e;
  45.        }
  46.    }
  47. }
  50. // 装饰器2：熔断装饰器
  51. public class CircuitBreakerDecorator implements ServiceInvoker {
  53.    private ServiceInvoker invoker;
  54.    private CircuitBreaker circuitBreaker;
  56.    public CircuitBreakerDecorator(ServiceInvoker invoker) {
  58.        this.invoker = invoker;
  59.        this.circuitBreaker = CircuitBreaker.ofDefaults("serviceInvoker");
  61.    }
  63.    @Override
  64.    public Object invoke(String serviceName, String method, Object[] params) throws Exception {
  66.        return Try.ofSupplier(() -> invoker.invoke(serviceName, method, params)).recover(circuitBreaker, e -> fallback(serviceName, method)).get();
  68.    }
  70.    private Object fallback(String serviceName, String method) {
  72.        return "服务暂时不可用，请稍后重试";
  73.    }
  74. }
  76. // 使用示例：构建装饰器链
  77. public class InvokerClient {
  78.    public ServiceInvoker buildInvoker() {
  79.        // 基础调用器 -> 日志装饰器 -> 熔断装饰器
  80.        return new CircuitBreakerDecorator(new LoggingDecorator(new RestInvoker()) );
  81.    }
  82. }
复制代码
2. 分布式场景优势


  • 动态组合：按需组合装饰器（如生产环境添加熔断 + 监控，测试环境添加日志 + 模拟延迟）。
  • 无侵入增强：核心调用逻辑与横切逻辑分离（如RestInvoker无需包含日志或熔断代码）。
五、外观模式：分布式系统的统一入口

5.1 模式核心与网关设计

外观模式通过提供统一接口封装子系统复杂性，在分布式系统中常用于 API 网关、服务聚合等场景。
1. 订单服务的外观设计
  1. // 子系统1：库存服务
  2. public class InventoryService {
  4.    public boolean deduct(Long productId, int quantity) { /* 扣减库存 */ }
  5. }
  7. // 子系统2：支付服务
  8. public class PaymentService {
  10.    public String pay(Long orderId, BigDecimal amount) { /* 发起支付 */ }
  12. }
  15. // 子系统3：物流服务
  16. public class LogisticsService {
  18.    public void createDelivery(Long orderId, String address) { /* 创建物流单 */ }
  20. }
  22. // 外观类：订单流程管理器
  23. public class OrderFacade {
  25.    private InventoryService inventoryService;
  26.    private PaymentService paymentService;
  27.    private LogisticsService logisticsService;
  29.    // 封装复杂流程为简单接口
  30.    public OrderResult createOrder(OrderDTO order) {
  31.        // 1. 扣减库存
  32.        boolean inventoryOk = inventoryService.deduct(order.getProductId(), order.getQuantity());
  33.        if (!inventoryOk) {
  34.            return OrderResult.fail("库存不足");
  35.        }
  36.        // 2. 创建订单记录（本地事务）
  37.        Long orderId = orderRepository.save(order).getId();
  39.        // 3. 发起支付
  40.        String payResult = paymentService.pay(orderId, order.getAmount());
  42.        if (!"SUCCESS".equals(payResult)) {
  43.            // 支付失败，回滚库存
  44.            inventoryService.refund(order.getProductId(), order.getQuantity());
  45.            return OrderResult.fail("支付失败");
  46.        }
  47.        // 4. 创建物流单
  48.        logisticsService.createDelivery(orderId, order.getAddress());
  49.        return OrderResult.success(orderId);
  50.    }
  51. }
  53. // 客户端使用
  54. public class OrderController {
  56.    @Autowired
  57.    private OrderFacade orderFacade;
  59.    @PostMapping("/orders")
  60.    public OrderResult createOrder(@RequestBody OrderDTO order) {
  62.        // 调用外观接口，无需关注子系统细节
  63.        return orderFacade.createOrder(order);
  64.    }
  65. }
复制代码
2. 分布式场景价值


  • 简化调用：客户端只需调用OrderFacade.createOrder()，无需逐个调用库存、支付、物流服务。
  • 事务协调：外观类可封装分布式事务逻辑（如支付失败时回滚库存），避免客户端处理复杂协调。
六、享元模式：分布式资源的高效复用

6.1 模式核心与连接池设计

享元模式通过共享细粒度对象减少资源消耗，在分布式系统中常用于连接池、线程池、缓存池等场景。
1. 数据库连接池的享元实现
  1. // 享元接口：数据库连接
  2. public interface DbConnection {
  3.    void execute(String sql);
  4.    void close(); // 归还到池，而非真正关闭
  5.    boolean isActive();
  6. }
  8. // 具体享元：MySQL连接
  9. public class MySqlConnection implements DbConnection {
  11.    private Connection connection; // 实际JDBC连接
  12.    private boolean inUse; // 是否被占用
  13.    public MySqlConnection(Connection connection) {
  14.        this.connection = connection;
  15.    }
  17.    @Override
  18.    public void execute(String sql) { /* 执行SQL */ }
  20.    @Override
  21.    public void close() {
  22.        this.inUse = false; // 标记为可用，归还到池
  23.    }
  25.    @Override
  26.    public boolean isActive() { /* 检查连接是否有效 */ }
  28.    // 内部状态设置（由连接池管理）
  29.    public void setInUse(boolean inUse) {
  30.        this.inUse = inUse;
  31.    }
  32. }
  34. // 享元工厂：连接池
  35. public class ConnectionPool {
  37.    private List<DbConnection> connections = new ArrayList<>();
  38.    private String url;
  39.    private String username;
  40.    private String password;
  41.    private int maxSize = 10; // 最大连接数
  42.    public ConnectionPool(String url, String username, String password) {
  44.        this.url = url;
  45.        this.username = username;
  46.        this.password = password;
  47.        initialize();
  48.    }
  50.    // 初始化连接池
  51.    private void initialize() {
  52.        for (int i = 0; i < maxSize; i++) {
  53.            Connection jdbcConn = DriverManager.getConnection(url, username, password);
  54.            connections.add(new MySqlConnection(jdbcConn));
  55.        }
  56.    }
  58.    // 获取连接（享元模式核心：复用现有连接）
  59.    public synchronized DbConnection getConnection() throws Exception {
  61.        // 查找可用连接
  62.        for (DbConnection conn : connections) {
  63.            if (!conn.isActive()) {
  64.                conn.setInUse(true);
  65.                return conn;
  66.            }
  67.        }
  69.        // 无可用连接，若未达上限则创建新连接
  70.        if (connections.size() < maxSize) {
  71.            DbConnection newConn = new MySqlConnection(DriverManager.getConnection(url, username, password));
  73.            newConn.setInUse(true);
  74.            connections.add(newConn);
  75.            return newConn;
  76.        }
  77.        throw new Exception("连接池已满");
  78.    }
  79. }
复制代码
2. 分布式场景价值


  • 资源复用：避免频繁创建销毁数据库连接（创建成本高，约 10-100ms），提升系统性能。
  • 限流保护：通过maxSize控制并发连接数，防止数据库被压垮。
七、代理模式：分布式服务的透明代理

7.1 模式核心与远程代理

代理模式通过代理对象控制对目标对象的访问，在分布式系统中常用于远程代理（RPC 调用）、安全代理（权限控制）等场景。
1. RPC 服务的动态代理实现
  1. // 服务接口
  2. public interface UserService {
  4.    User getUser(Long id);
  5. }
  8. // 远程代理：客户端代理
  9. public class RpcProxy implements InvocationHandler {
  11.    private String serviceUrl; // 服务端地址
  12.    public RpcProxy(String serviceUrl) {
  13.        this.serviceUrl = serviceUrl;
  14.    }
  16.    // 创建代理实例
  17.    public <T> T createProxy(Class<T> serviceInterface) {
  19.        return (T) Proxy.newProxyInstance(
  20.            serviceInterface.getClassLoader(),
  21.            new Class[]{serviceInterface},
  22.            this
  23.        );
  24.    }
  26.    @Override
  27.    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  29.        // 1. 封装RPC请求（服务名、方法名、参数）
  30.        RpcRequest request = new RpcRequest(
  31.            method.getDeclaringClass().getName(),
  32.            method.getName(),
  33.            args
  34.        );
  36.        // 2. 发送请求到服务端
  37.        RpcClient client = new RpcClient(serviceUrl);
  38.        RpcResponse response = client.send(request);
  39.        // 3. 处理响应
  40.        if (response.hasError()) {
  41.            throw response.getError();
  42.        }
  43.        return response.getResult();
  44.    }
  45. }
  47. // 客户端使用
  48. public class Client {
  50.    public static void main(String[] args) {
  51.        // 创建代理对象
  52.        RpcProxy proxy = new RpcProxy("http://user-service:8080/rpc");
  53.        UserService userService = proxy.createProxy(UserService.class);
  55.        // 透明调用远程服务（仿佛调用本地方法）
  56.        User user = userService.getUser(1L);
  57.    }
  58. }
复制代码
2. 分布式场景价值


  • 透明远程调用：客户端通过代理像调用本地方法一样调用远程服务，无需关注网络通信细节。
  • 中间层增强：代理可添加超时控制、重试、负载均衡等逻辑（如RpcProxy中实现失败重试）。
八、面试高频问题深度解析

8.1 基础概念类问题

Q：适配器模式与代理模式的核心区别？在分布式服务集成中如何选择？
A：
维度适配器模式代理模式核心目标解决接口不兼容问题控制对目标对象的访问（如远程调用、权限控制）接口关系适配者与目标接口不同代理与目标接口相同适用场景异构系统集成（如多注册中心适配）远程调用、权限控制、延迟加载

  • 分布式选择：
    集成异构系统（如不同协议、不同 API 的服务）时用适配器模式；需要透明访问远程服务或添加横切逻辑（如超时控制）时用代理模式。
Q：装饰器模式与代理模式都能增强对象功能，如何区分使用场景？
A：

  • 装饰器模式：强调动态组合功能（如为服务调用添加日志 + 熔断 + 监控，组合顺序可调整），核心是 “增强”。
  • 代理模式：强调控制访问（如远程代理控制远程服务的访问，安全代理控制权限），核心是 “控制”。
  • 分布式场景示例：

    • 为 RPC 调用添加日志和监控 → 装饰器模式（功能组合）。
    • 限制只有管理员能调用敏感接口 → 代理模式（访问控制）。

8.2 实战设计类问题

Q：如何用外观模式设计一个电商订单的分布式事务协调器？
A：

  • 子系统：订单服务、库存服务、支付服务、物流服务，每个服务有独立的本地事务。
  • 外观类：OrderTransactionFacade，提供createOrder()方法封装完整流程。
  • 协调逻辑：


  • 采用 SAGA 模式，分步执行本地事务（创建订单→扣减库存→支付→创建物流单）。
  • 每个步骤失败时调用补偿事务（如支付失败则回滚库存和订单）。

  • 客户端：只需调用facade.createOrder()，无需感知分布式事务细节。
Q：分布式缓存系统中，如何用享元模式优化缓存节点的资源占用？
A：

  • 享元对象：缓存连接（如 Redis 连接），将连接的 “主机 / 端口” 作为内部状态，“是否可用” 作为外部状态。
  • 享元工厂：CacheConnectionPool，维护连接池，复用空闲连接（而非每次创建新连接）。
  • 资源控制：通过maxConnections限制总连接数，避免缓存服务器连接过载。
  • 回收机制：定期检测空闲连接，关闭超过阈值的闲置连接（如 5 分钟未使用）。
总结：结构型模式的分布式设计原则

核心选型策略

分布式挑战推荐模式解决思路异构系统集成（多协议 / 多注册中心）适配器模式统一接口，屏蔽差异服务调用的横切逻辑增强装饰器模式动态组合日志、熔断、监控等功能远程服务的透明访问代理模式封装网络通信，模拟本地调用复杂流程的简化与协调外观模式提供统一入口，封装分布式事务等复杂逻辑集群节点的层级管理组合模式树形结构统一管理单机与集群分布式环境的设计要点


  • 网络容错：所有模式实现需考虑网络延迟、超时和重试（如代理模式中添加 RPC 超时控制）。
  • 状态一致性：组合模式和享元模式需处理分布式状态同步（如集群节点状态的一致性）。
  • 性能权衡：代理、适配器等模式可能引入额外开销，需避免过度设计（如轻量级场景可简化模式实现）。
通过掌握结构型模式在分布式系统中的演化与实践，不仅能在面试中清晰解析架构设计问题，更能在实际项目中构建松耦合、可扩展的分布式架构，体现高级程序员的系统设计能力。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
箝德孜
6 天前

0

粉丝关注

16

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫