[Design Pattern Series 22] Exemple de modèle de commande et analyse de principe

Présentation de la série de modèles de conception

Modèles de conception	Billet d'avion
Trois modèles d'usine	Entrée d'embarquement
Mode stratégie	Entrée d'embarquement
Mode de délégation	Entrée d'embarquement
Modèle de méthode de modèle	Entrée d'embarquement
Mode observateur	Entrée d'embarquement
Mode singleton	Entrée d'embarquement
Mode prototype	Entrée d'embarquement
Modèle d'agence	Entrée d'embarquement
Mode décorateur	Entrée d'embarquement
Mode adaptateur	Entrée d'embarquement
Mode constructeur	Entrée d'embarquement
Modèle de chaîne de responsabilité	Entrée d'embarquement
Modèle poids mouche	Entrée d'embarquement
Mode combiné	Entrée d'embarquement
Motif de façade	Entrée d'embarquement
Mode pont	Entrée d'embarquement
Modèle intermédiaire	Entrée d'embarquement
Mode itérateur	Entrée d'embarquement
Mode état	Entrée d'embarquement
Mode interprète	Entrée d'embarquement
Mode mémo	Entrée d'embarquement
Mode de commande	Entrée d'embarquement
Mode visiteur	Entrée d'embarquement
Résumé de 7 principes et modèles de conception de la conception de logiciels	Entrée d'embarquement

Préface

Cet article présentera principalement le mode commande et son principe en mode conception, et l'analysera avec des exemples.

Qu'est-ce que le mode commande

Le modèle de commande (modèle de commande) est une encapsulation de commandes, chaque commande est une opération. Tout d'abord, la partie requérante envoie une demande pour effectuer une opération, puis la partie réceptrice reçoit la demande et exécute l'opération.

Le mode de commande sépare le demandeur et le récepteur. Le demandeur n'a qu'à envoyer la commande sans se soucier de la façon dont la commande est reçue, comment la commande est exécutée et si la commande est exécutée ou non.

Le mode commande est un mode comportemental.

Pourquoi avez-vous besoin du mode commande

Dans notre système de développement logiciel, le demandeur de comportement et l'exécuteur réel sont généralement une relation étroitement couplée, mais dans ce cas, lorsque nous devons modifier le comportement, comme l'annulation ou le rétablissement, nous ne pouvons que modifier la demande. Le mode commande découplera le demandeur et l'exécuteur en introduisant une interface abstraite entre le demandeur de comportement et l'exécuteur, de sorte que si vous avez besoin de modifier le comportement, il vous suffit d'ajouter la commande de comportement correspondante. Il n'est pas du tout nécessaire de modifier le code source du demandeur.

D'accord, le moment est venu de faire semblant: parler n'est pas cher, montrez-vous le code , regardons d'abord un exemple très simple.

Exemple de mode de commande

Prenons comme exemple l'exécution des commandes du système d'exploitation Linux dans XShell pour écrire un exemple:

1. Créez d'abord une classe de commande d'exécution réelle:

package com.zwx.design.pattern.command;

public class LinuxSystem {
    
    
    public void cd(){
    
    
        System.out.println("已经切换到主目录");
    }

    public void ls(){
    
    
        System.out.println("已经列举出当前目录下所有文件");
    }

    public void restart(){
    
    
        System.out.println("开始重启系统");
    }
}

2. Créez une interface de commande (orientée vers la programmation abstraite, bien sûr, vous pouvez directement passer à l'étape 3 dans des circonstances appropriées):

package com.zwx.design.pattern.command;

public interface ICommand {
    
    
    void execute();
}

3. Il y a trois commandes dans notre classe LinuxSystem ci-dessus, donc nous créons ensuite une classe pour chaque commande.Ces classes maintiennent un objet LinuxSystem en interne, qui est utilisé pour traiter le véritable exécuteur LinuxSystem de la commande.

classe de commande cd:

package com.zwx.design.pattern.command;

public class CdCommand implements ICommand {
    
    
    private LinuxSystem linuxSystem;

    public CdCommand(LinuxSystem linuxSystem) {
    
    
        this.linuxSystem = linuxSystem;
    }

    @Override
    public void execute() {
    
    
        linuxSystem.cd();
    }
}

Classe de commande ls:

package com.zwx.design.pattern.command;

public class LsCommand implements ICommand {
    
    
    private LinuxSystem linuxSystem;

    public LsCommand(LinuxSystem linuxSystem) {
    
    
        this.linuxSystem = linuxSystem;
    }

    @Override
    public void execute() {
    
    
        linuxSystem.ls();
    }
}

Redémarrez la classe de commande:

package com.zwx.design.pattern.command;

public class RestartCommand implements ICommand {
    
    
    private LinuxSystem linuxSystem;

    public RestartCommand(LinuxSystem linuxSystem) {
    
    
        this.linuxSystem = linuxSystem;
    }

    @Override
    public void execute() {
    
    
        this.linuxSystem.restart();
    }
}

4. Ensuite, nous avons également besoin d'une classe pour recevoir des commandes:

package com.zwx.design.pattern.command;

import org.omg.PortableServer.LIFESPAN_POLICY_ID;

import java.util.ArrayList;
import java.util.List;

public class XshellInvoker {
    
    
    private List<ICommand> commandList = new ArrayList<>();

    public XshellInvoker(List<ICommand> commandList) {
    
    
        this.commandList = commandList;
    }

    /**
     * 执行指定命令
     * @param command
     */
    public void execute(ICommand command){
    
    
        command.execute();
    }

    /**
     * 执行命令宏
     */
    public void executeCdAndLs(){
    
    
        for (ICommand command : commandList){
    
    
            if (command instanceof LsCommand || command instanceof CdCommand){
    
    
                command.execute();
            }
        }
    }

    public void executeAll(){
    
    
        for (ICommand command : commandList){
    
    
            command.execute();
        }
    }
}

5. Enfin, créons une nouvelle classe de test:

package com.zwx.design.pattern.command;

import java.util.ArrayList;
import java.util.List;

public class TestCommand {
    
    

    public static void main(String[] args) {
    
    
        LinuxSystem linuxSystem = new LinuxSystem();
        List<ICommand> commandList = new ArrayList<>();
        commandList.add(new CdCommand(linuxSystem));
        commandList.add(new LsCommand(linuxSystem));
        commandList.add(new RestartCommand(linuxSystem));

        XshellInvoker xshellInvoker = new XshellInvoker(commandList);

        xshellInvoker.execute(new LsCommand(linuxSystem));//执行指定命令
        System.out.println("------------------------");
        xshellInvoker.executeCdAndLs();//指定特定命令宏
        System.out.println("------------------------");
        xshellInvoker.executeAll();//执行全部命令
    }
}

Les résultats sont les suivants:

已经列举出当前目录下所有文件
------------------------
已经切换到主目录
已经列举出当前目录下所有文件
------------------------
已经切换到主目录
已经列举出当前目录下所有文件
开始重启系统

Comme vous pouvez le voir, comme le contrôleur a été découplé de l'exécuteur de commandes, si vous voulez continuer à étendre de nouvelles commandes plus tard, ajoutez simplement une autre classe de commande.

Rôle du mode de commande

À partir de l'exemple ci-dessus, nous pouvons conclure que le mode itérateur a principalement 4 rôles:

• Rôle de récepteur (Receiver): responsable de l'implémentation ou de l'exécution spécifique d'une requête (comme LinuxSystem dans l'exemple).
• Rôle de commande (commande): définissez toutes les lignes de commande qui doivent être exécutées (comme ICommand dans l'exemple).
• Rôle de commande spécifique (ConcreteCommand): cette classe gère un récepteur (Receiver) en interne. Après avoir reçu la demande de commande d'exécution, la méthode correspondante de Receiver (telle que CdCommand, LsCommand, RestartCommand dans l'exemple) est appelée.
• Le rôle du demandeur (Invoker): Recevoir la commande du client et appeler la commande correspondante (comme dans l'exemple).

Scénarios d'application en mode commande

En fait, l'idée du mode commande est de découpler le demandeur et l'implémenteur de la commande par un intermédiaire. Principalement applicable aux scénarios suivants:

• 1. Il existe des opérations avec des "commandes" dans une sémantique réaliste, telles que les commandes dos et les commandes shell.
• 2. L'appelant de la demande et le récepteur de la demande doivent être découplés afin que l'appelant et le récepteur ne s'appellent pas directement.
• 3. Les comportements en attente d'exécution doivent être abstraits, tels que les opérations d'annulation et de récupération.
• 4. Besoin de prendre en charge l'opération de macro de commande (à savoir la combinaison de commandes).

Avantages et inconvénients du mode commande

avantage:

• 1. Découplez la demande et l'implémentation en introduisant un middleware (interface abstraite).
• 2. Il est pratique de développer, il suffit d'ajouter un objet directement en ajoutant une nouvelle commande.
• 3. Il prend en charge le fonctionnement combiné des commandes, ce qui est plus flexible et pratique.

Désavantage

• 1. S'il y a trop de commandes, il y aura des objets très volumineux.

Pour résumer

Cet article présente principalement l'utilisation de base du mode commande et utilise un exemple simple pour mieux comprendre le mode commande. Enfin, il résume brièvement les avantages et les inconvénients de l'utilisation du mode commande.

S'il vous plaît faites attention à moi et apprenez et progressez avec le loup solitaire .