Anwendungsfunktionen:
Wenn viele komplexe und kleine Funktionen Anrufanforderungen erfordern, haben diese Anrufe häufig ein gewisses Maß an Korrelation, dh ein Anruf ist eine Serie.
Strukturelle Merkmale:
Planen und vereinen Sie die ursprünglich komplexen und zahlreichen Anrufe in eine Eingangsklasse, und dann können Sie diesen Eintrag von nun an nur anrufen.
Beispiel für Codestruktur:
class ModuleOne(object): def Create(self): print 'create module one instance' def Delete(self): print 'delete module one instance' class ModuleTwo(object): def Create(self): print 'create module two instance' def Delete(self): print 'delete module two instance' class Facade(object): def __init__(self): self.module_one = ModuleOne() self.module_two = moduletwo () def create_module_one (self): self.module_one.create () def create_module_two (self): self.module_two.create () Def create_both (self.module_create ().Module_two.create ().Module ().Module_two.create ().Module ().Module_two.create ().Module ().Module_two.create ().Module ().Module_two.create ().Module ().Module_two.create (). Delete_module_one (self): self.module_one.delete () def delete_module_two (self): self.module_two.delete () def delete_both (self): self.module_one.delete () self.module_two.delete () () ())
Es ist ein bisschen ähnlich wie im Proxy -Modus. Der Unterschied besteht darin, dass der Aussehensmodus nicht nur die Funktionen jedes Moduls eines Subsystems in Anspruch genommen, sondern auch aus der Perspektive des Subsystems stammt und die Funktionen jedes Moduls des Subsystems kombiniert, um eine höhere Schnittstelle über die Außenwelt zu liefern, wodurch sich die Bedürfnisse des Subsystems semantisch erfüllen.
Wenn sich die Systemfunktionen weiter ausdehnen, muss das System in mehrere Subsysteme oder Submodule unterteilt werden, um die Kopplung zu reduzieren, die Komplexität des Systemcode zu verringern und die Wartbarkeit zu verbessern, der Proxy -Modus hat normalerweise seine eigenen Vorteile.
Schauen wir uns ein anderes Beispiel an:
Klasse small_or_piece1: def __init __ (self): Pass def do_small1 (self): print 'do small 1' class small_or_piece_2: def __init __ (self): Pass def def do_small2 (self): drucken 'do small 2' class small_or_piec_3: def __init __init __init __ (self): pass def d Def del_small3 (self __init __init __in Außerhalb: def __init __ (self): self .__ small1 = small_or_piece1 () self .__ small2 = small_or_piece_2 () self .__ small3 = small_piece_3 () Def method1 (self): self .__ small1.do_small1 () ## Wenn es mehr als zwei Funcions genannt wird, werden hier mehr als zwei Funktionen genannt. You can clear the original complex function call relationship and unify self.__small2.do_small2() def method2(self): self.__small2.do_small2() self.__small3.do_small3() if __name__ == '__main__': osd = outside() osd.method1() osd.method2()
Ergebnis:
klein machen 1 klein 2 machen klein 2 machen klein 3