Partage de technologie

Exemples de mise en œuvre de scénarios d'utilisation de modèles de conception, avantages et inconvénients (modèle structurel - modèle de proxy, modèle d'apparence)

2024-07-12

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

modèle structurel

Modèle de proxy

Proxy Pattern est un modèle de conception structurelle qui contrôle l'accès à un autre objet en introduisant un objet proxy. Cet objet proxy peut fournir des fonctionnalités supplémentaires à l'objet proxy, telles que le contrôle d'accès, l'initialisation différée, la journalisation ou l'accès au réseau.

Scène applicable

  1. agent distant

    • Fournit une représentation locale d’un objet dans différents espaces d’adressage.
  2. agent virtuel

    • Créez des objets coûteux selon vos besoins.
  3. agent de protection

    • Contrôler l'accès à l'objet d'origine.
  4. Un guidage intelligent

    • Effectuez quelques opérations supplémentaires lors de l'accès à l'objet, telles que des opérations de comptage ou de détection de référence.

Exemple d'implémentation (Java)

Ce qui suit est un exemple simple d'implémentation du modèle de proxy, montrant comment contrôler l'accès à un objet réel via un objet proxy.

1. Définir l'interface du thème
public interface Subject {
    void request();
}
  • 1
  • 2
  • 3
  • illustrerSubject L'interface définit unrequest Méthode, c'est la méthode que l'objet réel et l'objet proxy doivent implémenter.
2. Définir la vraie classe de sujet (RealSubject)
public class RealSubject implements Subject {
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • illustrerRealSubject classe implémentéeSubject Interfacerequest Méthode, représentant la classe qui gère réellement la requête.
3. Définir la classe proxy (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
  • illustrer
    • Proxy classe implémentéeSubject interface et détient unRealSubject objet.
    • exister request Dans la méthode, la classe proxy vérifie d'abord les autorisations d'accès, puis appelle l'objet réelrequest méthode, et enfin enregistrer le journal des demandes.
4. Code client
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
  • illustrer
    • Client classe crééeRealSubject etProxy objet, à traversProxy Appel d'objetrequest méthode pour contrôler leRealSubject Accéder.

avantage

  1. Isolement

    • Le mode proxy peut servir d'intermédiaire entre l'appelant et l'objet réel, réduisant ainsi le couplage entre les composants du système et améliorant l'isolation entre les objets.
  2. sécurité

    • L'accès aux objets réels peut être contrôlé via des proxys, permettant des contrôles de sécurité et une vérification approfondie.
  3. Évolutivité

    • Le mode proxy peut ajouter des fonctions de manière flexible sans modifier le code objet spécifique.
  4. Intelligent

    • Certaines opérations supplémentaires, telles que l'initialisation retardée et les journaux d'accès, peuvent être implémentées sans modifier l'interface de l'objet de service.

défaut

  1. complexité du code

    • L'introduction d'agents signifie également augmenter la complexité du système, éventuellement introduire de nouvelles classes et interfaces, et augmenter la compréhension du code et les coûts de maintenance.
  2. Temps de réponse

    • Le mode proxy peut ralentir l'exécution du système, en particulier si une grande quantité de logique de traitement est ajoutée à l'opération proxy.
  3. Difficulté de conception

    • La conception et la mise en œuvre correctes du modèle de proxy nécessitent un examen attentif de la conception globale du système pour garantir qu'il n'y a pas d'impact négatif sur les performances du système.

Diagramme de classes

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

Résumer

Le modèle de proxy fournit un moyen efficace de contrôler et de gérer l'accès aux objets. En utilisant des proxys, vous pouvez ajouter diverses fonctions tout en gardant claires les responsabilités des objets métier. Ce mode est particulièrement adapté aux scénarios nécessitant un contrôle d'accès et d'autres opérations de prétraitement sur les objets métier.

Modèle de façade

Facade Pattern est un modèle de conception structurelle qui facilite l'utilisation des sous-systèmes complexes en fournissant une interface unifiée pour accéder à un groupe d'interfaces dans le sous-système. Le modèle de façade définit une interface de haut niveau qui rend ce sous-système plus facile à utiliser.

Scène applicable

  1. Simplifiez les interfaces avec les systèmes complexes

    • Fournit une interface simple pour les sous-systèmes complexes afin de réduire la complexité des interactions externes avec les sous-systèmes.
  2. Hiérarchie

    • Dans une structure de système multicouche, des modèles d'apparence peuvent être utilisés pour définir l'entrée de chaque couche et simplifier les dépendances entre les couches.
  3. Système découplé

    • En introduisant le modèle d'apparence, le couplage entre le sous-système et le client est réduit.

Exemple d'implémentation (Java)

Ce qui suit est un exemple simple d'implémentation du modèle Facade, montrant comment simplifier l'utilisation des sous-systèmes via des classes de façade.

1. Définir les classes de sous-systèmes
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. Définir la classe d'apparence
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. Code client
public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.operation1();
        facade.operation2();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Remarques

  1. Classe de sous-système

    • SubsystemA, SubsystemB, et SubsystemC Il s'agit de la classe d'implémentation spécifique du sous-système, et chaque classe possède sa propre méthode de fonctionnement unique.
  2. Classe d'apparence

    • Facade Les classes contiennent des objets de sous-système et fournissent des interfaces simplifiéesoperation1 etoperation2 pour appeler les fonctions du sous-système.
  3. code client

    • Client cours réussiFacade classe à appeleroperation1 etoperation2, simplifiant ainsi l'utilisation de sous-systèmes complexes.

avantage

  1. Interface simplifiée

    • Le modèle d'apparence fournit une interface simple pour les sous-systèmes, réduisant ainsi la complexité de l'interaction avec les sous-systèmes.
  2. couplage lâche

    • Le modèle d'apparence réduit le couplage entre le sous-système et le client, ce qui contribue à améliorer la maintenabilité et l'évolutivité du système.
  3. meilleure superposition

    • Les modèles d'apparence aident à établir une structure hiérarchique claire, définissant l'entrée de chaque niveau.

défaut

  1. Ne respecte pas le principe d'ouverture-fermeture

    • Lors de l'ajout de nouvelles fonctions de sous-système, il peut être nécessaire de modifier la classe d'apparence, ce qui viole le principe ouvert-fermé (ouvert pour les extensions, fermé pour les modifications).
  2. Peut entraîner des problèmes de performances

    • Dans certains cas, l'utilisation du modèle de façade peut entraîner une dégradation des performances du système, car toutes les requêtes doivent passer par la classe de façade.

Diagramme de classes

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

Résumer

Le modèle Facade facilite le travail avec des sous-systèmes complexes en fournissant une interface simplifiée. Il convient aux scénarios dans lesquels il est nécessaire de simplifier l'interface du sous-système, de réduire l'interaction directe entre le client et le sous-système et de découpler la hiérarchie du système. Bien qu’il puisse potentiellement violer le principe ouvert-fermé, dans la plupart des cas, ses avantages dépassent de loin ses inconvénients, rendant la conception du système plus claire et plus facile à maintenir.