Étapes de mise en œuvre du proxy statique (exemple de proxy statique)

Dans le développement de logiciels, nous rencontrons souvent des situations où nous devons effectuer des opérations supplémentaires sur un objet. Le proxy statique est un modèle de conception couramment utilisé, qui nous permet de créer un objet proxy, d'encapsuler des opérations supplémentaires dans l'objet proxy, de manière à obtenir le contrôle et l'extension de l'objet cible. Dans cet article, nous présenterons les étapes de mise en œuvre des mandataires statiques, ainsi qu'un exemple illustrant ses applications spécifiques.

Qu'est-ce qu'un proxy statique ?

Avant d'aborder les étapes de mise en œuvre d'un proxy statique, il convient de comprendre ce qu'est un proxy statique.

Les proxies statiques signifient que la classe de proxy est déjà déterminée au moment de la compilation, ce qui signifie que lors de l'utilisation de proxies statiques, nous devons écrire la classe de proxy manuellement.

Étapes de mise en œuvre des mandataires statiques

Voici les étapes à suivre pour mettre en place un proxy statique :

1. Définition d'une interface : nous devons tout d'abord définir une interface contenant les méthodes que l'objet cible doit implémenter.
2. Implémentation de l'objet cible : nous devons ensuite implémenter l'objet cible, c'est-à-dire mettre en œuvre l'interface définie à l'étape précédente et compléter la logique d'entreprise de l'objet cible.
3. Écrire une classe proxy : Ensuite, nous devons écrire une classe proxy qui implémente l'interface implémentée par l'objet cible et conserve une référence à l'objet cible dans la classe proxy.
4. Implémentation d'opérations supplémentaires dans les classes proxy : Dans une classe proxy, nous pouvons implémenter certaines opérations supplémentaires, telles que l'exécution de certaines opérations avant ou après l'appel des méthodes de l'objet cible.
5. Création d'un objet proxy : Enfin, nous pouvons créer un objet proxy par l'intermédiaire duquel nous pouvons appeler les méthodes de l'objet cible.

Exemples de mandataires statiques

Pour mieux comprendre les étapes de mise en œuvre des proxys statiques, prenons un exemple simple.

Supposons que nous ayons une interface `Image` qui définit une méthode `display()` :

public interface Image {
    void display() ; }
}

Ensuite, nous avons une classe concrète `RealImage` qui implémente l'interface `Image` :

public class RealImage implements Image {
    public class RealImage implements Image { private String filename ; public RealImage(String filename) {
    public class RealImage implements Image { private String filename ; public RealImage(String filename) {
        public class RealImage implements Image { private String filename ; public RealImage(String filename) { this.
        this.filename = filename ; loadImage() ;
    }
    private void loadImage() {
        System.out.println("Loading image : " + filename) ; }
    }
    public void display() {
        System.out.println("Affichage de l'image : " + nom du fichier) ; } public void display() { System.out.println("Affichage de l'image : " + nom du fichier) ; }
    }
}

Maintenant, nous voulons imprimer un journal avant d'appeler la méthode `display()` de `RealImage`. A ce stade, nous pouvons y parvenir avec un proxy statique :

public class ImageProxy implements Image {
    private RealImage realImage ; public ImageProxy(String filename) {
    public ImageProxy(String filename) {
        this.realImage = new RealImage(filename) ; this.
    }
    public void display() {
        System.out.println("Avant d'afficher l'image : " + realImage.getFilename()) ; realImage.display() ; } public void display(String filename) { this.
        realImage.display() ;
    }
}

Dans le code ci-dessus, `ImageProxy` implémente l'interface `Image` et imprime d'abord le journal dans la méthode `display()` puis appelle la méthode `display()` de `RealImage`.

Nous pouvons maintenant créer des objets proxy à utiliser :

public class Main {
    public static void main(String[] args) {
        Image image = new ImageProxy("example.jpg") ;
        image.display() ;
    }
}

Exécutez le code ci-dessus et le résultat est le suivant :

Avant l'affichage de l'image : exemple.jpg
Chargement de l'image : exemple.jpg
Affichage de l'image : exemple.jpg

Comme vous pouvez le voir, la méthode `display()` de `ImageProxy` est appelée, le journal est d'abord imprimé, puis la méthode `display()` de `RealImage` est appelée, qui implémente l'opération supplémentaire.

résumés

Les mandataires statiques sont un modèle de conception courant qui nous aide à contrôler et à étendre l'objet cible. En définissant une interface, en implémentant l'objet cible, en écrivant une classe proxy et en implémentant des opérations supplémentaires dans la classe proxy, nous pouvons créer un objet proxy qui nous permet d'utiliser l'objet cible comme proxy.

Dans cet article, nous présentons les étapes de mise en œuvre des mandataires statiques et utilisons un exemple pour illustrer leur application spécifique. Nous espérons que cet article vous aidera à comprendre les mandataires statiques.