mode commande

Le modèle de commande est un modèle de conception basé sur les données, qui est un modèle comportemental. La requête est enveloppée dans un objet sous la forme d'une commande et transmise à l'objet appelant. L'objet appelant recherche un objet approprié capable de gérer la commande et transmet la commande à l'objet correspondant, qui exécute la commande.

Introduction

Intention : Encapsule une requête dans un objet, vous permettant de paramétrer le client avec différentes demandes de modification.

Solution principale : Dans les systèmes logiciels, les demandeurs de comportement et les implémenteurs de comportement ont généralement une relation étroitement couplée, mais dans certains cas, comme la nécessité d'enregistrer, de révoquer ou ce genre de relation étroite une conception couplée qui ne peut pas résister aux changements n'est pas adaptée lors du traitement des refontes, des transactions, etc.

Quand utiliser : Dans certaines situations, telles que "enregistrement, annulation/rétablissement, transaction", etc., ce type de couplage étroit qui ne peut pas résister aux changements est inapproprié. Dans ce cas, comment découpler le « demandeur de comportement » du « implémenteur de comportement » ? L'abstraction d'un ensemble de comportements en objets peut permettre d'obtenir un couplage lâche entre eux.

Comment résoudre : Appelez le destinataire via l'appelant pour exécuter la commande, l'ordre est : appelant → récepteur → commande.

Code clé : Définissez trois rôles : 1. reçu est le véritable objet d'exécution de la commande 2. Commande 3. l'invocateur utilise l'entrée de l'objet de commande

Exemple d'application :Il n'y a qu'un seul contrôleur de base d'action ActionServlet dans Struts 1, ce qui est équivalent à Invoker, et la classe de couche modèle aura différentes classes de modèle avec différentes applications, ce qui équivaut à une commande spécifique.

Avantages : 1. Réduit le couplage du système. 2. De nouvelles commandes peuvent être facilement ajoutées au système.

Inconvénients : L'utilisation du mode commande peut entraîner un trop grand nombre de classes de commandes spécifiques pour certains systèmes.

Scénarios d'utilisation : Le mode commande peut être utilisé partout où des commandes sont prises en compte, telles que : 1. Chaque bouton de l'interface graphique est une commande. 2. Simulez CMD.

Remarque : Le système doit prendre en charge l'opération d'annulation (Annuler) et l'opération de récupération (Refaire) de la commande. Vous pouvez également envisager d'utiliser le mode commande. mode.

Implémentation

Nous créons d'abord l'interface Commande sous forme de commande puis créons la classe Stock sous forme de requête. Les classes de commandes d'entité BuyStock et SellStock implémentent l'interface Order et effectueront le traitement réel des commandes. Créez une classe Broker comme objet appelant, qui accepte les commandes et peut passer des commandes. L'objet

Broker utilise le modèle de commande, qui détermine quel objet exécute quelle commande en fonction du type de commande. CommandPatternDemo, notre classe de démonstration utilise la classe Broker pour démontrer le modèle de commande.

Étape 1

Créez une interface de commande.

Commande.java

public interface Order {
   void execute();
}

Étape 2

Créez une classe de requête.

Stock.java

public class Stock {
	
   private String name = "ABC";
   private int quantity = 10;

   public void buy(){
      System.out.println("Stock [ Name: "+name+", 
         Quantity: " + quantity +" ] bought");
   }
   public void sell(){
      System.out.println("Stock [ Name: "+name+", 
         Quantity: " + quantity +" ] sold");
   }
}

Étape 3

Créez une classe d'entité qui implémente l'interface Order.

BuyStock.java

public class BuyStock implements Order {
   private Stock abcStock;

   public BuyStock(Stock abcStock){
      this.abcStock = abcStock;
   }

   public void execute() {
      abcStock.buy();
   }
}

SellStock.java

public class SellStock implements Order {
   private Stock abcStock;

   public SellStock(Stock abcStock){
      this.abcStock = abcStock;
   }

   public void execute() {
      abcStock.sell();
   }
}

Étape 4

Créer une commande appelant classe .

Broker.java

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

   public class Broker {
   private List<Order> orderList = new ArrayList<Order>(); 

   public void takeOrder(Order order){
      orderList.add(order);		
   }

   public void placeOrders(){
      for (Order order : orderList) {
         order.execute();
      }
      orderList.clear();
   }
}

Étape 5

Utilisez la classe Broker pour accepter et exécuter des commandes.

CommandPatternDemo.java

public class CommandPatternDemo {
   public static void main(String[] args) {
      Stock abcStock = new Stock();

      BuyStock buyStockOrder = new BuyStock(abcStock);
      SellStock sellStockOrder = new SellStock(abcStock);

      Broker broker = new Broker();
      broker.takeOrder(buyStockOrder);
      broker.takeOrder(sellStockOrder);

      broker.placeOrders();
   }
}

Étape 6

Vérifiez la sortie.

Stock [ Name: ABC, Quantity: 10 ] bought
Stock [ Name: ABC, Quantity: 10 ] sold