Technologieaustausch

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Strukturmuster

Proxy-Muster

Proxy-Muster ist ein strukturelles Entwurfsmuster, das den Zugriff auf ein anderes Objekt durch Einführung eines Proxy-Objekts steuert. Dieses Proxy-Objekt kann dem Proxy-Objekt zusätzliche Funktionen bereitstellen, z. B. Zugriffskontrolle, verzögerte Initialisierung, Protokollierung oder Netzwerkzugriff.

Anwendbare Szene

1. Remote-Agent：

   • Bietet eine lokale Darstellung eines Objekts in verschiedenen Adressräumen.

2. virtueller Agent：

   • Erstellen Sie nach Bedarf teure Objekte.

3. Schutzmittel：

   • Kontrollieren Sie den Zugriff auf das Originalobjekt.

4. Intelligente Führung：

   • Führen Sie beim Zugriff auf das Objekt einige zusätzliche Vorgänge aus, z. B. Zählvorgänge oder Referenzerkennung.

Implementierungsbeispiel (Java)

Das Folgende ist ein einfaches Implementierungsbeispiel des Proxy-Musters, das zeigt, wie der Zugriff auf ein tatsächliches Objekt über ein Proxy-Objekt gesteuert wird.

1. Definieren Sie die Theme-Schnittstelle

public interface Subject {
    void request();
}
1
2
3

• veranschaulichen：Subject Die Schnittstelle definiert arequest Methode: Dies ist die Methode, die sowohl vom tatsächlichen Objekt als auch vom Proxy-Objekt implementiert werden muss.

2. Definieren Sie die echte Subjektklasse (RealSubject)

public class RealSubject implements Subject {
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}
1
2
3
4
5

• veranschaulichen：RealSubject Klasse implementiertSubject Schnittstellerequest Methode, die die Klasse darstellt, die die Anfrage tatsächlich verarbeitet.

3. Proxy-Klasse definieren (Proxy)

public class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    public void request() {
        if (this.checkAccess()) {
            this.realSubject.request();
            this.logAccess();
        }
    }

    private boolean checkAccess() {
        // 检查访问权限
        System.out.println("Proxy: Checking access prior to firing a real request.");
        return true;
    }

    private void logAccess() {
        // 记录请求日志
        System.out.println("Proxy: Logging the time of request.");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

• veranschaulichen：
  • Proxy Klasse implementiertSubject Schnittstelle und hält aRealSubject Objekt.
  • existieren request Bei der Methode prüft die Proxy-Klasse zunächst die Zugriffsberechtigungen und ruft dann die des realen Objekts aufrequest Methode und zeichnen Sie schließlich das Anforderungsprotokoll auf.

4. Client-Code

public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Proxy proxy = new Proxy(realSubject);
        
        proxy.request();
    }
}
1
2
3
4
5
6
7
8

• veranschaulichen：
  • Client Klasse erstelltRealSubject UndProxy Objekt, durchProxy Objektaufrufrequest Methode zur Steuerung derRealSubject Zugang.

Vorteil

1. Isolierung：

   • Der Proxy-Modus kann als Vermittler zwischen dem Aufrufer und dem tatsächlichen Objekt dienen, wodurch die Kopplung zwischen Systemkomponenten verringert und die Isolation zwischen Objekten verbessert wird.

2. Sicherheit：

   • Der Zugriff auf tatsächliche Objekte kann über Proxys gesteuert werden, was Sicherheitsüberprüfungen und eine detaillierte Überprüfung ermöglicht.

3. Skalierbarkeit：

   • Der Proxy-Modus kann Funktionen flexibel hinzufügen, ohne den spezifischen Objektcode zu ändern.

4. Intelligent：

   • Einige zusätzliche Vorgänge, wie z. B. verzögerte Initialisierung und Zugriffsprotokolle, können implementiert werden, ohne die Serviceobjektschnittstelle zu ändern.

Mangel

1. Codekomplexität：

   • Die Einführung von Agenten bedeutet auch eine Erhöhung der Komplexität des Systems, möglicherweise die Einführung neuer Klassen und Schnittstellen sowie eine Erhöhung des Codeverständnisses und der Wartungskosten.

2. Reaktionszeit：

   • Der Proxy-Modus kann dazu führen, dass das System langsamer läuft, insbesondere wenn dem Proxy-Vorgang viel Verarbeitungslogik hinzugefügt wird.

3. Designschwierigkeit：

   • Das ordnungsgemäße Entwerfen und Implementieren des Proxy-Musters erfordert eine sorgfältige Prüfung des gesamten Systemdesigns, um sicherzustellen, dass es keine negativen Auswirkungen auf die Systemleistung gibt.

Klassen Diagramm

Client
  |
  v
Subject <---- Proxy <---- RealSubject
1
2
3
4

Zusammenfassen

Das Proxy-Muster bietet eine effiziente Möglichkeit, den Zugriff auf Objekte zu steuern und zu verwalten. Durch die Verwendung von Proxys können Sie verschiedene Funktionen hinzufügen und gleichzeitig die Verantwortlichkeiten von Geschäftsobjekten klar halten. Dieser Modus eignet sich besonders für Szenarien, die eine Zugriffskontrolle und andere Vorverarbeitungsvorgänge für Geschäftsobjekte erfordern.

Fassadenmuster

Fassadenmuster ist ein strukturelles Entwurfsmuster, das die Verwendung komplexer Subsysteme erleichtert, indem es eine einheitliche Schnittstelle für den Zugriff auf eine Gruppe von Schnittstellen im Subsystem bereitstellt. Das Fassadenmuster definiert eine High-Level-Schnittstelle, die die Verwendung dieses Subsystems erleichtert.

Anwendbare Szene

1. Vereinfachen Sie Schnittstellen zu komplexen Systemen：

   • Stellen Sie eine einfache Schnittstelle für komplexe Subsysteme bereit, um die Komplexität externer Interaktionen mit Subsystemen zu reduzieren.

2. Hierarchie：

   • In einer mehrschichtigen Systemstruktur können Erscheinungsmuster verwendet werden, um den Eingang zu jeder Schicht zu definieren und die Abhängigkeiten zwischen Schichten zu vereinfachen.

3. Entkoppeltes System：

   • Durch die Einführung des Erscheinungsmusters wird die Kopplung zwischen dem Subsystem und dem Client verringert.

Implementierungsbeispiel (Java)

Im Folgenden finden Sie ein einfaches Implementierungsbeispiel des Fassadenmusters, das zeigt, wie die Verwendung von Subsystemen durch Fassadenklassen vereinfacht werden kann.

1. Subsystemklassen definieren

public class SubsystemA {
    public void operationA() {
        System.out.println("SubsystemA: operationA");
    }
}

public class SubsystemB {
    public void operationB() {
        System.out.println("SubsystemB: operationB");
    }
}

public class SubsystemC {
    public void operationC() {
        System.out.println("SubsystemC: operationC");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2. Definieren Sie die Erscheinungsklasse

public class Facade {
    private SubsystemA subsystemA;
    private SubsystemB subsystemB;
    private SubsystemC subsystemC;

    public Facade() {
        this.subsystemA = new SubsystemA();
        this.subsystemB = new SubsystemB();
        this.subsystemC = new SubsystemC();
    }

    public void operation1() {
        System.out.println("Facade: operation1");
        subsystemA.operationA();
        subsystemB.operationB();
    }

    public void operation2() {
        System.out.println("Facade: operation2");
        subsystemB.operationB();
        subsystemC.operationC();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3. Client-Code

public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.operation1();
        facade.operation2();
    }
}
1
2
3
4
5
6
7

Anmerkungen

1. Subsystemklasse：

   • SubsystemA, SubsystemB, Und SubsystemC Es handelt sich um die spezifische Implementierungsklasse des Subsystems, und jede Klasse verfügt über ihre eigene, einzigartige Operationsmethode.

2. Erscheinungsklasse：

   • Facade Klassen enthalten Subsystemobjekte und stellen vereinfachte Schnittstellen bereitoperation1 Undoperation2 um Subsystemfunktionen aufzurufen.

3. Client-Code：

   • Client Klasse bestandenFacade Klasse anzurufenoperation1 Undoperation2, wodurch die Verwendung komplexer Subsysteme vereinfacht wird.

Vorteil

1. Vereinfachte Schnittstelle：

   • Das Erscheinungsmuster stellt eine einfache Schnittstelle für Subsysteme bereit und verringert so die Komplexität der Interaktion mit Subsystemen.

2. lose Kopplung：

   • Der Darstellungsmodus reduziert die Kopplung zwischen dem Subsystem und dem Client, was zur Verbesserung der Wartbarkeit und Skalierbarkeit des Systems beiträgt.

3. bessere Schichtung：

   • Darstellungsmuster helfen dabei, eine klare hierarchische Struktur zu schaffen, die den Eingang zu jeder Ebene definiert.

Mangel

1. Entspricht nicht dem Auf-Zu-Prinzip：

   • Beim Hinzufügen neuer Subsystemfunktionen kann es erforderlich sein, die Erscheinungsklasse zu ändern, was gegen das Offen-Geschlossen-Prinzip verstößt (offen für Erweiterungen, geschlossen für Änderungen).

2. Kann Leistungsprobleme verursachen：

   • In einigen Fällen kann die Verwendung des Fassadenmusters zu einer Verschlechterung der Systemleistung führen, da alle Anforderungen die Fassadenklasse durchlaufen müssen.

Klassen Diagramm

Client
  |
  v
Facade ----> SubsystemA
          ----> SubsystemB
          ----> SubsystemC
1
2
3
4
5
6

Zusammenfassen

Das Facade-Muster erleichtert die Arbeit mit komplexen Subsystemen, indem es eine vereinfachte Schnittstelle bereitstellt. Es eignet sich für Szenarien, in denen es erforderlich ist, die Subsystemschnittstelle zu vereinfachen, die direkte Interaktion zwischen Client und Subsystem zu reduzieren und die Systemhierarchie zu entkoppeln. Obwohl es das Potenzial hat, gegen das Offen-Geschlossen-Prinzip zu verstoßen, überwiegen seine Vorteile in den meisten Fällen bei weitem seine Nachteile, wodurch das Systemdesign klarer und einfacher zu warten ist.