什么是代理模式，用 Python 如何实现 Proxy（代理 或 Surrogate）对象结构型模式？

什么是代理模式？

代理（Proxy）是一种结构型设计模式，其目的是通过引入一个代理对象来控制对另一个对象的访问。代理对象充当目标对象的接口，这样客户端就可以通过代理对象间接地访问目标对象，从而在访问过程中实现一些额外的控制、功能或处理。

---

代理模式主要有三种类型：保护代理、虚拟代理和远程代理。

1. 保护代理（Protection Proxy）： 控制对真实对象的访问权限，允许或拒绝对真实对象的请求。例如，访问控制、身份验证等功能可以通过保护代理来实现。

+-----------------+       +---------------------+       +----------------+
|   Subject       |       |    RealSubject     |       |     Proxy      |
|   +request()    |<------|   +SensitiveOp()   |<------| +request()     |
+-----------------+       +---------------------+       +----------------+
1
2
3
4

这个简单的图示表达了保护代理的基本结构。在保护代理中，代理对象可以在调用真实主题的方法前后添加一些控制逻辑，例如检查权限，确保敏感操作只有在合适的条件下才能被执行。

2. 虚拟代理（Virtual Proxy）： 控制对目标对象的访问，延迟目标对象的创建或加载，以减少系统开销。例如，加载大型图像或复杂对象时，可以使用虚拟代理进行懒加载，只有在需要时才真正创建目标对象。

+-----------------+       +---------------------+       +----------------+
|   Subject       |       |    RealSubject     |       |     Proxy      |
|   +request()    |<------|   +loadImage()      |<------| +request()     |
+-----------------+       +---------------------+       +----------------+
1
2
3
4

在虚拟代理（Virtual Proxy）中，“虚拟”体现在代理对象不立即创建或加载真实对象，而是在需要的时候才进行。这种延迟加载的行为使得代理对象在不实际创建真实对象的情况下提供相同的接口。因此，"虚拟"表示的是代理对象对真实对象的懒加载特性。

3. 远程代理（Remote Proxy）： 在不同地址空间中代理对象，使得可以在不同的系统中进行远程通信。远程代理允许客户端访问位于远程服务器上的对象，而不必了解底层的网络细节。

+-----------------+       +---------------------+       +----------------+
|   Subject       |       |    RealSubject     |       |     Proxy      |
|   +request()    |<------|   +remoteRequest() |<------| +request()     |
+-----------------+       +---------------------+       +----------------+
1
2
3
4

在远程代理中，代理对象充当了客户端和真实对象之间的中介，使得客户端可以透明地访问位于远程服务器上的真实对象。代理负责处理网络通信、序列化和反序列化等远程调用的细节，使得客户端无需了解底层的网络细节，实现了对远程对象的透明访问。

---

代理模式的主要优势包括：

• 控制访问： 代理对象可以控制客户端对目标对象的访问，从而增强安全性或实现访问控制。

• 延迟加载： 使用虚拟代理可以延迟目标对象的创建，减少系统启动时间和资源占用。

• 简化接口： 代理对象可以提供更简单的接口，隐藏目标对象的复杂性。

• 远程访问： 远程代理使得客户端可以访问远程服务器上的对象，实现分布式系统中的远程通信。

---

代理模式的一般结构包括：

• 抽象主题（Subject）： 定义了代理和真实对象的共同接口，客户端通过该接口访问真实对象。

• 真实主题（Real Subject）： 实现了抽象主题接口，是代理所代表的真实对象。

• 代理（Proxy）： 实现了抽象主题接口，保存了对真实对象的引用，可以在客户端访问真实对象前后执行一些额外的操作。

代理模式的实现方式在不同编程语言中可能有所不同，但核心思想是引入一个中间层（代理对象）来控制对目标对象的访问。这样的设计提供了更好的灵活性和可维护性，允许在不修改客户端代码的情况下改变目标对象的行为或实现。

模式的意图

为其他对象提供一种代理以控制对这个对象的访问。

别名

Surrogate

---

在 Python 3 中，如何实现（Proxy）代理设计模式：

在 Python 中实现代理（Proxy）设计模式相对简单，因为 Python 语言的特性和语法支持可以轻松地创建代理对象。下面是一个简单的例子，演示了如何实现保护代理（Protection Proxy）：

# 抽象主题（Subject）
class Subject:
    def request(self):
        pass

# 真实主题（Real Subject）
class RealSubject(Subject):
    def request(self):
        print("RealSubject: Handling request")

# 代理（Proxy）
class Proxy(Subject):
    def __init__(self, real_subject):
        self._real_subject = real_subject

    def request(self):
        # 添加额外的控制逻辑
        print("Proxy: Checking access permissions.")
        if self._check_access():
            # 调用真实主题的方法
            self._real_subject.request()
            print("Proxy: Logging the request.")
        else:
            print("Proxy: Access denied.")

    def _check_access(self):
        # 模拟访问权限控制
        # 在实际应用中，这里可能会涉及更复杂的逻辑，如身份验证等
        return True  # 允许访问

# 客户端代码
if __name__ == "__main__":
    real_subject = RealSubject()
    proxy = Proxy(real_subject)

    # 通过代理访问真实主题
    proxy.request()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

在这个例子中：

• Subject 是抽象主题，定义了代理和真实主题的共同接口。
• RealSubject 是真实主题，实现了抽象主题的接口，表示真实的对象。
• Proxy 是代理，包含一个对真实主题的引用，并在调用真实主题的方法前后添加了额外的控制逻辑。

在客户端代码中，我们首先创建了真实主题 RealSubject 和代理 Proxy 的实例，然后通过代理对象调用 request() 方法。代理对象会在调用真实主题的方法前后执行一些额外的操作，例如检查访问权限和记录请求。

这只是代理模式的一个简单示例，实际应用中可能涉及更复杂的场景和逻辑。代理模式可以根据具体的需求进行不同形式的实现，例如虚拟代理（Virtual Proxy）或远程代理（Remote Proxy）。

---

在实现代理模式时，有一些需要注意的地方：

1. 接口一致性： 代理对象应该实现与真实对象相同的接口，以确保客户端能够无缝地切换代理和真实对象。

2. 代理生命周期： 考虑代理对象和真实对象的生命周期。确保代理对象和真实对象的创建、销毁和状态管理都得到正确处理。

3. 懒加载： 在虚拟代理中，确保真实对象的懒加载（延迟加载）逻辑正确实现，只有在需要时才真正创建或加载真实对象。

4. 权限控制： 在保护代理中，确保代理对象正确地进行访问权限的控制，只有在符合条件时才允许客户端访问真实对象。

5. 网络通信： 在远程代理中，要注意网络通信的问题，如处理超时、错误处理、序列化和反序列化等。

6. 性能考虑： 使用代理模式可能引入一些性能开销，特别是在远程代理中。要仔细考虑性能需求，避免不必要的开销。

7. 线程安全性： 如果在多线程环境中使用代理模式，确保代理对象的线程安全性，以避免潜在的并发问题。

8. 代理组合： 考虑使用多个代理对象的组合，形成代理链。代理链可以实现更复杂的控制逻辑，但要注意确保每个代理的职责清晰且不重叠。

9. 避免过度设计： 不要过度设计代理模式。根据实际需求，只添加必要的代理，以避免引入不必要的复杂性。

10. 异常处理： 考虑代理对象和真实对象的异常处理。确保代理对象能够适当地处理异常，并在必要时传递给客户端。

总体来说，代理模式的实现需要根据具体场景灵活运用，确保代理对象能够正确地完成预期的功能，并且与真实对象协同工作。在设计和实现时，理清代理对象和真实对象的职责和关系是非常重要的。

---

本文就到这里了，感谢您的阅读 。别忘了点赞、收藏~ Thanks♪(･ω･)ﾉ 🍇