antecedentes

Existen estos escenarios en la vida real Hay muchos elementos diferentes en un objeto de colección y hay muchos visitantes y métodos de acceso diferentes para cada elemento. Por ejemplo, hay muchos productos básicos diferentes en un supermercado y hay muchos clientes comprando ropa. Diferentes clientes tienen diferentes evaluaciones de diferentes productos.

Cuando nos encontramos con una estructura de datos con elementos de datos relativamente estables que se procesan y una variedad de métodos de acceso, podemos utilizar el modelo de visitante. A través del modelo de visitante, podemos separar el método de acceso de la estructura de datos, de modo que podamos extender el nuevo método de acceso y lograr una expansión flexible sin modificar el código del programa original.

¿Cuál es el patrón de visitantes?

El texto anterior puede estar en la nube. Ahora solo necesita saber que la función de usar el patrón de visitante es separar los elementos en la estructura de datos de los métodos de operación.

"
Representar una operación a realizar sobre los elementos de una estructura de objeto. Visitor le permite definir una nueva operación sin cambiar las clases de los elementos sobre los que opera. Es posible definir nuevas operaciones que actúan sobre estos elementos sin cambiar la estructura de datos .)
"

El patrón de visitantes se compone principalmente de los siguientes 5 elementos:

"

Rol de visitante abstracto (Visitante): define una interfaz para acceder a elementos específicos, para cada clase de elemento específico corresponde a una operación de visita visit (), el tipo de parámetro en esta operación identifica el elemento específico a visitar.

Rol de visitante específico (ConcreteVisitor): implementa cada operación de acceso declarada en el rol de visitante abstracto y determina qué debe hacer el visitante al acceder a un elemento.

Rol de elemento abstracto (Elemento): declara una interfaz que contiene la operación accept () y el objeto de visitante aceptado se utiliza como parámetro del método accept ().

Rol de elemento concreto (ConcreteElement): implementa la operación accept () proporcionada por el rol de elemento abstracto. El cuerpo del método suele ser visit.visit (this). Además, el elemento concreto también puede contener operaciones relacionadas con su propia lógica empresarial.

Rol de estructura de objeto: es un contenedor que contiene roles de elementos, proporcionando un método para que los visitantes recorran todos los elementos del contenedor, generalmente implementado por clases agregadas como List, Set y Map.

"

El diagrama de estructura es el siguiente:

Modo visitante

Código

Elemento

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

ConcretoElemento

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的操作。";
    }
}

Visitante

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

ConcreteVisitor

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());
    }
}

Estructura de objeto

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);
    }
}

Código de prueba

@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);
}

Resultados de la prueba:

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

La cadena de llamadas es la siguiente:

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

Pensando en el patrón de visitantes

Entonces, ¿cuándo usamos el modo de visitante?

Cuando la estructura del objeto es estable, pero el algoritmo de operación cambia a menudo, podemos usar el modo visitante para evitar que el cambio de estos algoritmos de operación afecte la estructura de datos. Separamos el algoritmo de la estructura de datos.

De hecho, cuando usamos iteradores para recorrer los elementos de la colección, además de usar el modo de iterador, también usamos el modo de visitante. La colección en sí no participa en el recorrido, pero se obtiene mediante el método iterador.

"
En este tipo de lugar, debe considerar el uso del patrón de visitante: las reglas comerciales requieren que se atraviesen varios objetos diferentes. Este en sí mismo es también el punto de partida del patrón de visitante. El patrón de iterador solo puede acceder a datos del mismo tipo o la misma interfaz (por supuesto, si usa instanceof, puede acceder a todos los datos, no hay argumento), y el patrón de visitante es el patrón de iterador La expansión de, puede atravesar diferentes objetos, y luego realizar diferentes operaciones, es decir, realizar diferentes operaciones para que se acceda a diferentes objetos.
"

El modo visitante es un modo centralizado y regular, especialmente adecuado para proyectos de reconstrucción a gran escala. En esta etapa, los requisitos son muy claros y los puntos de función del sistema original también son claros. Algunas funciones se pueden clasificar fácilmente a través del modo de visitante., Para lograr la centralización final de la función de objetivo, como un cálculo de informe unificado, visualización de la interfaz de usuario, etc., también podemos mezclar con otros modos para construir nuestro propio conjunto de filtros o interceptores.

El patrón de visitante del patrón de diseño 19