二、外观模式（Facade Pattern）
2.1 概念与动机
外观模式的核心思想非常直观：为复杂子系统提供一个统一的高层接口，使子系统更容易使用。打个比方，一个完整的家庭影院系统包含投影仪、音响、播放器、灯光控制等多个组件，用户如果每次看电影都需要逐个启动、配置这些设备，操作成本极高且容易出错。而一个"一键观影"的遥控器按钮，就是外观模式在实际生活中的体现。
在软件开发中，外观模式的价值体现在以下几个方面：首先，它将子系统中的众多接口整合为少数几个高层接口，大幅降低了客户端的认知负担和使用成本；其次，它解耦了客户端和子系统之间的依赖关系，子系统的内部变更不会波及客户端；最后，它提供了一个清晰的系统分层边界，有助于团队协作和模块化开发。
外观模式的适用场景：① 需要为一个复杂子系统提供一个简单的入口；② 客户端与多个子系统之间存在紧密耦合；③ 希望将系统划分为层次结构，每层通过外观作为通信入口。
2.2 经典结构
外观模式的结构包含三个核心角色：Facade（外观类）知道哪些子系统类负责处理请求，将客户端请求委派给对应的子系统对象处理；Subsystem Classes（子系统类）实现子系统的具体功能，处理由Facade分配的任务，但它们对Facade的存在一无所知；Client（客户端）直接调用Facade提供的高层接口，无需直接与子系统交互。
2.3 Python实现：家庭影院系统
下面通过一个家庭影院系统的例子演示外观模式的经典实现。首先是各个子系统组件：
# 子系统类：投影仪
class Projector:
def on(self):
print("[投影仪] 已开启，等待信号输入...")
def set_input(self, source: str):
print(f"[投影仪] 信号源切换至：{source}")
def off(self):
print("[投影仪] 已关闭")
# 子系统类：音响
class SoundSystem:
def on(self):
print("[音响] 已开启")
def set_volume(self, level: int):
print(f"[音响] 音量设置为 {level}")
def set_surround(self, mode: str):
print(f"[音响] 环绕声模式：{mode}")
def off(self):
print("[音响] 已关闭")
# 子系统类：播放器
class MediaPlayer:
def load(self, media: str):
print(f"[播放器] 正在加载：{media}")
def play(self):
print("[播放器] 开始播放")
def stop(self):
print("[播放器] 停止播放")
接下来是外观类的实现，它将所有子系统的启动和关闭流程封装为两个简单的方法：
# 外观类：统一控制接口
class HomeTheaterFacade:
def __init__(self):
self.projector = Projector()
self.sound = SoundSystem()
self.player = MediaPlayer()
def watch_movie(self, movie_name: str):
"""一键观影：封装所有子系统的启动流程"""
print(
"\n===== 启动观影模式 =====\n")
self.projector.on()
self.projector.set_input(
"HDMI 1")
self.sound.on()
self.sound.set_volume(
20)
self.sound.set_surround(
"影院")
self.player.load(movie_name)
self.player.play()
print(
"\n===== 祝您观影愉快 =====\n")
def end_movie(self):
"""一键关闭：封装所有子系统的关闭流程"""
print(
"\n===== 关闭系统 =====\n")
self.player.stop()
self.sound.off()
self.projector.off()
print(
"\n===== 系统已全部关闭 =====\n")
# 客户端代码
if __name__ ==
"__main__":
theater = HomeTheaterFacade()
theater.watch_movie(
"星际穿越.mp4")
theater.end_movie()
输出说明：客户端只需调用 watch_movie() 和 end_movie() 两个方法即可完成复杂的多设备协同操作。子系统类的内部修改（例如更换音响型号、增加新设备）不会影响客户端的调用方式，真正实现了"高内聚、低耦合"的设计目标。
2.4 外观模式在Python标准库中的应用
Python标准库中外观模式的应用俯拾即是。os模块是对操作系用系统调用的外观封装——开发者调用 os.listdir() 或 os.path.join() 时，完全不需要关心底层是Linux的syscall还是Windows的Win32 API。shutil模块是文件和目录操作的外观，在 os 模块基础之上提供了更高级的文件复制、归档等接口。subprocess模块则是进程创建和管理的终极外观，它统一了 os.system()、os.popen() 等旧式接口，提供了一套简洁而强大的进程通信方案。
在第三方生态中，Requests库是最为人熟知的外观模式典范。它隐藏了urllib3中复杂的连接池管理、SSL握手、重定向处理、Cookie持久化等底层细节，让HTTP请求变得像 requests.get(url) 这样一行代码就能完成。
# Requests库作为外观模式的经典体现
# 底层涉及：连接池管理、SSL/TLS握手、HTTP协议解析、重定向处理、Cookie管理
# 上层接口：统一的请求方法
import requests
# 一行代码发起完整的HTTP请求
response = requests.get(
"https://api.github.com",
headers={"Accept": "application/vnd.github.v3+json"},
timeout=10
)
print(response.json())
2.5 外观模式的优缺点
优势
- 降低客户端与子系统之间的耦合度
- 简化复杂系统的使用接口，降低学习成本
- 提供清晰的系统分层边界，增强可维护性
- 子系统可以独立演进，不影响客户端
劣势
- 外观类可能成为"上帝对象"，承担过多职责
- 过度使用会导致业务逻辑全部集中在外观层
- 当子系统发生变化时，外观类可能需要同步修改
- 不恰当的抽象会限制客户端对底层功能的灵活访问
三、代理模式（Proxy Pattern）
3.1 概念与动机
代理模式的核心思想是为一个对象提供一个替身或占位符，通过这个替身来控制对原对象的访问。代理和被代理对象实现相同的接口，客户端感知不到代理的存在——在客户端看来，它操作的就是原对象。正是这种"透明替换"的特性，使得代理可以在不修改原有业务代码的前提下，织入额外的控制逻辑。
代理模式之所以重要，源于一个基本事实：在真实系统中，对象的创建和访问往往伴随着昂贵的代价。例如，高分辨率图片的加载需要耗费大量I/O和内存，远程服务调用需要网络通信开销，敏感数据的访问需要权限校验。如果将所有对象的创建和访问操作都安排得"一视同仁"，系统资源会被严重浪费。代理模式提供了一种精巧的解决方案：在真正需要时才创建或访问对象，并在访问过程中插入必要的控制逻辑。
代理模式的四种常见变体：① 虚拟代理（Virtual Proxy）——延迟创建开销大的对象，直到真正使用时才实例化；② 保护代理（Protection Proxy）——在访问对象前进行权限检查；③ 远程代理（Remote Proxy）——屏蔽远程对象调用的网络细节，使远程调用像本地调用一样透明；④ 日志代理（Logging Proxy）——在不修改原对象的情况下记录方法调用的日志信息。
3.2 经典结构
代理模式的结构围绕三个核心角色展开：Subject（抽象主题）定义了真实主题和代理的共同接口，是两者可互换的保证；RealSubject（真实主题）是真正执行业务逻辑的对象，代理所代表的最终目标；Proxy（代理）持有对RealSubject的引用，实现与Subject相同的接口，在转发请求给RealSubject前后执行附加操作。
3.3 虚拟代理：延迟加载图片
虚拟代理是代理模式中最常见的应用之一。当一个对象的创建代价很高（如需要加载大型文件、建立网络连接、执行复杂计算），但在系统启动时并不一定立即需要时，可以通过虚拟代理延迟其实例化。以下是一个图片查看器中使用虚拟代理延迟加载高分辨率图片的例子：
from abc import ABC, abstractmethod
import time
# 抽象主题
class Image(ABC):
def display(self):
"""在界面上显示图片"""
pass
# 真实主题：高分辨率图片（创建代价高）
class HighResolutionImage(Image):
def __init__(self, filename: str):
self.filename = filename
self._load_from_disk()
def _load_from_disk(self):
"""模拟从磁盘加载大文件（耗时操作）"""
print(f"正在从磁盘加载高清图片：{self.filename} ...")
time.sleep(2) # 模拟加载耗时
self.data = f"[{self.filename} 的高清像素数据]"
print(f"图片 {self.filename} 加载完成")
def display(self):
print(f"显示图片：{self.data}")
# 代理：延迟加载代理
class LazyImageProxy(Image):
def __init__(self, filename: str):
self.filename = filename
self._real_image = None # 延迟实例化
def display(self):
"""在第一次调用 display() 时才加载真实图片"""
if self._real_image is None:
print("[代理] 检测到首次访问，开始加载真实图片...")
self._real_image = HighResolutionImage(self.filename)
else:
print("[代理] 图片已加载，直接返回缓存实例")
self._real_image.display()
# 客户端代码
if __name__ == "__main__":
# 创建代理时不会加载图片
image = LazyImageProxy("travel_photo_4k.jpg")
print("代理已创建，图片尚未加载（节省了启动时间）")
# 第一次显示时才真正触发加载
print("\n第一次调用 display():")
image.display()
# 第二次显示直接使用缓存
print("\n第二次调用 display():")
image.display()
3.4 保护代理：权限控制
保护代理在将请求转发给真实对象之前执行访问权限检查。这在实现细粒度的权限控制系统时非常有用，尤其是当真实对象的代码无法修改（例如属于第三方库）或不宜混合权限逻辑时。
from abc import ABC, abstractmethod
from enum import Enum, auto
class UserRole(Enum):
GUEST = auto()
USER = auto()
ADMIN = auto()
# 抽象主题
class Document(ABC):
def read(self) -> str: ...
def write(self, content: str): ...
def delete(self): ...
# 真实主题
class ConfidentialDocument(Document):
def __init__(self, title: str):
self.title = title
self.content = ""
def read(self) -> str:
return f"[{self.title}] 内容：{self.content}"
def write(self, content: str):
self.content = content
print(f"文档 [{self.title}] 已更新")
def delete(self):
print(f"文档 [{self.title}] 已删除")
# 保护代理
class DocumentProtectionProxy(Document):
def __init__(self, doc: Document, user_role: UserRole):
self._doc = doc
self._role = user_role
def _check_permission(self, operation: str) -> bool:
permissions = {
UserRole.GUEST: {"read"},
UserRole.USER: {"read", "write"},
UserRole.ADMIN: {"read", "write", "delete"},
}
if operation in permissions.get(self._role, set()):
return True
print(f"[权限拒绝] {self._role.name} 角色无权执行 [{operation}] 操作")
return False
def read(self) -> str:
if not self._check_permission("read"):
return ""
return self._doc.read()
def write(self, content: str):
if not self._check_permission("write"):
return
self._doc.write(content)
def delete(self):
if not self._check_permission("delete"):
return
self._doc.delete()
# 客户端测试
if __name__ == "__main__":
doc = ConfidentialDocument("公司战略规划")
guest_proxy = DocumentProtectionProxy(doc, UserRole.GUEST)
user_proxy = DocumentProtectionProxy(doc, UserRole.USER)
admin_proxy = DocumentProtectionProxy(doc, UserRole.ADMIN)
print("--- 访客尝试写操作 ---")
guest_proxy.write("机密内容")
print("\n--- 普通用户尝试写操作 ---")
user_proxy.write("允许的内容")
print(user_proxy.read())
print("\n--- 管理员执行删除 ---")
admin_proxy.delete()
3.5 远程代理：透明RPC调用
远程代理的核心价值在于让开发者以调用本地对象的方式调用远程服务，完全屏蔽网络通信的复杂性。Python标准库中的 xmlrpc.client 就是远程代理的一个简单实现。
# 远程代理示例：模拟RPC调用
import json
import urllib.request
import urllib.error
class RemoteServiceProxy:
"""远程API调用的透明代理"""
def __init__(self, base_url: str):
self._base_url = base_url.rstrip("/")
self._cache = {}
def _request(self, endpoint: str) -> dict:
"""执行真实的HTTP请求（模拟远程调用）"""
url = f"{self._base_url}/{endpoint}"
print(f"[远程代理] 发起请求：{url}")
# 在实际代码中这里会做 urllib.request.urlopen(url)
# 这里简化模拟
return {"status": "ok", "data": f"模拟响应 from {endpoint}"}
def get_user(self, user_id: int) -> dict:
return self._request(f"users/{user_id}")
def get_posts(self, page: int = 1) -> dict:
return self._request(f"posts?page={page}")
# 客户端像使用本地对象一样使用远程代理
api = RemoteServiceProxy("https://jsonplaceholder.typicode.com")
user_data = api.get_user(1)
posts = api.get_posts(page=2)
3.6 日志代理：无侵入式方法追踪
日志代理在不修改原始类的情况下，为每个方法调用添加日志记录功能，这在调试、审计和性能监控中非常实用。
import functools
import time
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
logger = logging.getLogger("proxy")
class LoggingProxy:
"""通用的日志代理：记录所有调用的入参、返回值和执行时间"""
def __init__(self, target: object):
self._target = target
def __getattr__(self, name: str):
attr = getattr(self._target, name)
if not callable(attr):
return attr
def _logged_call(*args, **kwargs):
logger.info(f"调用: {name}(args={args}, kwargs={kwargs})")
start = time.time()
try:
result = attr(*args, **kwargs)
elapsed = (time.time() - start) * 1000
logger.info(f"返回: {name} -> {result!r} (耗时 {elapsed:.1f}ms)")
return result
except Exception as e:
elapsed = (time.time() - start) * 1000
logger.error(f"异常: {name} -> {e!r} (耗时 {elapsed:.1f}ms)")
raise
return _logged_call
# 使用示例
class Calculator:
def add(self, a: int, b: int) -> int:
return a + b
def divide(self, a: int, b: int) -> float:
return a / b
calc = LoggingProxy(Calculator())
calc.add(3, 5) # 自动记录调用日志和返回值
calc.divide(10, 2) # 同上
3.7 代理模式的优缺点
优势
- 职责清晰：将控制逻辑（延迟加载、权限校验、日志等）与业务逻辑分离
- 开闭原则：可以在不修改真实主题的情况下扩展功能
- 透明性：客户端无需感知代理的存在，调用方式保持一致
- 灵活组合：多种代理可以叠加组合，实现复合需求
劣势
- 增加系统复杂度：引入额外的类和间接层
- 可能降低性能：每次请求都经过代理转发，增加调用开销
- 过度代理导致代码难以调试和追踪
- 代理与真实主题的接口一致性需要严格维护
四、Python特性下的动态代理
Python的动态特性让代理模式的实现可以比传统静态语言更加灵活和简洁。利用 __getattr__ 特殊方法、描述符协议以及标准库中的高阶工具，我们可以用极少的代码实现通用的、可复用的代理机制。
4.1 __getattr__ 实现通用动态代理
在Python中，__getattr__ 方法在对象查找属性失败时被调用。利用这一特性，我们可以创建一个通用代理类，将未找到的属性访问自动转发给被代理对象。这与前面的LoggingProxy原理一致，但我们可以进一步抽象，使其支持多种拦截策略的叠加。
class GenericProxy:
"""基于 __getattr__ 的通用代理基类"""
def __init__(self, target: object):
self._target = target
def __getattr__(self, name: str):
"""将未找到的属性/方法调用自动转发给真实对象"""
attr = getattr(self._target, name)
if not callable(attr):
return attr
def _wrapper(*args, **kwargs):
# 子类可以覆盖 _before 和 _after 方法实现拦截
self._before(name, args, kwargs)
try:
result = attr(*args, **kwargs)
self._after(name, result)
return result
except Exception as e:
self._error(name, e)
raise
return _wrapper
def _before(self, name: str, args: tuple, kwargs: dict):
"""调用前的钩子方法，子类可覆盖"""
pass
def _after(self, name: str, result):
"""调用后的钩子方法，子类可覆盖"""
pass
def _error(self, name: str, exc: Exception):
"""调用异常时的钩子方法，子类可覆盖"""
pass
# 通过继承快速创建具体的代理变体
class TimingProxy(GenericProxy):
"""计时代理：自动记录每个方法的执行时间"""
def _before(self, name, args, kwargs):
self._start = time.time()
print(f"[计时] {name} 开始执行...")
def _after(self, name, result):
elapsed = (time.time() - self._start) * 1000
print(f"[计时] {name} 执行完毕，耗时 {elapsed:.2f}ms")
class CachingProxy(GenericProxy):
"""缓存代理：对无参方法的返回值进行缓存"""
def __init__(self, target):
super().__init__(target)
self._cache = {}
def _before(self, name, args, kwargs):
if not args and not kwargs:
cache_key = name
if cache_key in self._cache:
print(f"[缓存] 命中 {name}，返回缓存结果")
def _after(self, name, result):
if name not in self._cache:
self._cache[name] = result
print(f"[缓存] 已缓存 {name} 的结果")
4.2 LazyProperty：描述符实现的属性级虚拟代理
在Python中，描述符（Descriptor）是控制属性访问的强大工具。我们可以利用描述符协议实现属性级别的虚拟代理——延迟初始化属性（Lazy Property），将属性的计算推迟到首次访问时，并将结果缓存起来供后续访问复用。
class LazyProperty:
"""描述符实现延迟初始化属性"""
def __init__(self, func):
self.func = func
self.attr_name = func.__name__
def __get__(self, instance, owner):
if instance is None:
return self
# 首次访问：调用函数计算结果并缓存
value = self.func(instance)
# 将结果存入实例的 __dict__，后续访问不再触发 __get__
instance.__dict__[self.attr_name] = value
print(f"[LazyProperty] {self.attr_name} 已计算并缓存")
return value
class DataAnalyzer:
def __init__(self, dataset_size: int):
self.dataset_size = dataset_size
def _expensive_computation(self):
"""模拟耗时的数据计算"""
print("正在执行大规模数据计算...")
total = sum(i * i for i in range(self.dataset_size))
return total
def _expensive_ml(self):
"""模拟耗时的机器学习模型训练"""
print("正在训练机器学习模型...")
# 模拟训练过程
return {"accuracy": 0.956, "f1_score": 0.942}
# 使用 LazyProperty 装饰器，属性在首次访问时才计算
@LazyProperty
def summary_stats(self):
return self._expensive_computation()
@LazyProperty
def ml_model(self):
return self._expensive_ml()
# 客户端使用
analyzer = DataAnalyzer(10_000_000)
print("DataAnalyzer 对象已创建，尚未执行任何计算")
# 首次访问 summary_stats 时触发计算
stats = analyzer.summary_stats
print(f"统计结果: {stats}")
# 再次访问直接返回缓存，不会重复计算
stats_again = analyzer.summary_stats
print(f"缓存结果: {stats_again}")
4.3 functools.lru_cache：内置的缓存代理
Python标准库 functools 模块中的 lru_cache 装饰器本质上是缓存代理的一种内置实现。它自动缓存函数的返回值，并提供最大缓存容量和LRU（最近最少使用）淘汰策略。
import functools
import time
class DataService:
@staticmethod
@functools.lru_cache(maxsize=128)
def fetch_data(query_id: int) -> str:
"""模拟从数据库或远程API获取数据的耗时操作"""
print(f"正在从数据源获取 query_id={query_id} 的数据...")
time.sleep(1.5) # 模拟网络延迟
return f"数据结果 for query {query_id}"
svc = DataService()
# 第一次调用：实际执行并缓存
result1 = svc.fetch_data(42)
# 第二次调用相同参数：直接从缓存返回（无 sleep 延迟）
result2 = svc.fetch_data(42)
print(f"两次结果一致：{result1 == result2}")
# 查看缓存命中统计
print(f"缓存统计: {svc.fetch_data.cache_info()}")
# 清理缓存
svc.fetch_data.cache_clear()
关于 lru_cache 的实用建议：该装饰器要求被装饰函数的参数都是可哈希（hashable）的。对于耗时稳定、输入固定的纯函数，使用 lru_cache 可以获得显著的性能提升。需要注意合理设置 maxsize 参数以避免内存泄漏，或将 maxsize 设为 None 使用无限制的普通缓存。
五、外观模式 vs 代理模式 vs 适配器模式对比
外观模式、代理模式和适配器模式同属结构型设计模式，它们的实现方式有一定的相似性（都通过封装一个或多个对象来提供接口），但设计意图和适用场景存在本质区别。理解这些差异对于在实际项目中做出正确的设计决策至关重要。
| 维度 |
外观模式 (Facade) |
代理模式 (Proxy) |
适配器模式 (Adapter) |
| 核心意图 |
简化复杂子系统的使用接口 |
控制对目标对象的访问 |
使不兼容的接口能够协同工作 |
| 接口关系 |
提供全新的简化接口 |
保持与目标对象相同的接口 |
将源接口转换为目标接口 |
| 封装对象数 |
封装多个子系统（一对多） |
封装单个目标对象（一对一） |
封装一个适配者（一对一） |
| 客户端感知 |
客户端明确知道在使用外观 |
客户端不知道代理的存在 |
客户端知道适配后的接口 |
| 附加功能 |
流程编排、功能聚合 |
延迟加载、权限校验、日志等 |
接口转换、数据格式适配 |
| 典型Python案例 |
requests库封装urllib3 |
lru_cache装饰器 |
len()函数适配__len__ |
从表中可以清晰地看到：外观模式的核心在于简化——它面对的是多个子系统，目标是提供更易用的高层接口；代理模式的核心在于控制——它面对的是单个对象，目标是保持接口不变的前提下插入控制逻辑；适配器模式的核心在于转换——它解决接口不兼容的问题，让原本无法协作的类能够合作。在实际开发中，这三种模式甚至可以被组合使用：例如，一个外观类内部可能通过保护代理访问敏感子系统，或者通过适配器接入第三方库。
六、实战案例：数据采集框架中的模式综合应用
下面通过一个完整的数据采集框架案例，演示外观模式和代理模式如何在实际项目中协同工作。该框架需要从多个数据源采集数据，涉及复杂的配置管理、权限控制和缓存优化。
from abc import ABC, abstractmethod
import functools
import time
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("data_framework")
# ------ 子系统：各种数据源 ------
class DatabaseSource:
def connect(self, conn_str: str):
print(f"连接数据库：{conn_str}")
def query(self, sql: str) -> list:
print(f"执行SQL：{sql}")
return [{"id": 1, "name": "Alice"}]
class APISource:
def authenticate(self, api_key: str):
print(f"API认证：{api_key[:8]}...")
def fetch(self, endpoint: str) -> dict:
print(f"调用API：{endpoint}")
return {"status": "ok", "data": [1, 2, 3]}
class FileSource:
def open_file(self, path: str):
print(f"打开文件：{path}")
def read_csv(self) -> list:
print("读取CSV数据...")
return [{"col1": "val1"}]
# ------ 代理层：权限控制 + 缓存 ------
class ProtectedProxy:
"""保护代理：只允许特定角色访问数据源"""
def __init__(self, target, allowed: bool = True):
self._target = target
self._allowed = allowed
def __getattr__(self, name):
attr = getattr(self._target, name)
if not callable(attr):
return attr
def _check_call(*args, **kwargs):
if not self._allowed:
raise PermissionError("无权限访问此数据源")
return attr(*args, **kwargs)
return _check_call
class CachedProxy:
"""缓存代理：对查询类方法进行结果缓存"""
def __init__(self, target):
self._target = target
self._cache = {}
def __getattr__(self, name):
attr = getattr(self._target, name)
if not callable(attr) or name not in {"query", "fetch", "read_csv"}:
return attr
@functools.wraps(attr)
def _cached_call(*args, **kwargs):
cache_key = (name, args, tuple(sorted(kwargs.items())))
if cache_key in self._cache:
logger.info(f"缓存命中：{name}")
return self._cache[cache_key]
result = attr(*args, **kwargs)
self._cache[cache_key] = result
logger.info(f"已缓存：{name}")
return result
return _cached_call
# ------ 外观类：统一的数据采集入口 ------
class DataCollectorFacade:
"""外观类：封装所有数据源的操作，提供统一的采集接口"""
def __init__(self, config: dict):
# 使用代理包装子系统
self.db = CachedProxy(
ProtectedProxy(DatabaseSource(), config.get("db_enabled", True))
)
self.api = CachedProxy(
ProtectedProxy(APISource(), config.get("api_enabled", True))
)
self.file = CachedProxy(
ProtectedProxy(FileSource(), config.get("file_enabled", True))
)
def collect_all(self) -> dict:
"""一键采集所有数据源的数据"""
print("\n===== 开始全量数据采集 =====\n")
results = {}
try:
self.db.connect("mysql://localhost:3306/mydb")
results["db"] = self.db.query("SELECT * FROM users")
except Exception as e:
logger.error(f"数据库采集失败：{e}")
try:
self.api.authenticate("sk-xxxxxxxxxxxxxxxx")
results["api"] = self.api.fetch("/v1/data")
except Exception as e:
logger.error(f"API采集失败：{e}")
try:
self.file.open_file("/data/input.csv")
results["file"] = self.file.read_csv()
except Exception as e:
logger.error(f"文件采集失败：{e}")
print("\n===== 全量数据采集完成 =====\n")
return results
# 客户端使用
config = {"db_enabled": True, "api_enabled": True, "file_enabled": True}
collector = DataCollectorFacade(config)
data = collector.collect_all()
# 第二次采集会命中缓存（如果配置允许）
data_again = collector.collect_all()
在这个实战案例中，外观模式通过 DataCollectorFacade 封装了数据库、API和文件三个子系统的操作流程，客户端只需调用 collect_all() 即可完成全量数据采集；保护代理通过 ProtectedProxy 根据配置控制对各数据源的访问权限；缓存代理通过 CachedProxy 对查询类方法自动缓存结果，避免重复请求。三种模式的组合使用展现了结构型设计模式在实际系统中强大的协同能力。
七、核心要点总结
- 外观模式的核心价值在于"化繁为简"——它为复杂子系统提供统一的高层接口，降低客户端的使用复杂度，同时解耦客户端和子系统之间的依赖关系。
- 代理模式的核心价值在于"控制访问"——通过引入一个替身对象，在不修改原对象的前提下，实现延迟加载、权限控制、日志记录、远程调用等横切关注点。
- Python动态特性让代理模式的实现更加灵活：
__getattr__ 可以实现通用的方法转发代理；描述符协议 __get__ 可以实现属性级别的延迟加载；functools.lru_cache 提供了开箱即用的缓存代理功能。
- LazyProperty 描述符是虚拟代理在属性级别的典型应用——将耗时计算推迟到首次访问时执行，并将结果缓存在实例
__dict__ 中，后续访问无额外开销。
- 三大模式的区别：外观模式提供新接口、封装多个对象；代理模式保持原接口、封装单个对象；适配器模式转换接口、封装单个对象。三者的设计意图不同，适用场景也不同。
- 模式可以组合使用：在实际项目中，外观类内部可以使用代理来包装子系统，代理内部也可以使用外观来简化复杂流程。关键在于理解每种模式的设计意图，在正确的层次上使用它们。
- 避免过度设计：设计模式的引入必然会增加系统的抽象层数和代码量。在简单的场景下，直接调用子系统或使用简单的装饰器函数可能是更务实的选择。设计模式的权衡取舍永远是架构师的核心能力。
八、进一步思考
外观模式和代理模式虽然经典，但并非终极答案。在现代Python开发中，出现了许多基于这些模式思想的新实践：
面向切面编程（AOP）与代理模式有着深刻的亲缘关系。Python的装饰器机制本质上是轻量级的代理实现，而像 contextlib 模块中的 contextmanager、contextDecorator 等工具，则提供了更高级的AOP能力。当需要在多个方法或类中织入横切逻辑（如日志、事务、缓存）时，AOP往往是比手动编写代理类更优雅的解决方案。
依赖注入（DI）框架中的代理生成技术值得关注。像 inject、dependency-injector 等Python DI框架能够在运行时自动生成代理对象，实现懒加载和作用域管理。理解代理模式的工作原理，可以帮助你更深入地理解这些框架的设计思想和配置语法。
异步编程中的代理模式呈现出新的形态。在 asyncio 生态中，代理不仅需要转发方法的调用，还需要正确处理协程的 await 语义。例如，一个异步的缓存代理需要判断被代理方法是否为协程函数，并相应地使用 await 或直接返回结果。
最后，回到设计模式的核心哲学——封装变化。无论外观模式还是代理模式，其本质都是在变化点周围构建一层稳定的抽象。外观封装的是"复杂接口的变化"，代理封装的是"访问方式的变化"。理解这一点，你就能在不同的场景中灵活应用甚至创造新的模式，而不仅仅是机械地套用经典范例。
实践建议：在下一个Python项目中，尝试用 __getattr__ 实现一个通用代理来统一处理日志或性能监控，而不是在每个方法中重复编写样板代码。或者，用 LazyProperty 描述符重构那些在构造函数中执行了昂贵初始化的属性，观察启动性能的提升。这些微小的模式实践，正是架构能力积累的起点。