数据结构
网络
关系型数据库管理系统
操作系统
Java
MS Excel
iOS
HTML
CSS
Android
Python
C 编程
C++
C#
MongoDB
MySQL
Javascript
PHP
物理学
化学
生物学
数学
英语
经济学
心理学
社会学
时尚研究
法律研究Python 中的对象通信代理设计模式
类和对象是编程的基本元素。这些实体构建了整个逻辑并控制对代码不同部分的访问。可能会出现我们受到操作复杂性限制的情况，因此，我们需要一个高效且优化的解决方案。
代理设计模式就是这样一种强大的技术，它可以创建代理类而不是真实类的实例。在本文中，我们将探讨这种技术的要点，并了解如何使用它来解决涉及大量数据的问题。让我们开始讨论。
理解代理设计模式
在代理设计模式中，我们创建一个充当真实类接口的代理类。现在，问题是我们为什么要创建接口？好吧，当我们处理涉及大量内存和时间的问题时，重复使用类的对象和数据而不是重复创建新的引用是合乎逻辑的。
在创建类之后，我们使用对象/实例来访问类数据，但是如果类操作很复杂，则应适当地规范对象实例化。
这就是代理设计模式发挥作用的地方。为包含大量数据的真实类初始化新对象是一种代价高昂的方法。相反，我们可以创建一个类似于真实类的代理类，并且可以根据操作需要进行自定义。
考虑一种情况，我们需要计算检索数百万名政府雇员的信息。如果客户端尝试通过为每个调用创建实例来直接访问真实类，那么这将使整个过程变得非常昂贵。明智的做法是使用一个媒介或接口，该媒介或接口具有真实类所有属性，并且可以通过代理类进行控制。
使用代理设计模式进行对象通信
对象通信是指在同一模式内不同代理对象之间的数据传输。我们只会创建一个真实的类实例，其余的操作将依赖于不同的代理对象及其相互交互。
我们将创建一个抽象类，它将作为创建真实类和代理类的模板。此抽象类将由这些具体类实现。我们的任务是检索与 200 万名政府雇员的薪资相关的信息。我们将创建两个抽象方法来计算薪资并显示雇员详细信息。
这两个方法都将在具体/真实类中定义。
在具体类中，将计算和处理 200 万名雇员的薪资。此操作的计算需求非常昂贵，因此我们将创建一个代理类。
在代理类中，我们将再次实现抽象类的方法，并添加额外的自定义层。我们自定义程序以检查类属性“real_OBJ”是否存在。
第一次执行程序时，将创建一个真实类对象，此后每次执行都将使用缓存对象。缓存对象为数据可重用性提供了一个更快的平台。通过这种方式，我们将使用单个真实对象并借助不同的代理对象对其进行控制。
示例
以下是实现对象通信代理设计模式的示例。
import abc
class Abstract_Base_class(metaclass=abc.ABCMeta):
@abc.abstractmethod
def Sal_calculator(self, rate):
pass
@abc.abstractmethod
def employee_details(self):
pass
class concrete(Abstract_Base_class):
def __init__(self):
self.total_employees = []
for x in range(2000000):
self.total_employees.append(x)
def employee_details(self):
self.employeeSector = "Government"
return len(self.total_employees), self.employeeSector
def Sal_calculator(self, rate):
self.total_sal = 150000 * rate * len(self.total_employees)
return self.total_sal
class proxy(Abstract_Base_class):
def __init__(self):
if not getattr(self.__class__, "real_OBJ", None):
self.__class__.real_OBJ = concrete()
print("A real object is created")
else:
print("Object already exists, using cached object")
def Sal_calculator(self, rate):
return self.__class__.real_OBJ.Sal_calculator(rate)
def employee_details(self):
return self.__class__.real_OBJ.employee_details()
if __name__ == "__main__":
first_Prox = proxy()
print(f"The total Salary budget with a 12% rate is: {first_Prox.Sal_calculator(12)}")
print(f"The total Salary budget with a 10% rate is: {first_Prox.Sal_calculator(10)}")
print(f"The total Salary budget with a 15% rate is: {first_Prox.Sal_calculator(15)}")
Second_Prox = proxy()
print(f"The total number of employees and their sectors are: {Second_Prox.employee_details()}")
Third_Prox = proxy()
print("This is a 3rd proxy object")
输出
A real object is created The total Salary budget with a 12% rate is: 3600000000000 The total Salary budget with a 10% rate is: 3000000000000 The total Salary budget with a 15% rate is: 4500000000000 Object already exists, using cached object The total number of employees and their sectors are: (2000000, 'Government') Object already exists, using cached object This is a 3rd proxy object
结论
在本文中，我们介绍了对象通信代理设计模式的基础知识。我们了解了内存和时间在计算操作中的重要性。我们使用代理对象来生成优化的程序。借助这些对象，可以避免昂贵的对象调用。最后，我们讨论了计算 200 万名员工数据的现实问题，并使用代理对象来处理此复杂操作。
85 次浏览
