Patrón de diseño de Java desencadenado por un sistema de monopolio informático: patrón de visitante

definición

El modo visitante es un modo de comportamiento de un objeto. Su propósito es encapsular algunas operaciones impuestas sobre ciertos elementos de la estructura de datos. Una vez que estas operaciones necesitan ser modificadas, la estructura de datos que recibe esta operación puede permanecer sin cambios.

intención

Separar la estructura de datos de la operación de datos

Resolver el problema

Estructura de datos estable y problema de acoplamiento de operación variable

Cuándo usar

Para realizar muchas operaciones diferentes y no relacionadas en los objetos en una estructura de objeto, es necesario evitar que estas operaciones "contaminen" las clases de estos objetos, y usar el patrón de visitante para encapsularlos en las clases.

Pros y contras

ventaja:

• Facilita la adición de nuevas operaciones
• Concentre los comportamientos relacionados en un objeto de visitante en lugar de dispersarlos en clases de nodos individuales
• Puede acceder a las clases de miembros que pertenecen a diferentes estructuras jerárquicas en la estructura jerárquica de varias clases.

Desventajas:

• Se vuelve difícil agregar nuevas clases de nodos
• Destruye el paquete

estructura

Roles involucrados:

• Rol de visitante abstracto (visitante): declara una o más operaciones de acceso para formar una interfaz que todos los roles de elementos específicos deben implementar
• Rol de visitante concreto (ConcreteVisitor): implementa la interfaz declarada por el rol de visitante abstracto, es decir, las diversas operaciones de acceso declaradas por el visitante abstracto
• Rol de nodo abstracto (nodo): declara una operación de recepción, recibiendo un objeto visitante como parámetro
• Rol de nodo específico (nodo): implementa la operación de recepción especificada por el nodo abstracto
• Rol de objeto de estructura (ObjectStructure): tiene las siguientes responsabilidades, puede atravesar todos los elementos de la estructura, si es necesario, proporcionar una interfaz de alto nivel para que el objeto visitante pueda acceder a cada elemento, si es necesario, puede diseñar un objeto compuesto o agregado , Como lista o conjunto

El código fuente es el siguiente: El
rol de visitante abstracto proporciona una operación de acceso para cada nodo y recibe el objeto de nodo correspondiente como parámetro:

public interface Visitor {
    
    

    /** 对应于NodeA的访问操作 */
    void visit(NodeA nodeA);

    /** 对应于NodeB的访问操作 */
    void visit(NodeB nodeB);
}

Los siguientes son los roles específicos de los visitantes:

public class VisitorA implements Visitor {
    
    

    /** 对应于NodeA的访问操作 */
    @Override
    public void visit(NodeA nodeA) {
    
    
        System.out.println(nodeA.operationA());
    }

    /** 对应于NodeB的访问操作 */
    @Override
    public void visit(NodeB nodeB) {
    
    
        System.out.println(nodeB.operationB());
    }
}

public class VisitorB implements Visitor {
    
    

    /** 对应于NodeA的访问操作 */
    @Override
    public void visit(NodeA nodeA) {
    
    
        System.out.println(nodeA.operationA());
    }

    /** 对应于NodeB的访问操作 */
    @Override
    public void visit(NodeB nodeB) {
    
    
        System.out.println(nodeB.operationB());
    }
}

El nodo abstracto declara una operación de recepción:

public abstract class Node {
    
    

    /** 接收操作 */
    public abstract void accept(Visitor visitor);
}

Nodos específicos:

public class NodeA extends Node {
    
    

    /** 接收操作 */
    @Override
    public void accept(Visitor visitor) {
    
    
        visitor.visit(this);
    }

    /** NodeA特有的商业方法 */
    public String operationA() {
    
    
        return "NodeA被访问了";
    }
}

    /** 接收操作 */
    @Override
    public void accept(Visitor visitor) {
    
    
        visitor.visit(this);
    }

    /** NodeB特有的商业方法 */
    public String operationB() {
    
    
        return "NodeB被访问了";
    }
}

La función del objeto de estructura contiene una agregación y proporciona un método de adición al mundo exterior como una operación de gestión de la agregación. Al llamar a este método, se puede agregar dinámicamente un nuevo nodo:

public class ObjectStructure {
    
    

    private List<Node> nodes;

    private Node node;


    public ObjectStructure() {
    
    
        nodes = new ArrayList<>();
    }

    /** 执行访问操作 */
    public void action(Visitor visitor) {
    
    
        for (Node n : nodes) {
    
    
            n.accept(visitor);
        }
    }

    public void add(Node node) {
    
    
        nodes.add(node);
    }
}

Cliente:

public class Client {
    
    

    private static ObjectStructure structure;

    private static Visitor visitor;

    public static void main(String[] args) {
    
    
        //创建一个结构对象
        structure = new ObjectStructure();
        //给结构增加一个节点
        structure.add(new NodeA());
        //给结构增加一个节点
        structure.add(new NodeB());
        //创建一个新的访问者
        visitor = new VisitorA();
        //让访问者访问结构
        structure.action(visitor);
    }
}

Sistema de monopolio informático

Esta tienda de informática puede vender computadoras ensambladas, partes de computadoras, como CPU, placas base, chasis, etc., o productos semiacabados, como placas base integradas.Cada pieza tiene su propio precio.

Lo siguiente primero define un rol de visitante abstracto y declara todos los métodos de acceso:

public interface Visitor {
    
    

    /** 主板访问操作 */
    void visitMainBoard(MainBoard mainBoard);

    /** 硬盘访问操作 */
    void visitHardDisk(HardDisk disk);

    /** cpu访问操作 */
    void visitCpu(Cpu cpu);

    /** 机箱访问操作 */
    void visitCase(Case ce);

    /** 集成主板访问操作 */
    void visitIntegratedBoard(IntegratedBoard board);

    /** 组装电脑访问操作 */
    void visitPc(Pc pc);
}

El rol de visitante específico se utiliza para calcular el precio de cada parte sumada:

public class PriceVisitor implements Visitor {
    
    

    private double total;

    public PriceVisitor() {
    
    
        total = 0.0;
    }

    /** 商业方法 */
    public double value() {
    
    
        return total;
    }

    @Override
    public void visitMainBoard(MainBoard mainBoard) {
    
    
        total += mainBoard.price();
    }

    @Override
    public void visitHardDisk(HardDisk disk) {
    
    
        total += disk.price();
    }

    @Override
    public void visitCpu(Cpu cpu) {
    
    
        total += cpu.price();
    }

    @Override
    public void visitCase(Case ce) {
    
    
        total += ce.price();
    }

    @Override
    public void visitIntegratedBoard(IntegratedBoard board) {
    
    
        total += board.price();
    }

    @Override
    public void visitPc(Pc pc) {
    
    
        total += pc.price();
    }
}

Los siguientes son los roles de visitante específicos que se utilizan para administrar cada parte:

public class InventoryVisitor implements Visitor {
    
    

    private Vector vector;

    public InventoryVisitor() {
    
    
        vector = new Vector();
    }

    /** 商业方法 */
    public int size() {
    
    
        return vector.size();
    }

    @Override
    public void visitMainBoard(MainBoard mainBoard) {
    
    
        vector.add(mainBoard);
    }

    @Override
    public void visitHardDisk(HardDisk disk) {
    
    
        vector.add(disk);
    }

    @Override
    public void visitCpu(Cpu cpu) {
    
    
        vector.add(cpu);
    }

    @Override
    public void visitCase(Case ce) {
    
    
        vector.add(ce);
    }

    @Override
    public void visitIntegratedBoard(IntegratedBoard board) {
    
    
        vector.add(board);
    }

    @Override
    public void visitPc(Pc pc) {
    
    
        vector.add(pc);
    }
}

Rol de nodo abstracto, declare un método de recepción:

public abstract class Equipment {
    
    

    /** 接收方法 */
    public abstract void accept(Visitor visitor);

    /** 价格 */
    public abstract double price();
}

Rol de nodo específico:

public class MainBoard extends Equipment {
    
    
    @Override
    public void accept(Visitor visitor) {
    
    
        System.out.println("主板被访问了");
        visitor.visitMainBoard(this);
    }

    @Override
    public double price() {
    
    
        return 100.0;
    }
}

public class HardDisk extends Equipment {
    
    
    @Override
    public void accept(Visitor visitor) {
    
    
        System.out.println("硬盘被访问了");
        visitor.visitHardDisk(this);
    }

    @Override
    public double price() {
    
    
        return 200.0;
    }
}

public class Cpu extends Equipment {
    
    
    @Override
    public void accept(Visitor visitor) {
    
    
        System.out.println("CPU被访问了");
        visitor.visitCpu(this);
    }

    @Override
    public double price() {
    
    
        return 800.0;
    }
}

public class Case extends Equipment {
    
    
    @Override
    public void accept(Visitor visitor) {
    
    
        System.out.println("机箱被访问了");
        visitor.visitCase(this);
    }

    @Override
    public double price() {
    
    
        return 30.0;
    }
}

El siguiente es un nodo compuesto:

public class Composite extends Equipment {
    
    

    private Vector vector = new Vector();

    @Override
    public void accept(Visitor visitor) {
    
    
        for (int i = 0; i < vector.size(); i++) {
    
    
            ((Equipment)vector.get(i)).accept(visitor);
        }
    }

    @Override
    public double price() {
    
    
        double total = 0;
        for (int i=0; i<vector.size(); i++) {
    
    
            total += ((Equipment)vector.get(i)).price();
        }
        return total;
    }

    public void add(Equipment equipment) {
    
    
        vector.add(equipment);
    }
}

public class IntegratedBoard extends Composite {
    
    

    public IntegratedBoard() {
    
    
        super.add(new MainBoard());
        super.add(new Cpu());
    }

    @Override
    public void accept(Visitor visitor) {
    
    
        System.out.println("集成主板被访问了");
        super.accept(visitor);
    }
}

public class Pc extends Composite {
    
    

    public Pc() {
    
    
        super.add(new IntegratedBoard());
        super.add(new HardDisk());
        super.add(new Case());
    }

    @Override
    public void accept(Visitor visitor) {
    
    
        System.out.println("组装电脑被访问了");
        super.accept(visitor);
    }
}

Cliente:

public class Client {
    
    

    private static PriceVisitor priceVisitor;

    private static InventoryVisitor inventoryVisitor;

    private static Equipment equipment;

    public static void main(String[] args) {
    
    
        equipment = new Pc();
        priceVisitor = new PriceVisitor();
        equipment.accept(priceVisitor);
        System.out.println("价格：" + priceVisitor.value());
        inventoryVisitor = new InventoryVisitor();
        equipment.accept(inventoryVisitor);
        System.out.println("零件数：" + inventoryVisitor.size());
    }
}