La leyenda del emperador de jade del rey mono que va al cielo, el patrón de diseño de Java para hacer un hostigamiento en el templo: modo de comando

Ejemplo

El sistema necesita diseñar una interfaz de línea de comandos. El usuario puede ingresar comandos para ejecutar una determinada función. Las funciones del sistema continuarán aumentando y los comandos continuarán aumentando.
¿Cómo agregar cada función a esta interfaz de línea de comandos?
Después de escribir el programa de línea de comandos, ¿cómo puedo agregar comandos y funciones de manera flexible sin modificaciones debido a la adición de funciones?
Aquí hay un ejemplo de té con leche que se vende en una tienda de té con leche:

public class MashedTaroMilk {
    
    

    public void build() {
    
    
        System.out.println("奶茶师傅制作芋泥啵啵奶茶。。。");
    }
}

public class StrawBerryMilk {
    
    
    public void build() {
    
    
        System.out.println("奶茶师傅制作草莓奶茶。。。");
    }
}

Categoría de camarero: Responsable de recibir clientes y vender té con leche.

public class Waiter {
    
    
    public void receiver(String command) {
    
    
        System.out.println("您选择了：" + command);
        switch (command) {
    
    
            case "芋泥啵啵奶茶" :
                new MashedTaroMilk().build();
                break;
            case "草莓奶茶" :
                new StrawBerryMilk().build();
                break;
            default :
                System.out.println("您点的奶茶本店没有。。。");
                break;
        }
    }

    public void showMenu() {
    
    
        System.out.println("您好，本店有以下奶茶：");
        System.out.println("\t芋泥啵啵奶茶");
        System.out.println("\t草莓奶茶");
    }
}

Categoría de prueba:

public class Client {
    
    

    public static void main(String[] args) {
    
    
        waiter();
    }

    public static  void waiter() {
    
    
        Waiter waiter = new Waiter();
        waiter.showMenu();
        Scanner scanner = new Scanner(System.in);
        System.out.println("请选择：");
        String chooseMilk = scanner.nextLine();
        waiter.receiver(chooseMilk);
        scanner.close();
    }
}

Ahora, si se aumenta el té con leche, debe modificar la declaración de cambio en la clase de camarero, pero no desea modificarla. ¿Qué debo hacer?

Mejora el código

Defina una interfaz para hacer té con leche, y todos los tés con leche la implementarán:

public interface Command {
    
    
    /** 制作奶茶接口 */
    void build();
}

Clase de implementación:

public class AppleMilk implements Command {
    
    
    @Override
    public void build() {
    
    
        System.out.println("开始制作苹果奶茶。。。");
    }
}

public class PlainMilk implements Command {
    
    
    @Override
    public void build() {
    
    
        System.out.println("开始制作原味奶茶。。。");
    }
}

Ahora se contrata a otra camarera para recibir:

public class Waitress {
    
    

    private Map<String, Command> map = new HashMap<>();

    public void addMilk(String name, Command command) {
    
    
        map.put(name, command);
    }

    public void receiver(String command) {
    
    
        System.out.println("您选择了：" + command);
        Command command1 = map.get(command);
        if (command1 != null) {
    
    
            command1.build();
        } else {
    
    
            System.out.println("您点的奶茶本店没有。。。");
        }
    }

    public void showMenu() {
    
    
        System.out.println("您好，本店有以下奶茶：");
        map.keySet().forEach((item)->{
    
    
            System.out.println("\t" + item);
        });
    }
}

Categoría de prueba:

public class Client {
    
    

    public static void main(String[] args) {
    
    
        waitress();
    }

    public static void waitress() {
    
    
        Waitress waitress = new Waitress();
        waitress.addMilk("苹果奶茶", new AppleMilk());
        waitress.addMilk("原味奶茶", new PlainMilk());
        waitress.showMenu();
        Scanner scanner = new Scanner(System.in);
        System.out.println("请选择：");
        String chooseMilk = scanner.nextLine();
        waitress.receiver(chooseMilk);
        scanner.close();
    }
}

Después de las mejoras anteriores, cada vez que se agrega un nuevo té con leche, solo es necesario implementar la interfaz.

Modo de comando

definición

Para desacoplar al llamador y al implementador específico de la función, se reduce el grado de acoplamiento del sistema y se mejora la flexibilidad.

intención

Encapsular una solicitud en un objeto para que pueda parametrizar clientes con diferentes solicitudes

Principalmente resuelve el problema

En un sistema de software, el solicitante del comportamiento y el implementador del comportamiento suelen estar en una relación estrechamente acoplada. Sin embargo, en ciertas situaciones, como cuando los comportamientos deben registrarse, cancelarse o rehacerse, y las transacciones se procesan, este tipo de rigidez no puede resistir cambios. El diseño acoplado no es adecuado

Cuándo usar

En algunas situaciones, como "registrar, deshacer / rehacer, transacción" y otros procesos de comportamiento, este tipo de acoplamiento estrecho que no puede resistir los cambios es inapropiado. En este caso, ¿cómo desacoplar el "solicitante de comportamiento" del "implementador de comportamiento"? La abstracción de un conjunto de comportamientos como objetos puede lograr un acoplamiento flexible entre los dos

Pros y contras

ventaja:

1. Reducir el grado de acoplamiento del sistema.
2. Mayor flexibilidad

Desventajas: el
uso del modo de comando puede causar demasiadas clases de comando específicas en algunos sistemas

Diagrama de clases:

roles involucrados:

1. Rol de cliente (Client): Cree un objeto de comando concreto (ConcreteCommand) y determine su receptor
2. Función de comando (comando): declara una interfaz abstracta para todas las clases de comando específicas, generalmente implementadas por interfaces o clases abstractas
3. Rol Concrete Command (ConcreteCommand): define un acoplamiento débil entre el receptor y el comportamiento; implementa el método execute (), responsable de invocar las operaciones correspondientes del receptor, el método execute () generalmente se llama método de ejecución
4. Rol de invocador: responsable de llamar al objeto de comando para ejecutar la solicitud, el método relacionado se llama método de acción
5. Función de receptor (Receptor): responsable de la implementación y ejecución específicas de una solicitud, cualquier clase puede convertirse en receptora, el método de implementación y ejecución de la solicitud se denomina método de acción

Las clases correspondientes son las siguientes:
Clase de cliente:

public class Client {
    
    

    public static void main(String[] args) {
    
    
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker(command);
        invoker.action();
    }
}

Interfaz de comando:

public interface Command {
    
    

    /** 执行方法 */
    void execute();
}

Clase de implementación ConcreteComman:

public class ConcreteCommand implements Command {
    
    

    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
    
    
        this.receiver = receiver;
    }

    @Override
    public void execute() {
    
    
        System.out.println("do something......");
        receiver.action();
    }
}

Clase de invocador:

public class Invoker {
    
    

    private Command command;

    public Invoker(Command command) {
    
    
        this.command = command;
    }

    /** 行动方法 */
    public void action() {
    
    
        command.execute();
    }
}

Clase de receptor:

public class Receiver {
    
    

    public Receiver() {
    
    

    }

    /** 行动方法 */
    public void action() {
    
    

    }
}

La leyenda del Emperador de Jade del Rey Mono que va al cielo

Antes de que el Rey Mono hiciera un gran ruido en el Palacio Celestial, el Emperador de Jade ordenó a Taibai Jinxing que llamara al Rey Mono al cielo. Este decreto del Emperador de Jade era una orden, y Taibai Jinxing era responsable de entregar el decreto imperial. El ejecutor fue el Rey Mono.:
Interfaz abstracta, todos los edictos imperiales deben implementarla:

public interface ImperialEdictCommand {
    
    

    /** 抽象圣旨，具体圣旨都必须具备的接口 */
    void command();
}

El orden específico es el edicto imperial específico de llamar al Rey Mono al cielo:

public class SkyReportsConcreteCommand implements ImperialEdictCommand {
    
    

    private MonkeyKingReceiver receiver;

    public SkyReportsConcreteCommand(MonkeyKingReceiver receiver) {
    
    
        this.receiver = receiver;
    }

    @Override
    public void command() {
    
    
        System.out.println("宣美猴王孙悟空上天报道！");
        receiver.action();
    }
}

El Emperador de Jade emitió un decreto:

public class TheJadeEmperorClient {
    
    

    public static void main(String[] args) {
    
    
        System.out.println("玉皇大帝颁布一道圣旨，宣美猴王上天报道！");
        MonkeyKingReceiver receiver = new MonkeyKingReceiver();
        ImperialEdictCommand command = new SkyReportsConcreteCommand(receiver);
        GreatWhitePlanetInvoker invoker = new GreatWhitePlanetInvoker();
        invoker.setCommand(command);
        invoker.action();
    }
}

Taibai Venus se encarga de transmitir la voluntad al Rey Mono:

public class GreatWhitePlanetInvoker {
    
    

    private ImperialEdictCommand command;

    public void setCommand(ImperialEdictCommand command) {
    
    
        this.command = command;
    }

    /** 请求者太白金星调用此方法，要求美猴王上天 */
    public void action() {
    
    
        System.out.println("太白金星传玉帝圣旨！");
        command.command();
    }
}

El ejecutor específico es el Rey Mono:

public class MonkeyKingReceiver {
    
    

    public MonkeyKingReceiver() {
    
    

    }
    public void action() {
    
    
        System.out.println("美猴王孙悟空上天，大闹天宫！");
    }
}

Diagrama de clase:

La diferencia entre el modo de comando y el modo de estrategia

La estructura del modo de comando es la siguiente: la estructura del

modo de estrategia es la siguiente: el

modo de estrategia: se enfoca en la realización de múltiples algoritmos para un comportamiento, algoritmos intercambiables, como los descuentos y los descuentos son algoritmos, puede elegir uno de ellos para comprar, comprar, comprar

Modo de comando: el objetivo es proporcionar métodos de ejecución flexibles para múltiples acciones, como el té con leche anterior. El pedido de cada cliente para comprar té con leche es una acción, y los diferentes métodos de producción de té con leche son diferentes, por lo que debe ser flexible para hacer té de la leche