第1章 代理模式概览
1.1 设计模式简介
设计模式，作为软件工程中的一种最佳实践，是在解决软件设计中普遍存在问题时被反复证实有效的解决方案模板。它并非具体代码，而是一种描述如何在特定情况下组织代码的设计原则和经验总结。设计模式可以分为三大类：创建型、结构型和行为型。在本文中我们将重点探讨结构型设计模式中的代理模式，其重要性在于能够帮助我们更好地隐藏对象的复杂性，解耦模块之间的依赖，并且提升系统的灵活性和可扩展性。
1.1.1 设计模式定义与分类
设计模式的概念最早由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四位作者在《设计模式：可复用面向对象软件的基础》一书中明确提出。设计模式通常包括模式名称、问题、解决方案、效果和相关实现等要素。其中，结构型设计模式关注类或对象的组合，通过简化接口或者将接口部分化以达到更灵活的系统构建。
1.1.2 结构型设计模式的重要性
设想这样一个场景：你正在构建一款在线音乐播放器，其中包含众多歌曲资源，但并非所有资源都能立即获取。这时，结构型设计模式中的代理模式就派上了用场。它允许我们在不直接操作实体对象的情况下，通过代理对象来控制对真实对象的访问，从而实现诸如延迟加载、权限控制等功能。
1.2 代理模式基本概念
1.2.1 代理模式定义与动机
代理模式（Proxy Pattern）是指为其他对象提供一种代理以控制对这个对象的访问。代理对象与真实对象有相同的接口，客户端可以像对待真实对象那样对待代理对象，而代理对象则负责在必要时调用真实对象的方法。代理模式的主要动机在于添加额外的功能或责任，例如日志记录、安全控制、缓冲或性能优化等，同时保持接口的一致性。
上述UML类图展示了代理模式的基本结构，其中Subject是接口，RealSubject是真实主题，Proxy是代理类，它们之间存在关联关系。
1.2.2 代理模式的角色与职责
? 真实主题（Real Subject）：也称为委托对象，它是代理所代表的真实对象，实现了核心业务逻辑。
? 代理（Proxy）：持有对真实主题的引用，提供了与真实主题相同的接口。代理可以决定何时以及如何调用真实主题的方法，甚至可以在方法调用前后执行附加操作。
在实际开发中，代理模式的应用让我们的代码更加灵活和模块化，使得程序设计更具针对性和适应性，进而吸引了广大技术爱好者和技术从业者的关注和研究。随着后续章节的深入，我们将通过Python实例进一步揭示代理模式的魅力及其在实际开发中的广泛应用。
第2章 Python代理模式详解
2.1 代理模式结构与UML图示
2.1.1 代理类与真实主题关系
代理模式的核心在于代理类与真实主题之间的关系。代理类（Proxy）作为真实主题（Real Subject）的替代品，对外提供与真实主题一致的接口。当客户端通过代理类调用方法时，代理类可以选择直接转发请求给真实主题，或者在调用前后添加额外的操作。这种设计使得客户端无需关心与真实主题交互的具体细节，只需与代理类打交道即可。
上述UML类图展示了代理模式的基本结构。其中，Subject接口定义了通用操作，RealSubject实现了这些操作，而Proxy同样实现了Subject接口，内部持有RealSubject的引用。当客户端调用Proxy.request()时，代理可以根据需要决定是否及如何调用RealSubject.request()。
2.1.2 客户端与代理交互过程
客户端与代理的交互过程遵循以下步骤：
1. 创建代理：客户端创建代理对象，而不是直接创建真实主题对象。
2. 调用方法：客户端通过代理对象调用所需方法，如proxy.request().
3. 代理处理：代理接收到方法调用后，可能执行以下操作之一：
? 直接转发：若无特殊需求，代理直接调用真实主题对应的方法，如real_subject.request().
? 添加额外逻辑：在调用真实主题方法前后，代理可以添加额外功能，如日志记录、权限检查、缓存等。
? 替代行为：在某些情况下，代理可以完全替代真实主题的行为，返回预设结果或执行其他操作。
4. 返回结果：真实主题方法执行完毕后，代理将结果返回给客户端。
2.2 代理模式在Python中的实现
2.2.1 基于类的代理实现
以下是一个基于类的简单代理实现，模拟了一个图书借阅系统。代理类BookProxy负责图书借阅操作，真实主题Book表示具体的图书对象。
class Book:
def __init__(self, title):
self.title = title
self.is_borrowed = False
def borrow(self):
if not self.is_borrowed:
self.is_borrowed = True
print(f"Borrowed {self.title}")
else:
print(f"{self.title} is already borrowed.")
class BookProxy:
def __init__(self, book):
self.book = book
def borrow(self):
# 在借书前检查用户权限
self.check_user_permission()
# 调用真实主题的borrow方法
self.book.borrow()
def check_user_permission(self):
# 假设此处进行了用户权限检查
print("Checked user permission...")
# 客户端代码
book_proxy = BookProxy(Book("Design Patterns"))
book_proxy.borrow()在这个例子中，BookProxy作为代理类，其borrow方法在调用真实主题的borrow方法之前，先执行了权限检查。
2.2.2 使用元类实现动态代理
Python中的元类（metaclass）可以用来创建动态代理。元类允许我们在创建类时对其进行定制，从而实现动态生成代理类。下面是一个使用元类实现的动态代理示例：
import abc
class Subject(metaclass=abc.ABCMeta):
@abc.abstractmethod
def request(self):
pass
class RealSubject(Subject):
def request(self):
print("RealSubject request")
class DynamicProxyMeta(type):
def __new__(cls, name, bases, attrs):
proxy_methods = {}
for base in bases:
for attr_name, attr in vars(base).items():
if callable(attr) and not attr_name.startswith("__"):
proxy_methods[attr_name] = cls.create_proxy_method(attr_name)
attrs.update(proxy_methods)
return super().__new__(cls, name, bases, attrs)
@staticmethod
def create_proxy_method(method_name):
def proxy_method(self, *args, **kwargs):
print(f"Proxy handling {method_name}...")
real_subject = getattr(self, "real_subject")
method = getattr(real_subject, method_name)
return method(*args, **kwargs)
return proxy_method
class DynamicProxy(Subject, metaclass=DynamicProxyMeta):
def __init__(self, real_subject):
self.real_subject = real_subject
# 客户端代码
real_subject = RealSubject()
proxy = DynamicProxy(real_subject)
proxy.request()在这个例子中，DynamicProxyMeta元类在创建DynamicProxy类时，为每个从Subject继承来的非私有方法动态生成了一个代理方法。代理方法在调用真实主题方法前打印一条消息，实现了对真实主题行为的代理。
2.2.3 利用第三方库（如functools）创建代理
Python标准库中的functools模块提供了@wraps装饰器和partial函数，可以方便地创建简单的函数代理。此外，第三方库pyproxy、objproxies等专门用于创建对象代理，简化代理模式的实现。
以functools.partial为例，它可以创建一个新的函数，该函数在调用时固定部分参数。这可以看作是对原函数的一种代理，适用于需要预设某些参数的情况。
from functools import partial
def greet(name, greeting="Hello"):
print(f"{greeting}, {name}!")
greet_proxy = partial(greet, greeting="Good morning")
greet_proxy("Alice") # 输出: Good morning, Alice!在这个例子中，greet_proxy是greet函数的一个代理，它预设了参数greeting为"Good morning"。当调用greet_proxy("Alice")时，实际上相当于调用了greet("Alice", "Good morning")。
通过上述多种实现方式，Python程序员可以根据实际需求灵活运用代理模式，解决各种设计难题，提升代码的可读性、可维护性和可扩展性，从而吸引广大技术爱好者和技术从业者的关注和实践。
第3章 代理模式的应用场景与实例分析
3.1 远程代理（Remote Proxy）
3.1.1 网络服务接口封装
远程代理在分布式系统中扮演着关键角色，它为本地客户端提供了一种间接访问远程服务的方式。比如，在Web服务中，客户端并不直接调用远程服务器上的方法，而是通过代理类发送请求并接收响应。这样做的好处在于，代理可以统一处理网络连接、数据序列化、异常处理等问题，使客户端代码与底层网络通信细节解耦。
例如，我们可以设计一个简单的远程代理，用于调用远程RESTful API：
import requests
class RemoteAPIProxy:
def __init__(self, api_base_url):
self.api_base_url = api_base_url
def get_data(self, endpoint):
url = f"{self.api_base_url}/{endpoint}"
response = requests.get(url)
if response.status_code == 200:
return response.json()
else:
raise Exception(f"Error calling remote API: {response.status_code}")
# 使用代理访问远程API
remote_proxy = RemoteAPIProxy("https://api.example.com")
data = remote_proxy.get_data("users/1")3.1.2 RPC框架中的代理应用
在RPC（Remote Procedure Call）框架中，远程代理尤为常见。如在gRPC、Apache Thrift等框架中，客户端会自动创建一个代理对象，该对象的方法调用会被转换为网络请求并通过网络发送至远程服务器。服务器接收到请求后执行相应操作，并将结果返回给客户端。整个过程对开发者来说就像是本地调用一样透明。
3.2 虚拟代理（Virtual Proxy）
3.2.1 大数据集延迟加载
在处理大数据集时，虚拟代理可以有效减少内存占用和初始化时间。只有在真正需要数据时才去加载。例如，假设有一个庞大的数据库查询结果集：
class LargeDataSet:
def __init__(self, query):
self.query = query
self._data = None
def load_data(self):
# 假设这里是从数据库或其他来源获取大量数据
self._data = fetch_large_data_from_database(self.query)
def get_data(self):
if self._data is None:
self.load_data()
return self._data
class LargeDataSetProxy:
def __init__(self, large_dataset):
self.large_dataset = large_dataset
def get_data(self):
return self.large_dataset.get_data()
# 使用虚拟代理加载数据
large_dataset_proxy = LargeDataSetProxy(LargeDataSet("complex_query"))
# 当首次访问数据时才会触发加载操作
data = large_dataset_proxy.get_data()3.2.2 图像/视频预加载与占位符
在网页或应用程序中，虚拟代理可用于图片或视频资源的预加载。在资源未加载完成时显示占位符，待资源加载完成后替换为真实内容。以下是一个简单的图片预加载代理示例：
class ImageProxy:
def __init__(self, url):
self.url = url
self.image = None
def load_image(self):
self.image = download_image(self.url)
def display(self):
if self.image is None:
self.load_image()
show_image(self.image)
# 使用虚拟代理加载图片
image_proxy = ImageProxy("http://example.com/image.jpg")
# 显示时开始加载，如果还未加载完，则等待加载完成后再显示
image_proxy.display()3.3 保护代理（Protection Proxy）
3.3.1 权限控制与访问限制
保护代理可以确保只有具有足够权限的用户才能访问目标对象。例如，在一个文件系统访问类中，可以使用代理类来验证用户身份和权限：
class File:
def __init__(self, filename):
self.filename = filename
def read(self):
return "Actual file content"
class FileAccessProxy:
def __init__(self, file, user):
self.file = file
self.user = user
def read(self):
if has_access_permission(self.user, self.file.filename):
return self.file.read()
else:
raise PermissionError("User does not have access to this file")
# 创建受保护的文件访问代理
file_proxy = FileAccessProxy(File("secret.txt"), current_user)
try:
content = file_proxy.read()
except PermissionError:
print("Access denied.")
else:
process_file_content(content)3.3.2 日志记录与监控
保护代理还可以用于记录用户对对象的所有操作，以便于审计跟踪和性能监控。每次方法调用前后，代理类都会记录相关信息：
class LoggingFileProxy(FileAccessProxy):
def read(self):
log_operation(self.user, "read", self.file.filename)
try:
result = super().read()
finally:
log_completion(self.user, "read", self.file.filename)
return result
# 使用带有日志功能的保护代理访问文件
logging_file_proxy = LoggingFileProxy(File("log.txt"), current_user)
content = logging_file_proxy.read()3.4 缓冲代理（Caching Proxy）
3.4.1 数据缓存与性能优化
缓冲代理通过存储常用或计算密集型数据的结果，避免频繁的重复计算，从而提高性能。例如，在访问数据库时，可以利用代理缓存查询结果：
class CachedDatabaseQuery:
def __init__(self, db_query):
self.db_query = db_query
self.cache = {}
def execute(self):
query_key = hash(self.db_query)
if query_key not in self.cache:
result = db_execute(self.db_query)
self.cache[query_key] = result
return self.cache[query_key]
# 使用缓存代理执行数据库查询
cached_query = CachedDatabaseQuery("SELECT * FROM users WHERE id = ?")
result_set = cached_query.execute()3.4.2 避免重复计算与资源消耗
在计算密集型场景下，代理可以拦截并缓存计算结果，如数学函数计算、大型数据处理等：
class ComputationProxy:
def __init__(self, expensive_computation):
self.expensive_computation = expensive_computation
self.cached_result = None
def calculate(self):
if self.cached_result is None:
self.cached_result = self.expensive_computation()
return self.cached_result
# 使用计算缓存代理执行耗时计算
expensive_calculation = lambda: heavy_computation()
computation_proxy = ComputationProxy(expensive_calculation)
result = computation_proxy.calculate()3.5 智能引用代理（Smart Reference Proxy）
3.5.1 引用计数与垃圾回收增强
在Python中，虽然已有内置的引用计数垃圾回收机制，但智能引用代理可以进一步优化内存管理和资源释放。例如，通过弱引用（weakref）来跟踪对象，仅当没有强引用指向真实对象时才释放资源：
import weakref
class SmartReferenceProxy:
def __init__(self, real_object):
self.ref = weakref.ref(real_object)
def method(self):
obj = self.ref()
if obj is not None:
return obj.method()
else:
print("Object has been garbage collected.")
# 使用智能引用代理
real_obj = SomeClass()
smart_ref = SmartReferenceProxy(real_obj)
smart_ref.method() # 如果real_obj被销毁，则不会调用其方法3.5.2 对象池管理与资源复用
在一些资源有限或创建成本高的场景，可以通过智能代理实现对象池，复用已创建的对象：
class ObjectPool:
def __init__(self):
self.pool = []
self.max_size = 10
def acquire(self):
if not self.pool:
return self._create_new_object()
else:
return self.pool.pop()
def release(self, obj):
if len(self.pool) < self.max_size:
self.pool.append(obj)
def _create_new_object(self):
return HeavyResource()
class PooledObjectProxy(ObjectPool):
def __init__(self):
self.obj = self.acquire()
def use_resource(self):
return self.obj.some_expensive_operation()
def __del__(self):
self.release(self.obj)
# 使用对象池代理创建和复用资源
resource_proxy = PooledObjectProxy()
result = resource_proxy.use_resource()通过以上各个子章节的实例和说明，我们深入理解了代理模式在不同应用场景下的价值和作用，展现了其在Python编程中的实用性和灵活性。接下来将继续探讨代理模式的优缺点及与其他设计模式的关系。
第4章 Python代理模式实战
4.1 实现一个远程服务代理
4.1.1 定义代理类与真实服务接口
在Python中，我们可以设计一个远程服务代理类，它封装了与远程服务通信的细节，如网络请求、数据序列化、异常处理等。以下是实现一个简单HTTP REST API代理类的示例：
import requests
class RemoteServiceProxy:
def __init__(self, base_url):
self.base_url = base_url
def _make_request(self, method, endpoint, data=None):
url = f"{self.base_url}{endpoint}"
response = requests.request(method, url, json=data)
if response.status_code != 200:
raise Exception(f"Error calling remote service: {response.status_code}")
return response.json()
def get_data(self, resource_id):
endpoint = f"/data/{resource_id}"
return self._make_request("GET", endpoint)
def create_data(self, data_dict):
endpoint = "/data"
return self._make_request("POST", endpoint, data=data_dict)
# 使用代理类访问远程服务
service_proxy = RemoteServiceProxy("https://api.example.com")
data = service_proxy.get_data("123")
new_data = {"key": "value"}
service_proxy.create_data(new_data)4.1.2 添加网络通信与错误处理逻辑
在实际应用中，代理类还需要考虑网络通信的异常情况，如超时、连接失败等。下面的代码展示了如何在代理类中添加错误处理逻辑：
class EnhancedRemoteServiceProxy(RemoteServiceProxy):
def _make_request(self, method, endpoint, data=None):
try:
return super()._make_request(method, endpoint, data)
except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
print(f"Network error occurred: {e}")
return {"error": "network_error"}
except Exception as e:
print(f"Unexpected error occurred: {e}")
return {"error": "unexpected_error"}
# 使用增强的代理类处理网络错误
enhanced_service_proxy = EnhancedRemoteServiceProxy("https://api.example.com")
data = enhanced_service_proxy.get_data("123")4.2 利用虚拟代理优化图像加载
4.2.1 创建占位图代理类
在Web开发中，为了提升用户体验，可以使用虚拟代理实现图片的异步加载。当图片尚未加载完成时，显示占位图，待图片加载完毕后替换为实际内容。以下是一个简单的图片代理类示例：
import threading
from queue import Queue
class ImageProxy:
def __init__(self, image_url, placeholder_url):
self.image_url = image_url
self.placeholder_url = placeholder_url
self.image_loaded = False
self.image_data = None
self.image_queue = Queue()
self.loading_thread = threading.Thread(target=self._load_image)
def _load_image(self):
image_data = download_image(self.image_url)
self.image_data = image_data
self.image_loaded = True
self.image_queue.put(image_data)
def get_image(self):
if not self.image_loaded:
self.loading_thread.start()
return self.placeholder_url
else:
return self.image_data
# 使用图片代理类加载图像
image_proxy = ImageProxy("https://example.com/actual_image.jpg", "https://example.com/placeholder.jpg")
image_url = image_proxy.get_image()4.2.2 异步加载与回调机制实现
为了更灵活地处理图片加载完成后的操作，可以引入回调机制。当图片加载成功后，调用注册的回调函数。以下是一个改进的图片代理类，支持回调函数：
class AsyncImageProxy(ImageProxy):
def __init__(self, image_url, placeholder_url, on_load=None):
super().__init__(image_url, placeholder_url)
self.on_load = on_load
def _load_image(self):
super()._load_image()
if self.on_load and self.image_loaded:
self.on_load(self.image_data)
# 使用异步图片代理类并注册回调函数
def handle_image_load(image_data):
print(f"Image loaded successfully: {image_data}")
async_image_proxy = AsyncImageProxy("https://example.com/actual_image.jpg", "https://example.com/placeholder.jpg", on_load=handle_image_load)
image_url = async_image_proxy.get_image()4.3 通过保护代理实现权限控制
4.3.1 设计权限验证代理类
在需要进行权限验证的场景下，可以创建一个保护代理类，确保只有具有适当权限的用户才能访问目标对象。以下是一个简单的权限验证代理类示例：
class ProtectedResourceProxy:
def __init__(self, resource, user):
self.resource = resource
self.user = user
def access(self):
if user_has_permission(self.user, self.resource):
return self.resource.access()
else:
raise PermissionError("User does not have permission to access this resource")
# 使用保护代理类控制资源访问
protected_resource = ProtectedResourceProxy(Resource(), current_user)
protected_resource.access()4.3.2 整合到实际项目中的示例
在实际项目中，保护代理类可以与现有的身份验证和授权系统集成。以下是一个整合到Flask应用中的保护代理类示例：
from flask import Flask, request, jsonify
app = Flask(__name__)
class User:
def __init__(self, username, role):
self.username = username
self.role = role
class Resource:
def access(self):
return "Resource accessed successfully."
def user_has_permission(user, resource):
# 实现具体的权限检查逻辑，这里仅为示例
return user.role == "admin"
@app.route("/resource", methods=["GET"])
def protected_resource():
user = User(request.headers["username"], request.headers["role"])
resource_proxy = ProtectedResourceProxy(Resource(), user)
try:
result = resource_proxy.access()
return jsonify({"status": "success", "message": result})
except PermissionError as e:
return jsonify({"status": "error", "message": str(e)}), 403
if __name__ == "__main__":
app.run(debug=True)通过以上实战案例，我们不仅加深了对代理模式的理解，还掌握了如何在Python项目中有效地应用代理模式以解决实际问题。接下来将进一步探讨代理模式的优缺点以及何时选用代理模式。
第5章 代理模式优缺点与适用性
5.1 代理模式优点
5.1.1 提高代码可扩展性
代理模式通过引入中间层，极大地增强了代码的扩展能力。例如，在远程服务代理中，我们可以在不修改原有服务接口的前提下，轻松地添加新的网络通信协议、错误处理机制甚至是安全认证功能。这样，无论是新增功能还是调整现有逻辑，都不影响客户端对服务的正常调用。
class ServiceProxy:
def __init__(self, real_service):
self.real_service = real_service
def make_request(self, data):
# 在此可以添加前置处理、日志记录、性能监控等
result = self.real_service.process(data)
# 在此可以添加后置处理、异常处理等
return result5.1.2 隐藏复杂性与细节封装
代理模式能够很好地隐藏真实对象的实现细节，使得客户端只与代理对象交互，从而降低耦合度。例如，在虚拟代理中，代理对象可以先展示占位符图像，然后在后台异步加载实际图像资源，用户只看到最终加载完成的画面，无需了解背后的加载逻辑。
class ImageProxy:
def __init__(self, image_path):
self.image_path = image_path
self.loaded = False
self.image = None
# 异步加载图片
thread = Thread(target=self.load_image)
thread.start()
def load_image(self):
self.image = load_image_from_path(self.image_path)
self.loaded = True
def get_image(self):
if not self.loaded:
return PLACEHOLDER_IMAGE
return self.image5.1.3 支持透明代理与智能代理
透明代理对客户端而言是“透明”的，即客户端不需要知道它在与代理对象交互。智能代理则在代理过程中增加了额外功能，如权限控制、缓存、过滤等。这两种代理都提升了系统的灵活性和可控性。
5.2 代理模式潜在挑战
5.2.1 代码复杂度增加
尽管代理模式提高了代码的扩展性，但它也会增加整体的代码复杂度。每增加一层代理，就需要额外编写和维护代理类，可能导致项目规模扩大，理解和调试难度加大。
5.2.2 性能开销与优化策略
由于代理模式引入了额外的中间层，可能会带来一定的性能损耗，尤其是在涉及频繁调用的真实场景。因此，需要合理设计代理类，尽量减少不必要的计算和资源消耗，如采用延迟初始化、缓存结果等策略优化性能。
5.3 何时选用代理模式
5.3.1 符合特定应用场景特征
代理模式特别适合那些需要在对象访问前后添加额外逻辑、隔离对象访问、管理共享资源或处理跨进程、跨网络通信等情况。例如，当需要对远程服务进行封装时，使用远程代理；当需要高效管理大资源加载时，使用虚拟代理；当需要实现权限控制时，使用保护代理。
5.3.2 结合设计原则与权衡考量
选择代理模式时，应结合单一职责原则、开闭原则等设计原则，评估是否通过代理能更好地分离关注点，同时考虑到性能和维护成本的权衡。只有在满足特定需求且利大于弊时，才应优先考虑采用代理模式。在实践中，设计者需要审慎判断何时以及如何运用代理模式，以达成最优设计决策。
第6章 代理模式与其他设计模式的关系
6.1 与适配器模式的区别与联系
6.1.1 目标与目的对比
适配器模式（Adapter Pattern）和代理模式（Proxy Pattern）都是结构型设计模式，它们都涉及对象间的交互和封装。然而，两者的目标与目的有所不同：
? 适配器模式：主要解决接口不兼容的问题。当现有类的接口不符合客户端期望的接口规范，或者需要将一组不相关的接口转换成单一接口供客户端使用时，适配器提供了一个中间层，将源接口适配为目标接口，使得原本无法直接协同工作的类能够合作无间。
? 代理模式：主要关注对对象访问的控制和扩展。代理为某个对象（真实主题）提供一个替代品，以便在访问真实主题时，可以加入额外的操作，如日志记录、缓存、权限检查等，同时保持对外接口的一致性。代理模式并不改变接口本身，而是控制如何使用这些接口。
6.1.2 结构与实现差异
在结构上，适配器模式与代理模式有相似之处，都引入了一个中间层。但它们的实现侧重点不同：
? 适配器模式通常通过继承或实现目标接口，然后持有源对象实例，并在新接口方法中调用源对象的方法来实现适配。适配器自身不一定是源对象的直接替代品，而是将源对象“包装”成符合目标接口的对象。
? 代理模式则直接继承或实现与真实主题相同的接口，代理对象本身就可以作为真实主题的替代品。代理在接口方法中不仅调用真实主题的方法，还可能执行额外操作。
6.2 与装饰者模式的异同分析
6.2.1 功能增强与代理行为比较
装饰者模式（Decorator Pattern）和代理模式都涉及到对象的包装，但它们的功能增强与代理行为有所区别：
? 装饰者模式专注于在不改变对象接口的前提下，为对象添加新功能。装饰者通过组合而非继承来持有被装饰对象，并在原有功能基础上动态地添加新行为。装饰者模式通常应用于功能扩展，如为咖啡添加调料、为文本添加格式等。
class Coffee:
def __init__(self, description, cost):
self.description = description
self.cost = cost
def get_cost(self):
return self.cost
class MilkDecorator(Coffee):
def __init__(self, coffee):
self.coffee = coffee
self.cost = coffee.get_cost() + 0.99
def get_cost(self):
return self.cost
# 示例：装饰一杯咖啡
base_coffee = Coffee("Espresso", 2..png)
with_milk = MilkDecorator(base_coffee)
print(with_milk.get_cost()) # 输出：2.99? 代理模式关注的是控制对对象的访问，代理类在实现与真实主题相同接口的同时，可能添加额外的控制逻辑，如权限检查、日志记录、缓存等，但不直接扩展对象功能。
class Image:
def load(self):
print("Loading original image...")
class ImageProxy:
def __init__(self):
self._image = None
def load(self):
if self._image is None:
print("Loading proxy image...")
self._image = Image()
self._image.load()
else:
print("Using cached image.")
# 示例：使用代理加载图像
proxy = ImageProxy()
proxy.load()6.2.2 类继承与组合方式探讨
在类继承与组合方式上，装饰者模式与代理模式也体现了不同的设计哲学：
? 装饰者模式采用组合方式，通过层层包裹被装饰对象来叠加功能。装饰者与被装饰者之间通常为“has-a”关系，即装饰者持有被装饰者的实例。这种方式允许在运行时动态地添加或移除装饰器，实现高度的灵活性。
? 代理模式既可以使用继承也可以使用组合，但更倾向于组合，因为组合更易于扩展和维护。代理与真实主题之间通常也为“has-a”关系。代理模式更注重代理对象与真实主题之间的协作，以及代理对象如何控制对真实主题的访问。
综上所述，虽然代理模式、适配器模式和装饰者模式在结构上都涉及对象的包装，但它们的目标、实现方式以及应用场景各有侧重。理解这些模式的异同有助于在实际编程中根据需求选择合适的设计方案。
第7章 结论
代理模式作为结构型设计模式的一员，在Python编程中发挥着关键作用，它通过代理类巧妙地控制对真实主题的访问，实现了功能增强、资源管理、性能优化等多种目标。本章详细阐述了代理模式在远程服务接口封装、大数据集延迟加载、权限控制、数据缓存等实际场景的应用，并通过实例展示了如何基于类、元类以及第三方库如functools来实现代理。尽管代理模式能提高代码可扩展性、隐藏复杂性和支持透明与智能代理，但也带来了代码复杂度增加和性能开销等挑战。在设计抉择时，应结合应用场景特性和设计原则，合理选用代理模式。
代理模式与适配器模式虽都涉及接口转换，但前者着重于访问控制和扩展，后者则聚焦于接口匹配。相较于装饰者模式，代理模式关注代理行为而非单纯的功能增强，两者虽均采用组合，但在目标与结构上有明显差异。
总结起来，代理模式不仅是现代软件开发中的有力工具，还在异步编程、微服务架构、AI与大数据等领域展现出广阔的应用前景。对于技术爱好者和技术从业者，深入掌握代理模式并在实践中灵活运用，将有助于构建更为稳健、高效和可维护的系统。为此，我们鼓励读者持续探索相关书籍、教程和开源项目，不断提升自身设计模式应用能力。
