[GO] Apprenez le modèle de conception "Proxy" en Python
En tant que matériel d'apprentissage des modèles de conception du GoF, le livre «Introduction aux modèles de conception appris dans le langage Java augmenté et révisé» semble être utile. Cependant, comme les exemples repris sont basés sur JAVA, j'ai essayé la même pratique avec Python pour approfondir ma compréhension.
■ Proxy (modèle de proxy)
Le modèle Proxy est un type de modèle de conception en programmation. Un proxy est, en gros, une classe qui agit comme une interface avec autre chose. L '«autre chose» peut être n'importe quoi, comme une connexion réseau, un gros objet en mémoire ou une ressource coûteuse ou impossible à dupliquer. Un exemple bien connu du modèle Proxy est un objet pointeur avec un nombre de références. Dans les situations où plusieurs copies d'un objet complexe sont nécessaires, l'ajout d'un modèle Flyweight au modèle Proxy peut réduire l'utilisation de la mémoire. Normalement, un seul objet complexe est créé et plusieurs objets proxy sont créés. Ces objets proxy ne contiennent que des références à des objets complexes. Les opérations sur le proxy sont transmises à l'objet d'origine. Lorsque tous les objets proxy sont détruits, la mémoire utilisée par l'objet complexe référencé est également libérée.
UML class and sequence diagram
UML class diagram
(Ce qui précède est cité sur Wikipedia)
■ Exemple de programme "Proxy"
En fait, je voudrais exécuter un exemple de programme qui utilise le modèle Proxy et vérifier le comportement suivant.
- Tout d'abord, acceptez "Alice" comme agent d'impression --Préparez l'imprimante pour qu'elle puisse être utilisée (le temps requis est d'environ 10 secondes)
- En fait, utilisez l'imprimante pour effectuer le processus d'impression suivant "** Ravi de vous rencontrer **".
- Ensuite, acceptez "Bob" comme agent d'impression
- En fait, utilisez l'imprimante pour effectuer le processus d'impression suivant "** Hello, World **".
<Traitement de l'impression> (1) Traitez l'agent d'imprimante actuel comme un utilisateur d'imprimante (2) Affichez le nom de l'utilisateur de l'imprimante en l'insérant entre "===" avant et après. (3) Affichez la chaîne de caractères.
$ python Main.py
Le nom de l'agent d'imprimante est maintenant(Alice)est
Instance d'imprimante(Alice)Est en cours de création..........Terminé
===Utilisateur d'imprimante(Alice) ===
Nice to meet you
Le nom de l'agent d'imprimante est maintenant(Bob)est
===Utilisateur d'imprimante(Bob) ===
Hello, World
Le point de confirmation ici est que l'instance d'imprimante (xxx) est en cours de création .......... Done "</ font> n'est affichée qu'une seule fois. C'est un point. Dans l'exemple de programme actuel, le modèle Singleton est utilisé afin qu'une instance d'un objet complexe ne puisse être créée qu'une seule fois.
■ Détails de l'exemple de programme
Un code similaire a été téléchargé dans le référentiel Git. https://github.com/ttsubo/study_of_design_pattern/tree/master/Proxy
- Structure du répertoire
.
├── Main.py
└── proxy
├── __init__.py
└── printer_proxy.py
(1) Rôle du sujet
Définit une interface pour associer les rôles «Proxy» et «RealSubject».
Grâce au rôle «Sujet», le rôle «Client» n'a pas besoin de connaître la différence entre le rôle «Proxy» et le rôle «RealProxy».
Dans l'exemple de programme, la classe Printable remplit ce rôle.
proxy/printer_proxy.py
class Printable(metaclass=ABCMeta):
@abstractmethod
def setPrinterName(self, name):
pass
@abstractmethod
def getPrinterName(self):
pass
@abstractmethod
def myPrint(self, string):
pass
(2) Rôle du mandataire
Le rôle Proxy gère autant que possible les requêtes du rôle Client.
Si vous ne pouvez pas le gérer vous-même, le rôle Proxy laissera le travail au rôle RealSubject.
Le rôle Proxy générera le rôle RealSubject après que vous ayez vraiment besoin du rôle RealSubject.
Le rôle Proxy implémente l'interface définie par le rôle Sujet.
Dans l'exemple de programme, la classe PrinterProxy remplit ce rôle.
proxy/printer_proxy.py
class PrinterProxy(Printable):
def __init__(self, name):
self.__name = name
self.__real = None
def setPrinterName(self, name):
self.__name = name
def getPrinterName(self):
return self.__name
def myPrint(self, string):
self.__real = Printer.getPrinter(self.__name)
self.__real.myPrint(string)
(3) Le rôle du sujet réel
Le rôle de "Sujet réel" du "mandant" apparaît lorsque le rôle de "Proxy" de "l'agent" devient incontrôlable.
Comme le rôle Proxy, ce rôle implémente également l'interface définie par le rôle Sujet.
Dans l'exemple de programme, la classe Printer remplit ce rôle.
proxy/printer_proxy.py
class Printer(Printable):
@classmethod
def getPrinter(cls, name):
if not hasattr(cls, "_instance"):
cls._instance = cls(name)
else:
cls._instance.__name = name
return cls._instance
def __init__(self, name):
self.__name = name
self.__heavyJob('Instance d'imprimante({})Est en cours de création'.format(self.__name))
def setPrinterName(self, name):
self.__name = name
def getPrinterName(self):
return self.__name
def myPrint(self, string):
print('===Utilisateur d'imprimante({}) ==='.format(self.__name))
print(string)
print("")
def __heavyJob(self, msg):
print(msg, end='')
for _ in range(10):
time.sleep(1)
print('.', end='')
print('Terminé')
(4) Le rôle du client
C'est un rôle qui utilise le rôle de «Proxy».
Dans l'exemple de programme, la méthode startMain remplit ce rôle.
Main.py
from proxy.printer_proxy import PrinterProxy
def startMain():
p = PrinterProxy("Alice")
print("Le nom de l'agent d'imprimante est maintenant({})est".format(p.getPrinterName()))
p.myPrint("Nice to meet you")
p.setPrinterName("Bob")
print("Le nom de l'agent d'imprimante est maintenant({})est".format(p.getPrinterName()))
p.myPrint("Hello, World")
if __name__ == '__main__':
startMain()
■ URL de référence
- Finition de «Introduction aux modèles de conception appris en langage Java» (non) Introduction aux modèles de conception appris dans les langages-Finition-Not-2cc9b34a30b2)
- [Article Qiita "Design Pattern #Proxy" (https://qiita.com/nirperm/items/cb200058edb935adb26c)
Recommended Posts