DuProxy.py
# 代理模式 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
标签：__,enormous,Python,Pattern,self,Proxy,print,data,class From： https://www.cnblogs.com/geovindu/p/16817584.html