设计模式系列（13）：结构型模式 - 外观模式

最新推荐文章于 2025-07-20 13:26:18 发布
最新推荐文章于 2025-07-20 13:26:18 发布
阅读量248 收藏 7
点赞数 4
CC 4.0 BY-SA版权
分类专栏： 设计模式 文章标签： 设计模式 外观模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dgatiger/article/details/149319882

系列导读：在学习了功能装饰后，我们来看如何简化复杂系统的使用。外观模式为复杂的子系统提供了一个简单统一的接口。本系列同步更新在微信公众号: 码农秋, 欢迎关注。

解决什么问题：为子系统中的一组接口提供一个统一的高层接口，使子系统更容易使用。隐藏系统复杂性，提供简化的调用方式。

在实际项目中，我们经常需要调用多个子系统来完成一个业务操作。比如，用户下单可能需要调用库存系统、支付系统、物流系统、短信系统等。如果让客户端直接调用这些系统，代码会变得复杂且容易出错。

外观模式就像酒店的前台一样，客户只需要告诉前台自己的需求，前台会协调各个部门来满足客户需求。客户不需要知道酒店内部的复杂流程，只需要通过前台这个简单接口就能享受服务。

本文在系列中的位置：

  • 前置知识：装饰器模式
  • 系列角色：结构型模式实用型
  • 难度等级：★★☆☆☆（概念简单，实用性强）
  • 后续学习：享元模式

目录

1. 模式概述

外观模式是一种结构型设计模式，它为复杂的子系统提供一个简单的接口。外观模式通过定义一个高层接口，使得子系统更容易使用，同时降低了客户端与子系统之间的耦合度。通过外观类，客户端可以只与高层接口交互，无需了解子系统的复杂实现细节。

1.1. 定义

为子系统中的一组接口提供一个统一的接口。外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。外观类封装了子系统的复杂性，对外暴露简洁的操作入口。

1.2. 目的

  • 简化复杂系统的使用，提升开发效率。
  • 降低系统间的耦合度，便于维护和扩展。
  • 提供统一的接口，隐藏子系统实现细节。

2. 使用场景

外观模式适用于以下场景：

  1. 系统集成

    • 需要集成多个子系统，简化调用流程。
    • 需要简化系统接口，提升易用性。
    • 需要降低系统耦合，便于后续维护。

  2. 分层设计

    • 需要分层架构，隔离不同层次的实现。
    • 需要隐藏实现细节，暴露统一接口。
    • 需要提供统一入口，便于上层调用。

  3. 系统重构

    • 需要重构复杂系统，简化对外接口。
    • 需要保持向后兼容，平滑过渡。
    • 需要简化系统使用，降低学习成本。

真实业务背景举例：

  • 大型企业的ERP系统，外观类统一封装财务、采购、库存等子系统，简化业务调用。
  • Web应用的服务层，外观类统一封装底层DAO、缓存、日志等子系统，提升开发效率。
  • 金融行业的支付网关，外观类统一封装多家银行、第三方支付接口，简化业务接入。
  • 电商平台的订单处理系统，外观类统一封装库存、物流、支付等子系统，提升业务开发效率。

3. 优缺点分析

3.1. 优点

  1. 简化使用：简化系统接口，降低使用难度。提高开发效率，便于团队协作。客户端无需了解子系统细节。
  2. 解耦：降低系统耦合，提升灵活性。便于系统维护和升级。支持子系统独立演化。
  3. 封装：隐藏实现细节，提升系统安全性。提供统一接口，便于扩展和维护。支持权限控制和安全校验。

3.2. 缺点

  1. 灵活性：可能限制灵活性，部分高级功能无法暴露。可能影响扩展性，需合理设计外观接口。可能增加系统复杂度，需权衡设计。
  2. 性能影响：可能影响性能，增加调用开销。可能影响执行效率，需优化实现。需避免外观类成为性能瓶颈。
  3. 维护成本：需要维护外观类，保证接口一致性。需要处理版本兼容和异常情况。需合理划分职责，避免外观类过于臃肿。

4. 实际应用案例

  1. 系统集成：多系统集成，统一入口简化调用。服务整合，提升业务开发效率。接口统一，便于外部系统对接。
  2. 框架设计：框架封装，隐藏底层实现细节。API设计，暴露简洁易用的接口。工具类封装，提升开发效率。
  3. 应用开发：模块封装，简化业务逻辑。功能整合，提升系统可维护性。接口简化，降低学习和使用成本。
  4. 系统重构：系统改造，平滑过渡新旧系统。接口升级，兼容历史调用方式。兼容性处理，降低重构风险。

5. 结构与UML类图

@startuml
package "Facade Pattern" #DDDDDD {
  class SystemFacade {
    + saveData(path: String, data: String): void
    + loadData(path: String): String
    + deleteData(path: String): void
    - fileSystem: FileSystem
    - cacheSystem: CacheSystem
    - logSystem: LogSystem
  }
  class FileSystem {
    + save(path: String, data: String): void
    + load(path: String): String
    + deleteFile(path: String): void
  }
  class CacheSystem {
    + put(key: String, value: String): void
    + get(key: String): String
    + remove(key: String): void
  }
  class LogSystem {
    + log(message: String): void
    + error(message: String): void
  }
  SystemFacade o-- FileSystem : fileSystem
  SystemFacade o-- CacheSystem : cacheSystem
  SystemFacade o-- LogSystem : logSystem
}
@enduml

6. 代码示例

6.1 基本结构示例

业务背景： 系统包含多个子系统，客户端希望通过统一入口简化操作，避免直接依赖各子系统。

package com.example.patterns.facade;

import java.util.Objects;

// 子系统A，提供独立功能
public class SubsystemA {
    public void operationA() {
        try {
            System.out.println("SubsystemA: 执行操作A");
        } catch (Exception e) {
            System.err.println("SubsystemA操作失败: " + e.getMessage());
            throw new RuntimeException("SubsystemA操作失败", e);
        }
    }
}

// 子系统B，提供独立功能
public class SubsystemB {
    public void operationB() {
        try {
            System.out.println("SubsystemB: 执行操作B");
        } catch (Exception e) {
            System.err.println("SubsystemB操作失败: " + e.getMessage());
            throw new RuntimeException("SubsystemB操作失败", e);
        }
    }
}

// 子系统C，提供独立功能
public class SubsystemC {
    public void operationC() {
        try {
            System.out.println("SubsystemC: 执行操作C");
        } catch (Exception e) {
            System.err.println("SubsystemC操作失败: " + e.getMessage());
            throw new RuntimeException("SubsystemC操作失败", e);
        }
    }
}

// 外观类，统一封装子系统操作
public class Facade {
    private final SubsystemA subsystemA;
    private final SubsystemB subsystemB;
    private final SubsystemC subsystemC;
    
    /**
     * 构造方法初始化各子系统，便于统一管理
     */
    public Facade() {
        this.subsystemA = new SubsystemA();
        this.subsystemB = new SubsystemB();
        this.subsystemC = new SubsystemC();
    }
    
    /**
     * 统一操作1，封装多个子系统调用
     */
    public void operation1() {
        System.out.println("Facade: 开始执行复合操作1");
        subsystemA.operationA();
        subsystemB.operationB();
        System.out.println("Facade: 复合操作1完成");
    }
    
    /**
     * 统一操作2，封装多个子系统调用
     */
    public void operation2() {
        System.out.println("Facade: 开始执行复合操作2");
        subsystemB.operationB();
        subsystemC.operationC();
        System.out.println("Facade: 复合操作2完成");
    }
}

6.2 企业级应用场景：电商订单处理系统

业务背景： 电商订单处理涉及库存、支付、物流等多个子系统，通过外观模式统一封装，简化业务流程。

package com.example.patterns.facade.ecommerce;

import java.math.BigDecimal;
import java.time.LocalDateTime;

// 库存管理子系统
public class InventorySystem {
    public boolean checkStock(String productId, int quantity) {
        System.out.println("库存系统: 检查商品 " + productId + " 库存数量 " + quantity);
        // 模拟库存检查逻辑
        return quantity <= 100; // 假设库存充足
    }
    
    public void reduceStock(String productId, int quantity) {
        System.out.println("库存系统: 扣减商品 " + productId + " 库存 " + quantity + " 件");
    }
    
    public void restoreStock(String productId, int quantity) {
        System.out.println("库存系统: 恢复商品 " + productId + " 库存 " + quantity + " 件");
    }
}

// 支付子系统
public class PaymentSystem {
    public boolean processPayment(String orderId, BigDecimal amount, String paymentMethod) {
        System.out.println("支付系统: 处理订单 " + orderId + " 支付，金额: ¥" + amount + "，支付方式: " + paymentMethod);
        // 模拟支付处理逻辑
        return amount.compareTo(BigDecimal.valueOf(10000)) <= 0; // 假设金额小于等于10000时支付成功
    }
    
    public void refund(String orderId, BigDecimal amount) {
        System.out.println("支付系统: 订单 " + orderId + " 退款，金额: ¥" + amount);
    }
}

// 物流子系统
public class LogisticsSystem {
    public String createShipment(String orderId, String address) {
        String trackingNumber = "TN" + System.currentTimeMillis();
        System.out.println("物流系统: 创建订单 " + orderId + " 物流单，跟踪号: " + trackingNumber + "，配送地址: " + address);
        return trackingNumber;
    }
    
    public void cancelShipment(String trackingNumber) {
        System.out.println("物流系统: 取消物流单 " + trackingNumber);
    }
}

// 订单管理子系统
public class OrderSystem {
    public String createOrder(String customerId, String productId, int quantity, BigDecimal price) {
        String orderId = "ORD" + System.currentTimeMillis();
        System.out.println("订单系统: 创建订单 " + orderId + "，客户: " + customerId + "，商品: " + productId);
        return orderId;
    }
    
    public void updateOrderStatus(String orderId, String status) {
        System.out.println("订单系统: 更新订单 " + orderId + " 状态为: " + status);
    }
    
    public void cancelOrder(String orderId) {
        System.out.println("订单系统: 取消订单 " + orderId);
    }
}

// 通知子系统
public class NotificationSystem {
    public void sendOrderConfirmation(String customerId, String orderId) {
        System.out.println("通知系统: 向客户 " + customerId + " 发送订单 " + orderId + " 确认通知");
    }
    
    public void sendShippingNotification(String customerId, String orderId, String trackingNumber) {
        System.out.println("通知系统: 向客户 " + customerId + " 发送订单 " + orderId + " 发货通知，跟踪号: " + trackingNumber);
    }
    
    public void sendCancellationNotification(String customerId, String orderId) {
        System.out.println("通知系统: 向客户 " + customerId + " 发送订单 " + orderId + " 取消通知");
    }
}

// 订单处理外观类
public class OrderProcessingFacade {
    private final InventorySystem inventorySystem;
    private final PaymentSystem paymentSystem;
    private final LogisticsSystem logisticsSystem;
    private final OrderSystem orderSystem;
    private final NotificationSystem notificationSystem;
    
    public OrderProcessingFacade() {
        this.inventorySystem = new InventorySystem();
        this.paymentSystem = new PaymentSystem();
        this.logisticsSystem = new logisticsSystem();
        this.orderSystem = new OrderSystem();
        this.notificationSystem = new NotificationSystem();
    }
    
    /**
     * 处理订单 - 统一的业务入口
     */
    public String processOrder(String customerId, String productId, int quantity, BigDecimal price, String paymentMethod, String address) {
        System.out.println("订单处理外观: 开始处理订单");
        
        try {
            // 1. 检查库存
            if (!inventorySystem.checkStock(productId, quantity)) {
                throw new RuntimeException("库存不足");
            }
            
            // 2. 创建订单
            String orderId = orderSystem.createOrder(customerId, productId, quantity, price);
            
            // 3. 扣减库存
            inventorySystem.reduceStock(productId, quantity);
            
            // 4. 处理支付
            BigDecimal totalAmount = price.multiply(BigDecimal.valueOf(quantity));
            if (!paymentSystem.processPayment(orderId, totalAmount, paymentMethod)) {
                // 支付失败，恢复库存
                inventorySystem.restoreStock(productId, quantity);
                orderSystem.cancelOrder(orderId);
                throw new RuntimeException("支付失败");
            }
            
            // 5. 创建物流
            String trackingNumber = logisticsSystem.createShipment(orderId, address);
            
            // 6. 更新订单状态
            orderSystem.updateOrderStatus(orderId, "已确认");
            
            // 7. 发送通知
            notificationSystem.sendOrderConfirmation(customerId, orderId);
            notificationSystem.sendShippingNotification(customerId, orderId, trackingNumber);
            
            System.out.println("订单处理外观: 订单 " + orderId + " 处理完成");
            return orderId;
            
        } catch (Exception e) {
            System.err.println("订单处理外观: 订单处理失败 - " + e.getMessage());
            throw new RuntimeException("订单处理失败", e);
        }
    }
    
    /**
     * 取消订单 - 统一的业务入口
     */
    public void cancelOrder(String customerId, String orderId, String productId, int quantity) {
        System.out.println("订单处理外观: 开始取消订单 " + orderId);
        
        try {
            // 1. 取消物流
            // logisticsSystem.cancelShipment(trackingNumber); // 需要根据订单查询跟踪号
            
            // 2. 处理退款
            // paymentSystem.refund(orderId, totalAmount); // 需要根据订单查询金额
            
            // 3. 恢复库存
            inventorySystem.restoreStock(productId, quantity);
            
            // 4. 更新订单状态
            orderSystem.cancelOrder(orderId);
            
            // 5. 发送通知
            notificationSystem.sendCancellationNotification(customerId, orderId);
            
            System.out.println("订单处理外观: 订单 " + orderId + " 取消完成");
            
        } catch (Exception e) {
            System.err.println("订单处理外观: 订单取消失败 - " + e.getMessage());
            throw new RuntimeException("订单取消失败", e);
        }
    }
}

7. 测试用例

业务背景： 验证外观模式的核心功能，包括基本外观功能和订单处理系统。

package com.example.patterns.facade.test;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.*;
import java.math.BigDecimal;

public class FacadePatternTest {
    
    private Facade basicFacade;
    private OrderProcessingFacade orderFacade;
    
    @BeforeEach
    public void setUp() {
        basicFacade = new Facade();
        orderFacade = new OrderProcessingFacade();
    }
    
    @Test
    public void testBasicFacadeOperations() {
        // 测试基本外观操作
        assertDoesNotThrow(() -> {
            basicFacade.operation1();
            basicFacade.operation2();
        });
    }
    
    @Test
    public void testOrderProcessingSuccess() {
        // 测试成功的订单处理
        String orderId = orderFacade.processOrder(
                "CUST001", 
                "PROD001", 
                2, 
                BigDecimal.valueOf(99.99), 
                "支付宝", 
                "北京市朝阳区xxx"
        );
        
        assertNotNull("订单ID不应为空", orderId);
        assertTrue("订单ID应以ORD开头", orderId.startsWith("ORD"));
    }
    
    @Test
    public void testOrderProcessingFailure() {
        // 测试订单处理失败（金额过大导致支付失败）
        assertThrows(RuntimeException.class, () -> {
            orderFacade.processOrder(
                    "CUST002", 
                    "PROD002", 
                    1, 
                    BigDecimal.valueOf(20000), // 超过支付限额
                    "微信支付", 
                    "上海市浦东新区xxx"
            );
        });
    }
    
    @Test
    public void testOrderCancellation() {
        // 测试订单取消
        assertDoesNotThrow(() -> {
            orderFacade.cancelOrder("CUST001", "ORD123456", "PROD001", 2);
        });
    }
}

8. 常见误区与反例

8.1 常见误区

  • 误区1 ：外观类承担过多职责，成为"上帝类"
  • 误区2 ：外观类与子系统强耦合，难以扩展
  • 误区3 ：忽略异常处理，没有统一的错误处理机制

8.2 反例分析

  • 反例1 ：直接在外观类中实现业务逻辑，违反单一职责原则
  • 反例2 ：外观类暴露子系统的实现细节
  • 反例3 ：没有考虑并发安全问题

9. 最佳实践

9.1 设计原则

  1. 保持外观类的简洁性 ：只做协调和封装，不包含复杂业务逻辑
  2. 合理划分子系统 ：确保子系统职责单一且松散耦合
  3. 提供多层次的外观 ：根据不同的使用场景提供不同级别的外观

9.2 实现技巧

  1. 使用依赖注入 ：提高外观类的可测试性和可配置性
  2. 实现统一的异常处理 ：在外观层统一处理和转换异常
  3. 支持配置化 ：允许通过配置灵活调整子系统的调用策略

10. 参考资料与延伸阅读

  • 《设计模式：可复用面向对象软件的基础》GoF
  • Effective Java（中文版）
  • https://refactoringguru.cn/design-patterns/facade
  • https://www.baeldung.com/java-facade-pattern

本文为设计模式系列第13篇，后续每篇将聚焦一个设计模式或设计原则，深入讲解实现与应用，敬请关注。微信公众号: 码农秋，欢迎关注。

设计模式-外观模式-Facade Pattern
wesigj的博客
09-03 2411
例如，在Java微服务项目中，外观模式可以用于代码分层，其中Facade作为对外暴露API接口的一层，Controller作为API的实现类，Service为核心业务服务。在这些语言中，外观模式的实现方式可能会有所不同，但核心思想是一致的：提供一个高级的接口，简化对子系统的操作。这种模式隐藏了子系统的细节，使得客户端代码可以通过一个简单的接口来访问子系统的功能，从而降低了客户端与复杂子系统之间的耦合度。外观模式是一个强大的工具，可以帮助简化复杂系统的接口，但也应该谨慎使用，以避免引入不必要的抽象层次。
软件工程设计模式分类详解：创建型、结构型与行为型模式的概念及应用场景综述了文档的主要内容
05-20
结构型模式关注类和对象的组合，如适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式。行为型模式关注对象间的通信和职责分配，涵盖责任链模式、命令模式、解释器模式、迭代器模式、中介者...
11结构型设计模式——外观模式
qq_55610255的博客
08-18 1502
外观模式的应用可以使看起来复杂的外观简化，使得系统看起来更加直观和方便。外观模式的缺点可能引入过度封装：外观类可能会过度封装，导致子系统的某些功能无法被直接访问。不适用于所有场景：对于需要高度定制的场景，外观模式可能不适用，因为它提供的是统一的接口，可能无法满足所有特定需求。
C++设计模式结构型模式———外观模式
无敌岩雀的博客
11-04 1356
外观模式定义一组高层接口或者说提供子系统的一个到多个简化接口让子系统更容易使用以及让操作变得更直接，让客户端和子系统实现解耦。当子系统发生改变时，一般只需要修改外观类而基本不需要修改客户端代码（虽然这种修改有点违背开闭原则）。外观模式提供的接口给客户端调用带来了很大的方便，使客户端无须关心子系统的工作细节，但这些接口也许缺乏灵活性，当然，如果客户端认为有必要对子系统进行最灵活的控制，那么依然可以绕过外观模式类而直接使用子系统。
Java设计模式- 结构型设计模式-外观模式
Fatter$hday的博客
07-02 1063
Java设计模式- 结构型设计模式-外观模式
设计模式(十)：结构型之外观模式
从基础到源码解析的学习记录
06-09 1263
定义又名门面模式是一种通过为多个复杂的子系统提供一个一致的接口而使这些子系统更加容易被访问的模式该模式对外有一个统一接口外部应用程序不用关心内部子系统的具体的细节这样会大大降低应用程序的复杂度，提高了程序的可维护性。
设计模式结构型——外观模式
tszc95的博客
07-20 1851
外观模式（Facade Pattern）：又叫作门面模式，归属于结构型模式，提供了一个统一的接口，用来访问子系统中的一群接口。外观模式定义了一个高层接口，即为子系统中的一组接口提供一个一致的界面，让子系统更容易使用。外部应用程序不用关心内部子系统的具体细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。外观模式是为了解决类与类之家的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度。
设计模式 - 结构型模式_外观模式
小工匠
02-05 2万+
设计模式是解决程序中不合理、不易于扩展、不易于维护的问题，也是⼲掉⼤部分 ifelse 的利器，在我们常⽤的框架中基本都会⽤到⼤量的设计模式来构建组件，这样也能⽅便框架的升级和功能的扩展。但如果不能合理的设计以及乱⽤设计模式，会导致整个编程变得更加复杂难维护，也就是我们常说的: 反设计 、 过渡设计。⽽这部分设计能⼒也是从实践的项⽬中获取的经验，不断的改造优化摸索出的最合理的⽅式，应对当前的服务体量。外观模式也叫⻔⾯模式，主要解决的是降低调⽤⽅的使⽤接⼝的复杂逻辑组合。
【愚公系列】软考中级-软件设计师 051-面向对象技术（设计模式-结构型）
时光隧道
01-27 8万+
设计模式是在软件设计领域中，为解决常见问题而被反复使用、被广泛认可的一种设计思想。它是一种经过实践验证的，被认为是最佳解决方案的经验总结，可以帮助开发人员快速高效地解决软件设计中的一些固有问题。每一个设计模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动。设计模式的核心在于提供了相关问题的解决方案，使得人们可以更加简单方便的复用成功的设计和体系结构。特点描述在特定情况下被使用。
设计模式之结构型模式
m0_64974617的博客
11-25 1419
结构型模式主要用于处理类或对象的组成结构，即如何将类或对象组合成更大的结构。这些模式通常关注于对象的组合、接口的设计以及类的组合关系。通过这些模式，我们可以更灵活地设计类结构，提高代码的可复用性和可维护性。结构型模式主要用于处理类或对象的组成结构，通过组合、委托、封装等方式，提高代码的可复用性和可维护性。常见的结构型模式包括适配器模式、桥接模式、组合模式、装饰器模式、代理模式、享元模式和外观模式。每种模式都有其独特的应用场景和优点，理解并掌握这些模式可以帮助我们在实际开发中更好地设计和优化代码结构。
【愚公系列】软考高级-架构设计师 086-创建型设计模式
热门推荐
时光隧道
05-26 9万+
在软件开发中，模式是帮助开发人员解决常见问题并提高开发效率的重要工具。模式可以分为架构模式、设计模式和惯用法三种类型。架构模式：高层决策，涉及系统的整体结构（如C/S结构）。设计模式：中层决策，提供解决常见问题的方案，包含模式名称、问题、解决方案和效果四个基本要素。惯用法：低层决策，关注特定编程语言中的实现细节和最佳实践。理解并运用这些模式，可以帮助开发人员提高软件设计和实现的质量与效率。
JAVA-设计模式-结构型模式-外观模式
08-10
JAVA-设计模式-结构型模式-外观模式
软件工程设计模式全解析：创建型、结构型与行为型模式在软件开发中的应用及优化
05-21
文章详细讲解了创建型模式（如单例模式、工厂模式、建造者模式、原型模式）、结构型模式（如适配器模式、装饰器模式、代理模式、外观模式）和行为型模式（如观察者模式、策略模式、模板方法模式、责任链模式）三大类...
c++设计模式-结构型模式-外观模式
06-13
c++设计模式-结构型模式-外观模式；qt工程；c++简单源码； 外观（Facade）模式又叫作门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，...
深入理解设计模式之模板模式：优雅地定义算法骨架
vvilkin的学习备忘
07-19 517
在软件开发中，我们经常会遇到这样的情况：多个类执行相似的操作流程，但每个类在流程的某些步骤上有自己特定的实现。如果为每个类都完整地编写整个流程，会导致大量重复代码，且难以维护。这时候，模板模式（Template Method Pattern）就派上用场了。
《Python 类设计模式：属性分类（类属性 VS 实例属性）与方法类型（实例 / 类 / 静态）详解》
xw3373409564的博客
07-16 1177
当用print()或str()输出对象时，会自动调用__str__，返回一个用户友好的字符串。# 自定义打印格式return f"我叫{self.name}，今年{self.age}岁"p = Person("小明", 18)print(p) # 输出：我叫小明，今年18岁（自动调用__str__）print(str(p)) # 输出：我叫小明，今年18岁（同样调用__str__）默认==比较对象的内存地址，用__eq__可自定义比较规则。self.id = id # 学号（唯一标识）
模式结构-微服务架构设计模式
zyl042的博客
07-18 319
需求部分描述了必须解决的问题和围绕这个问题的特定上下文环境。需求有时候是相互冲突的，所以。哪一个需求更重要，取决于他的上下文。你必须把。
深入理解设计模式：访问者模式详解
最新发布
vvilkin的学习备忘
07-20 620
在软件开发中，我们经常会遇到需要对一个复杂对象结构进行操作的情况。随着需求的不断变化，我们可能需要在这个对象结构上添加各种新的操作。如果直接在对象结构中添加这些操作，会导致类的职责过重，且每次添加新操作都需要修改原有代码，违反了开闭原则。访问者模式（Visitor Pattern）就是为了解决这类问题而诞生的。 本文将全面介绍访问者模式，包括其定义、结构、实现方式、优缺点、适用场景以及在实际项目中的应用案例，帮助读者深入理解这一重要的设计模式。
前端设计模式应用精析
技术分享
07-17 784
解耦艺术通过观察者模式将视图层与数据流分离（如 Vue 的响应式系统），而控制反转在工厂模式中体现为组件创建权移交框架（React 的 ReactDOM.createRoot）。当代架构趋势如 React Server Components，本质是策略模式（渲染位置决策）、代理模式（服务端-客户端组件桥接）与组合模式的深度融合。本文精析 8 个核心模式，结合原生 JavaScript 与框架实践，揭示模式在现代前端架构中的底层映射与应用。核心思想：将操作封装为对象，支持撤销/重做与事务管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值