Contexte

Il existe de tels scénarios dans la vie réelle. Il existe de nombreux éléments différents dans un objet de collection, et il existe de nombreux visiteurs et méthodes d'accès différents pour chaque élément. Par exemple, il existe de nombreux produits différents dans un supermarché et de nombreux clients achètent des vêtements. Différents clients ont différentes évaluations de différents produits.

Lorsque nous rencontrons une structure de données avec des éléments de données relativement stables qui sont traités et une variété de méthodes d'accès, nous pouvons utiliser le modèle de visiteur. Grâce au modèle de visiteur, nous pouvons séparer la méthode d'accès de la structure de données, de sorte que nous pouvons étendre la nouvelle méthode d'accès et réaliser une expansion flexible sans modifier le code du programme d'origine.

Quel est le modèle de visiteur

Le texte ci-dessus peut se trouver dans le cloud. Il vous suffit maintenant de savoir que la fonction de l'utilisation du modèle de visiteur est de séparer les éléments de la structure de données des méthodes d'opération.

"
Représenter une opération à effectuer sur les éléments d'une structure d'objet. Visiteur permet de définir une nouvelle opération sans changer les classes des éléments sur lesquels il opère. Il est possible de définir de nouvelles opérations qui agissent sur ces éléments sans modifier la structure des données .)
"

Le modèle de visiteur est principalement composé des 5 éléments suivants:

"

Rôle de visiteur abstrait (Visiteur): définir une interface pour accéder à des éléments spécifiques, pour chaque classe d'élément spécifique correspond à une opération de visite visit (), le type de paramètre dans cette opération identifie l'élément spécifique à visiter.

Rôle de visiteur spécifique (ConcreteVisitor): implémente chaque opération d'accès déclarée dans le rôle de visiteur abstrait, et détermine ce que le visiteur doit faire lors de l'accès à un élément.

Rôle d'élément abstrait (élément): Déclarez une interface qui contient l'opération accept (), et l'objet visiteur accepté est utilisé comme paramètre de la méthode accept ().

Rôle d'élément concret (ConcreteElement): implémente l'opération accept () fournie par le rôle d'élément abstrait. Le corps de la méthode est généralement visiteur.visit (this). De plus, l'élément concret peut également contenir des opérations liées à sa propre logique métier.

Rôle de structure d'objet: est un conteneur qui contient des rôles d'élément, fournissant une méthode permettant aux visiteurs de parcourir tous les éléments du conteneur, généralement implémenté par des classes d'agrégation telles que List, Set et Map.

"

Le diagramme de structure est le suivant:

Mode visiteur

Code

Élément

public interface Element {
    void accept(Visitor visitor);
}

BétonÉlément

public class ConcreteElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public String operationA() {
        return "具体元素A的操作。";
    }
}

public class ConcreteElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public String operationB() {
        return "具体元素B的操作。";
    }
}

Visiteur

public interface Visitor {
    void visit(ConcreteElementA element);
    void visit(ConcreteElementB element);
}

BétonVisiteur

public class ConcreteVisitorA implements Visitor {
    @Override
    public void visit(ConcreteElementA element) {
        System.out.println("具体访问者A访问-->" + element.operationA());
    }

    @Override
    public void visit(ConcreteElementB element) {
        System.out.println("具体访问者A访问-->" + element.operationB());
    }
}

public class ConcreteVisitorB implements Visitor {
    @Override
    public void visit(ConcreteElementA element) {
        System.out.println("具体访问者B访问-->" + element.operationA());
    }

    @Override
    public void visit(ConcreteElementB element) {
        System.out.println("具体访问者B访问-->" + element.operationB());
    }
}

ObjectStructure

public class ObjectStructure {
    private List<Element> list = new ArrayList<>();

    public void accept(Visitor visitor) {
        Iterator<Element> i = list.iterator();
        while (i.hasNext()) {
            i.next().accept(visitor);
        }
    }

    public void add(Element element) {
        list.add(element);
    }

    public void remove(Element element) {
        list.remove(element);
    }
}

Code de test

@Test
public void test() {
    ObjectStructure os=new ObjectStructure();
    os.add(new ConcreteElementA());
    os.add(new ConcreteElementB());
    Visitor visitor=new ConcreteVisitorA();
    os.accept(visitor);
    System.out.println("------------------------");
    visitor=new ConcreteVisitorB();
    os.accept(visitor);
}

Résultats de test:

具体访问者A访问-->具体元素A的操作。
具体访问者A访问-->具体元素B的操作。
------------------------
具体访问者B访问-->具体元素A的操作。
具体访问者B访问-->具体元素B的操作。

La chaîne d'appels est la suivante:

//举例A:
ObjectStructure#accept() -> ConcreteElementA#accept() -> ConcreteVisitorA#visit()

Penser au modèle de visiteur

Alors, quand utilisons-nous le mode visiteur?

Lorsque la structure de l'objet est stable, mais que l'algorithme d'opération change souvent, nous pouvons utiliser le mode visiteur pour éviter que le changement de ces algorithmes d'opération n'affecte la structure des données.Nous séparons l'algorithme de la structure des données.

En fait, lorsque nous utilisons des itérateurs pour parcourir les éléments de la collection, en plus d'utiliser le mode itérateur, nous utilisons également le mode visiteur. La collection elle-même ne participe pas au parcours, mais est obtenue via la méthode iterator.

"
Dans ce type d'endroit, vous devez envisager d'utiliser le modèle de visiteur: les règles métier exigent que plusieurs objets différents soient traversés. C'est aussi le point de départ du modèle de visiteur. Le modèle d'itérateur ne peut accéder qu'aux données du même type ou de la même interface (bien sûr, si vous utilisez instanceof, vous pouvez accéder à toutes les données, il n'y a pas d'argument), et le modèle de visiteur est le modèle d'itérateur L'expansion de, vous pouvez parcourir différents objets, puis effectuer différentes opérations, c'est-à-dire effectuer différentes opérations pour différents objets auxquels accéder.
"

Le mode visiteur est un mode centralisé et régulier, particulièrement adapté aux projets de reconstruction à grande échelle. À ce stade, les exigences sont très claires et les points de fonction du système d'origine sont également clairs. Certaines fonctions peuvent être facilement triées via le mode visiteur., Pour atteindre la centralisation ultime de la fonction objectif, comme un calcul de rapport unifié, l'affichage de l'interface utilisateur, etc., nous pouvons également mélanger avec d'autres modes pour créer notre propre ensemble de filtres ou d'intercepteurs.

Recommandé dans le passé

Scannez le code QR pour devenir plus excitant. Ou recherchez Lvshen_9 sur WeChat , vous pouvez répondre pour obtenir des informations en arrière-plan

回复"java" 获取java电子书；

回复"python"获取python电子书；

回复"算法"获取算法电子书；

回复"大数据"获取大数据电子书；

回复"spring"获取SpringBoot的学习视频。

回复"面试"获取一线大厂面试资料

回复"进阶之路"获取Java进阶之路的思维导图

回复"手册"获取阿里巴巴Java开发手册(嵩山终极版)

回复"总结"获取Java后端面试经验总结PDF版

回复"Redis"获取Redis命令手册，和Redis专项面试习题（PDF）

回复"并发导图"获取Java并发编程思维导图（xmind终极版）

Un autre: cliquez sur [ Mes avantages ] pour avoir plus de surprises.

Le modèle de visiteur du modèle de conception 19