代理模式

A proxy, in its most general form, is a class functioning as an interface to something else. The proxy could interface to anything: a network connection, a large object in memory, a file, or some other resource that is expensive or impossible to duplicate. In short, a proxy is a wrapper or agent object that is being called by the client to access the real serving object behind the scenes. Use of the proxy can simply be forwarding to the real object, or can provide additional logic. In the proxy, extra functionality can be provided, for example caching when operations on the real object are resource intensive, or checking preconditions before operations on the real object are invoked. For the client, usage of a proxy object is similar to using the real object, because both implement the same interface.
Notes:

• A proxy may hide information about the real object to the client.
• A proxy may perform optimization like on demand loading.
• A proxy may do additional house-keeping job like audit tasks.
• Proxy design pattern is also known as surrogate design pattern.

“代理模式”：在客户端和目标对象之间建立一个代理对象，客户端通过代理对象来访问目标对象；这样可以起到保护或欺骗目标对象的作用。

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
38
39
40

"""
Proxy pattern example.
"""
from abc import ABCMeta, abstractmethod

NOT_IMPLEMENTED = "You should implement this."

class :
    __metaclass__ = ABCMeta


    def drive(self):
        raise NotImplementedError(NOT_IMPLEMENTED)

class Car(AbstractCar):
    def drive(self):
        print("Car has been driven!")

class Driver(object):
    def __init__(self, age):
        self.age = age

class ProxyCar(AbstractCar):
    def __init__(self, driver):
        self.car = Car()
        self.driver = driver

    def drive(self):
        if self.driver.age <= 16:
            print("Sorry, the driver is too young to drive.")
        else:
            self.car.drive()

driver = Driver(16)
car = ProxyCar(driver)
car.drive()

driver = Driver(25)
car = ProxyCar(driver)
car.drive()