灵巧守门员——代理模式（Python实现）

大家好，上一期我们介绍了享元模式，今天我们来讲最后一种结构型设计模式——代理模式。代理模式不仅在控制对象访问上展现了其独特的优势，还在功能扩展和系统安全性上起到了重要作用。接下来，我们将深入探讨一下这个模式的奥秘，并通过Python代码一窥它的实际应用。

什么是代理模式？

代理模式（Proxy Pattern）是一种结构型设计模式，它为其他对象提供了一种代理以控制对这些对象的访问；可以把代理模式理解为一个“守门员”，在客户（Client）和真实对象（RealSubject）之间充当中介，控制请求的传递和处理—— 就像你想看一部付费电影时，需要先通过一个“守门员”确认你是否支付了费用，这名守门员就是代理，他会在你访问电影资源之前先做一些检查，确保你有权利观看。

UML图

示意图

代码实现

接下来，我们通过代码展示如何在Python中实现一些常用的代理模式——静态代理、动态代理、保护代理、虚拟代理。

静态代理实现

class RealSubject:
    def request(self):
        print("真实对象：处理请求。")

class Proxy:
    def __init__(self, real_subject: RealSubject):
        self._real_subject = real_subject

    def request(self):
        print("代理：在真实对象之前检查权限。")
        # 代理控制访问
        self._real_subject.request()
        print("代理：在真实对象之后记录日志。")
# 使用代理
real_subject = RealSubject()
proxy = Proxy(real_subject)
proxy.request()

代码解析： 在这个例子中，代理类 Proxy 通过组合的方式持有真实对象 RealSubject 的实例；代理类的 request 方法在执行前后分别加入了权限检查和日志记录的功能，这种静态代理在编译时确定代理行为，非常适合结构固定的场景。

动态代理实现

动态代理与静态代理的不同在于，动态代理可以在运行时动态地为对象添加功能，而不需要在编译时确定：

import time
from functools import wraps

def timing_proxy(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 执行时间：{end_time - start_time:.4f} 秒。")
        return result
    return wrapper

class SomeService:
    @timing_proxy
    def perform_task(self):
        print("正在执行任务...")
        time.sleep(2)
# 使用动态代理
service = SomeService()
service.perform_task()

代码解析： 通过Python的装饰器，我们可以灵活地实现动态代理，在这个例子中，timing_proxy 装饰器为 perform_task 方法添加了执行时间记录的功能。动态代理能够在不修改原有代码的情况下，为方法或函数动态添加新功能，非常适合需要扩展功能的场景。

保护代理实现

保护代理是一种常见的应用场景，用于控制对对象的访问权限，下面的例子展示了如何实现一个简单的保护代理：

class RealSubject:
    def request(self, user_role):
        print(f"{user_role} 访问：执行敏感操作。")

class ProtectionProxy:
    def __init__(self, real_subject: RealSubject):
        self._real_subject = real_subject

    def request(self, user_role):
        if user_role == "Admin":
            self._real_subject.request(user_role)
        else:
            print(f"访问被拒绝：{user_role} 没有权限。")
# 使用保护代理
real_subject = RealSubject()
proxy = ProtectionProxy(real_subject)

proxy.request("Admin")  # 输出: Admin 访问：执行敏感操作。
proxy.request("Guest")  # 输出: 访问被拒绝：Guest 没有权限。

代码解析： 在这个保护代理的例子中，ProtectionProxy 类控制了对 RealSubject 的访问，只有具备管理员权限的用户才能执行敏感操作，其他用户则会被拒绝访问，这种模式非常适用于权限控制系统。

虚拟代理实现

虚拟代理用于控制昂贵资源的延迟加载，只有在真正需要时才创建对象：

class HeavyResource:
    def load(self):
        print("加载大量数据...")

class VirtualProxy:
    def __init__(self):
        self._real_resource = None

    def request(self):
        if self._real_resource is None:
            self._real_resource = HeavyResource()
            self._real_resource.load()
        print("资源已加载，执行操作。")
# 使用虚拟代理
proxy = VirtualProxy()
proxy.request()  # 首次调用会加载数据
proxy.request()  # 第二次调用不会再次加载数据

代码解析： 在这个虚拟代理的例子中，VirtualProxy 控制了对 HeavyResource 的访问，只有在第一次访问时才会加载实际资源，后续的访问不会再重复加载，这种模式非常适合需要优化性能的场景。

适用场景

代理模式的应用非常广泛，以下是一些典型的场景：

• 远程代理（Remote Proxy）：在分布式系统中，客户端通过代理与远程服务器交互，隐藏底层的复杂网络通信；
• 虚拟代理（Virtual Proxy）：当创建昂贵对象时，虚拟代理可以延迟对象的创建，直到真正需要时再进行实例化，如大型图片的延迟加载；
• 保护代理（Protection Proxy）：在权限控制系统中，通过代理来控制对敏感数据或操作的访问权限，不同用户的权限判断就是一个典型应用；
• 缓存代理（Caching Proxy）：代理模式可以缓存频繁访问的结果，减少系统负载并提升响应速度，例如缓存数据库查询结果。

优缺点

优点：

• 功能增强：代理模式允许你在不修改原始对象的情况下，添加新的功能；
• 访问控制：代理模式可以帮助控制对原始对象的访问权限，提升系统的安全性和稳定性。

缺点：

• 增加复杂性：引入代理模式后，系统的复杂性会增加，尤其是在多个代理叠加使用时；
• 性能开销：代理模式可能会带来额外的性能开销，特别是在频繁调用的场景中，这一点需要特别注意。

总结

代理模式作为一种灵活的结构型设计模式，不仅在增强对象功能、控制访问权限上展现了其独特的优势，还能有效提升系统的安全性和扩展性。虽然它可能会增加系统的复杂性和性能开销，但在合适的场景中，代理模式无疑是提升代码质量的利器。

希望本文能帮助你更好地理解代理模式及其在Python中的实现，并能在实际项目中灵活应用这一设计模式！如果你有任何疑问或想法，欢迎在下方留言！别忘了关注我们的公众号，获取更多有趣的编程知识和实用的代码技巧，我们期待与你的交流与分享！