Python: Proxy Pattern

DuProxy.py

100

101

102

103

104

# 代理模式 Proxy Pattern
from abc import ABCMeta, abstractmethod
import abc
import random
 
 
class ISubject(metaclass=ABCMeta):
    "An interface implemented by both the Proxy and Real Subject"
    @staticmethod
    @abstractmethod
    def request():
        "A method to implement"
 
class RealSubject(ISubject):
    "The actual real object that the proxy is representing"
 
    def __init__(self):
        # hypothetically enormous amounts of data
        self.enormous_data = [1, 2, 3,'geovindu','Geovin Du','涂聚文']
 
    def request(self):
        return self.enormous_data
 
class Proxy(ISubject):
    """
    The proxy. In this case the proxy will act as a cache for
    `enormous_data` and only populate the enormous_data when it
    is actually necessary
    """
 
    def __init__(self):
        self.enormous_data = []
        self.real_subject = RealSubject()
 
    def request(self):
        """
        Using the proxy as a cache, and loading data into it only if
        it is needed
        """
        if self.enormous_data == []:
            print("从真实主体提取数据")
            self.enormous_data = self.real_subject.request()
            return self.enormous_data
        print("从代理缓存中提取数据")
        return self.enormous_data
 
 
class AbstractClass(metaclass=abc.ABCMeta):
    """ interface for real and proxy object """
 
    @abc.abstractmethod
    def sort_digits(self, reverse=False):
        pass
 
 
class RealClass(AbstractClass):
    """ RealClass that holds a larger object """
 
    def __init__(self):
        self.digits = []
 
        for i in range(1000000):
            self.digits.append(random.random())
 
    def sort_digits(self, reverse=False):
        self.digits.sort()
 
        if reverse:
            self.digits.reverse()
 
 
class ProxyClass(AbstractClass):
    """ A proxy class that has the same interface as RealClass. """
 
    ref_count = 0
 
    def __init__(self):
        """ Creates an object if it doesn't exist and caches it otherwise """
 
        if not getattr(self.__class__, '缓存对象', None):
            self.__class__.cached_object = RealClass()
            print('生成新对象')
        else:
            print('使用缓存的对象')
 
        self.__class__.ref_count += 1
        print('引用计数:', self.__class__.ref_count)
 
    def sort_digits(self, reverse=False):
        print('排序方法')
        print(locals().items())
 
        # invokes the sort_digits method of real class
        self.__class__.cached_object.sort_digits(reverse=reverse)
 
    def __del__(self):
        """ Delete the object when the number of reference is 0 """
        self.__class__.ref_count -= 1
 
        if self.__class__.ref_count == 0:
            print('删除缓存对象')
            del self.__class__.cached_object
 
        print('引用计数:', self.__class__.ref_count)

main.py 调用

# 代理模式 Proxy Pattern
duSubject = DuProxy.Proxy()
# use SUBJECT
print(id(duSubject))
# load the enormous amounts of data because now we want to show it.
print(duSubject.request())
# show the data again, but this time it retrieves it from the local cache
print(duSubject.request())
print("\n")
proxA = DuProxy.ProxyClass()
print()
 
proxB = DuProxy.ProxyClass()
print()
 
proxC = DuProxy.ProxyClass()
print()
 
proxA.sort_digits(reverse=True)
print()
 
print('删除对象 proxA')
del proxA
 
print('删除对象 proxB')
del proxB
 
print('删除对象 proxC')
del proxC

输出：

1830765068000
从真实主体提取数据
[1, 2, 3, 'geovindu', 'Geovin Du', '涂聚文']
从代理缓存中提取数据
[1, 2, 3, 'geovindu', 'Geovin Du', '涂聚文']
 
 
生成新对象
引用计数: 1
 
生成新对象
引用计数: 2
 
生成新对象
引用计数: 3
 
排序方法
dict_items([('self', <DuProxy.ProxyClass object at 0x000001AA4219FFA0>), ('reverse', True)])
 
删除对象 proxA
引用计数: 2
删除对象 proxB
引用计数: 1
删除对象 proxC
删除缓存对象
引用计数: 0