精华内容
下载资源
问答
  • 命令模式的应用实例

    2019-03-26 23:44:21
    先简单找到一些,不解释很多,做收集用。 1.Spring Colud Hystrix — 服务降级,直接上图: 2.

    先简单找到一些,不解释很多,做收集用。

    1.Spring Colud Hystrix — 服务降级,直接上图:

    2.

    展开全文
  • 设计模式 命令模式 实例 命令设计模式是一种广为人知设计模式,属于行为设计模式(“四人帮”一部分)。 顾名思义,它与应用程序中动作和事件有关。 问题陈述: 假设有一个网页将在其中包含多个菜单情况...

    设计模式 命令模式 实例

    命令设计模式是一种广为人知的设计模式,属于行为设计模式(“四人帮”的一部分)。 顾名思义,它与应用程序中的动作和事件有关。

    问题陈述:

    假设有一个网页将在其中包含多个菜单的情况。 编写此代码的一种方法是使条件成立,并在每次单击菜单时执行操作。

    private void getAction(String action){
    	  if(action.equalsIgnoreCase('New')){
    		  //Create new file
    	  }
    	  else if(action.equalsIgnoreCase('Open')){
    		  //Open existing file
    	  }
    	  if(action.equalsIgnoreCase('Print')){
    		  //Print the file
    	  }
    	  if(action.equalsIgnoreCase('Exit')){
    		  //get out of the application
    	  }
      }

    我们必须根据操作字符串执行操作。 然而,以上代码如果条件太多,则无法扩展。

    意图:

    • 动作的请求者需要与执行该动作的对象分离。
    • 允许将请求封装为对象。 注意这一行,因为这对于命令模式是非常重要的概念。
    • 允许将请求存储在队列中,即允许您存储稍后可以执行的操作列表。


    解:

    要解决上述问题,可以在此处恢复命令模式。 如上所述,命令模式通过封装将上述动作移至对象。 这些对象在执行时将执行命令。 在这里,每个命令都是一个对象。 因此,我们将必须为每个菜单操作(例如NewClassOpenClassPrintClassExitClass)创建单独的类。 所有这些类都继承自父接口(即Command接口)。 此接口(命令接口)抽象/包装所有子动作类。
    现在,我们介​​绍一个Invoker类,其主要工作是将操作与具有该操作的类进行映射。 它基本上保留了该动作,并通过调用execute()方法获得执行请求的命令。
    糟糕! 我们在这里错过了另一个利益相关者。 这是Receiver类。 接收器类具有执行操作的知识。 接收者具有执行动作时该做什么的知识。

    结构体:

    以下是“命令设计”模式的参与者:

    • 命令–这是用于执行操作的接口。
    • ConcreteCommand –此类扩展了Command接口并实现了execute方法。 此类在操作和接收者之间创建绑定。
    • 客户端–此类创建ConcreteCommand类并将其与接收者相关联。
    • 调用程序–此类要求命令执行请求。
    • 接收器–此类知道要执行的操作。


    范例



    脚步:

    1. 使用诸如execute()之类的方法签名定义Command接口。 在上面的示例中, ActionListenerCommand是具有单个execute()方法的命令界面。
    2. 创建一个或多个派生类,这些派生类封装以下内容的一些子集:“接收者”对象,要调用的方法,要传递的参数。 在上面的示例中, ActionOpenActionSave是Concrete命令类,它们在接收方和操作之间创建绑定。 ActionOpen类在execute()内调用接收方(在本例中为Document类)类的action方法。 因此,命令接收器类需要做什么。
    3. 为每个延迟的执行请求实例化Command对象。
    4. 将Command对象从创建者传递到调用者。
    5. 调用者决定何时执行()。
    6. 客户端实例化Receiver对象(Document)和Command对象,并允许调用者调用命令。


    代码示例:

    命令界面:

    public interface ActionListenerCommand {
    	public void execute();
    }

    接收器类别:

    public class Document {
       public void Open(){
    	   System.out.println('Document Opened');
       }
       public void Save(){
    	   System.out.println('Document Saved');
       }
    }

    具体命令:

    public class ActionOpen implements ActionListenerCommand {
    	private Document adoc;
    
    	public ActionOpen(Document doc) {
    		this.adoc = doc;
    	}
    	@Override
    	public void execute() {
    		adoc.Open();
    	}
    }

    祈求者等级:

    public class MenuOptions {
    	private ActionListenerCommand openCommand;
    	private ActionListenerCommand saveCommand;
    
    	public MenuOptions(ActionListenerCommand open, ActionListenerCommand save) {
    		this.openCommand = open;
    		this.saveCommand = save;
    	}
    public void clickOpen(){
    	openCommand.execute();
    }
    public void clickSave(){
    	saveCommand.execute();
    }
    }

    客户类别

    public class Client {
    	public static void main(String[] args) {
    		Document doc = new Document();
    		ActionListenerCommand clickOpen = new ActionOpen(doc);
    		ActionListenerCommand clickSave = new ActionSave(doc);
    		MenuOptions menu = new MenuOptions(clickOpen, clickSave);
    		menu.clickOpen();
    		menu.clickSave();
    	}
    
    }


    优点:

    命令模式有助于解耦调用方和接收方。 接收者是知道如何执行动作的人。
    命令应能够执行撤消和重做操作。
    这种模式在可扩展性方面有所帮助,因为我们可以在不更改现有代码的情况下添加新命令。

    退税:

    命令模式的主要缺点是每个单独命令的类数增加。 这些项目也可以通过方法实现来完成。 但是,命令模式类比使用if else条件创建多个方法更具可读性。

    有趣的一点:

    • java.lang.Runnable和javax.swing.Action的实现遵循命令设计模式。
    • 命令可以使用Memento维护撤消操作所需的状态。


    下载示例代码:

    Download Sample Code

    参考: 通过您的命令从我们JCG伙伴 Mainak哥斯瓦米在Idiotechie博客。

    翻译自: https://www.javacodegeeks.com/2012/11/by-your-command-command-design-pattern.html

    设计模式 命令模式 实例

    展开全文
  • 文章目录2.2 命令模式(1)概念(2)适用场景(3)代码示例(4)该模式在源码中的应用(5)命令模式的优缺点 (1)概念 命令模式(Command Pattern)是一种数据驱动的设计模式,它属于行为型模式。请求以命令的形式...

    2.2 命令模式

    示例代码git地址 : https://gitee.com/zyxscuec/Design-pattern.git

    (1)概念

    命令模式(Command Pattern)是一种数据驱动的设计模式,它属于行为型模式。请求以命令的形式包裹在对象中,并传给调用对象。调用对象寻找可以处理该命令的合适的对象,并把该命令传给相应的对象,该对象执行命令。

    主要解决:在软件系统中,行为请求者与行为实现者通常是一种紧耦合的关系,但某些场合,比如需要对行为进行记录、撤销或重做、事务等处理时,这种无法抵御变化的紧耦合的设计就不太合适。

    (2)适用场景

    认为是命令的地方都可以使用命令模式,比如: 1、GUI 中每一个按钮都是一条命令。 2、模拟 CMD。

    在某些场合,比如要对行为进行"记录、撤销/重做、事务"等处理,这种无法抵御变化的紧耦合是不合适的。在这种情况下,如何将"行为请求者"与"行为实现者"解耦?将一组行为抽象为对象,可以实现二者之间的松耦合。

    注意事项:系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作,也可以考虑使用命令模式,见命令模式的扩展。

    (3)代码示例

    关键代码:定义三个角色:1、received 真正的命令执行对象 2、Command 3、invoker 使用命令对象的入口

    我们首先创建作为命令的接口 Order,然后创建作为请求的 Stock 类。实体命令类 BuyStockSellStock,实现了 Order 接口,将执行实际的命令处理。创建作为调用对象的类 Broker,它接受订单并能下订单。

    Broker 对象使用命令模式,基于命令的类型确定哪个对象执行哪个命令。CommandPatternDemo,我们的演示类使用 Broker 类来演示命令模式。

    创建一个命令接口。

    package com.alibaba.design.commandpattern;
    
    /**
     * @author zhouyanxiang
     * @create 2020-08-2020/8/1-8:57
     */
    public interface Order {
    
        void execute();
    
    }
    

    创建一个请求类。

    package com.alibaba.design.commandpattern;
    
    /**
     * @author zhouyanxiang
     * @create 2020-08-2020/8/1-8:57
     */
    public class Stock {
    
        private String name = "Tom";
    
        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");
        }
    }
    

    创建实现了 Order 接口的实体类。

    • BuyStock
    package com.alibaba.design.commandpattern;
    
    /**
     * @author zhouyanxiang
     * @create 2020-08-2020/8/1-8:59
     */
    public class BuyStock implements Order {
    
        private Stock abcStock;
    
        public BuyStock(Stock abcStock){
            this.abcStock = abcStock;
        }
    
        @Override
        public void execute() {
            abcStock.buy();
        }
    }
    
    • SellStock
    package com.alibaba.design.commandpattern;
    
    /**
     * @author zhouyanxiang
     * @create 2020-08-2020/8/1-9:00
     */
    public class SellStock implements Order {
    
        private Stock abcStock;
    
        public SellStock(Stock abcStock){
            this.abcStock = abcStock;
        }
    
        @Override
        public void execute() {
            abcStock.sell();
        }
    }
    

    创建命令调用类。

    package com.alibaba.design.commandpattern;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author zhouyanxiang
     * @create 2020-08-2020/8/1-9:01
     */
    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();
        }
    
    }
    
    package com.alibaba.design.commandpattern;
    
    /**
     * @author zhouyanxiang
     * @create 2020-08-2020/8/1-9:02
     */
    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();
        }
    
    }
    

    执行程序,输出结果:

    (4)该模式在源码中的应用

    典型的java.lang.Runable和线程池中都有用到命令模式

    来看一下Runable的源码

    Runable:任务抽象,也就是“命令”;线程池通过submit和execute调用

    java.util.concurrent.ThreadPoolExecutor线程池中的源码

        /**
         * Executes the given task sometime in the future.  The task
         * may execute in a new thread or in an existing pooled thread.
         *
         * If the task cannot be submitted for execution, either because this
         * executor has been shutdown or because its capacity has been reached,
         * the task is handled by the current {@code RejectedExecutionHandler}.
         *
         * @param command the task to execute
         * @throws RejectedExecutionException at discretion of
         *         {@code RejectedExecutionHandler}, if the task
         *         cannot be accepted for execution
         * @throws NullPointerException if {@code command} is null
         */
        public void execute(Runnable command) {
            if (command == null)
                throw new NullPointerException();
            /*
             * Proceed in 3 steps:
             *
             * 1. If fewer than corePoolSize threads are running, try to
             * start a new thread with the given command as its first
             * task.  The call to addWorker atomically checks runState and
             * workerCount, and so prevents false alarms that would add
             * threads when it shouldn't, by returning false.
             *
             * 2. If a task can be successfully queued, then we still need
             * to double-check whether we should have added a thread
             * (because existing ones died since last checking) or that
             * the pool shut down since entry into this method. So we
             * recheck state and if necessary roll back the enqueuing if
             * stopped, or start a new thread if there are none.
             *
             * 3. If we cannot queue task, then we try to add a new
             * thread.  If it fails, we know we are shut down or saturated
             * and so reject the task.
             */
            int c = ctl.get();
            if (workerCountOf(c) < corePoolSize) {
                if (addWorker(command, true))
                    return;
                c = ctl.get();
            }
            if (isRunning(c) && workQueue.offer(command)) {
                int recheck = ctl.get();
                if (! isRunning(recheck) && remove(command))
                    reject(command);
                else if (workerCountOf(recheck) == 0)
                    addWorker(null, false);
            }
            else if (!addWorker(command, false))
                reject(command);
        }
    
        /**
         * Initiates an orderly shutdown in which previously submitted
         * tasks are executed, but no new tasks will be accepted.
         * Invocation has no additional effect if already shut down.
         *
         * <p>This method does not wait for previously submitted tasks to
         * complete execution.  Use {@link #awaitTermination awaitTermination}
         * to do that.
         *
         * @throws SecurityException {@inheritDoc}
         */
        public void shutdown() {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                checkShutdownAccess();
                advanceRunState(SHUTDOWN);
                interruptIdleWorkers();
                onShutdown(); // hook for ScheduledThreadPoolExecutor
            } finally {
                mainLock.unlock();
            }
            tryTerminate();
        }
    

    (5)命令模式的优缺点

    • 优点:

      1、降低了系统耦合度。

      2、新的命令可以很容易添加到系统中去。

    • 缺点:

      使用命令模式可能会导致某些系统有过多的具体命令类。

    展开全文
  • 原文链接作者:Pankaj Kumar译者:f0tlo <...命令模式是一种行为模式,因此,它处理是对象行为。命令模式为系统中不同对象提供中性化交流媒介。...在企业级应用中,命令模式是非常有用,它使得多个...

    原文链接  作者:Pankaj Kumar 译者:f0tlo <1357654289@qq.com>

    命令模式是一种行为模式,因此,它处理的是对象的行为。命令模式为系统中不同的对象提供中性化的交流媒介。根据GoF的定义,命令模式是:

    通过封装一组完全不相关的对象相互之间的的交互及通讯来完成松耦合。

    允许某一个对象的行为的变化是独立于其他对象的。

    在企业级应用中,命令模式是非常有用的,它使得多个对象可以相互交流。如果一些对象与另一些对象直接交流,系统组件之间是紧耦合的方式。这种方式导致系统具有更高的可维护性,可扩展的灵活性变得很低。命令模式专注于提供一个调解人介于需要交流的对象之间来帮助完成对象间的松耦合。

    飞机流量控制器就是使用命令模式最好的例子。空管中心就是和这个负责不同飞机之间交流的调解人。调解人犹如一个不同对象之间的路由器,它有自己逻辑来提供对象之间如何交流。

    在本文的例子中,我们试着完成一个聊天程序,允许群聊。用户使用自己的名字来识别,他们可以发送接收消息。任何人发送的消息都能被群组中的其他用户接收到。

    调解人接口

    首先创建调解人接口,用于如何定义具体的调解人。

    package com.journaldev.design.mediator;

    public interface ChatMediator {

    public void sendMessage(String msg, User user);

    void addUser(User user);

    }

    组群用户接口

    用户可以发送接送信息,因此应该有用户接口或者抽象类。此处创建用户抽象类如下:

    package com.journaldev.design.mediator;

    public abstract class User {

    protected ChatMediator mediator;

    protected String name;

    public User(ChatMediator med, String name){

    this.mediator=med;

    this.name=name;

    }

    public abstract void send(String msg);

    public abstract void receive(String msg);

    }

    注意用户有一个对调解人的索引,因为不同的用户需要交流。

    调解人实体类

    现在调解人的实体类,它包含了再组群中的一些类用户并且提供用户之间如何交流的逻辑。

    package com.journaldev.design.mediator;

    import java.util.ArrayList;

    import java.util.List;

    public class ChatMediatorImpl implements ChatMediator {

    private List users;

    public ChatMediatorImpl(){

    this.users=new ArrayList<>();

    }

    @Override

    public void addUser(User user){

    this.users.add(user);

    }

    @Override

    public void sendMessage(String msg, User user) {

    for(User u : this.users){

    //message should not be received by the user sending it

    if(u != user){

    u.receive(msg);

    }

    }

    }

    }

    组群用户的实体类

    现在创建用户的实体类用于客户端中

    package com.journaldev.design.mediator;

    public class UserImpl extends User {

    public UserImpl(ChatMediator med, String name) {

    super(med, name);

    }

    @Override

    public void send(String msg){

    System.out.println(this.name+": Sending Message="+msg);

    mediator.sendMessage(msg, this);

    }

    @Override

    public void receive(String msg) {

    System.out.println(this.name+": Received Message:"+msg);

    }

    }

    注意,send()方法正在调解人中被用于传递信息给其他用户。但是它不知道如何被此调解人使用。

    命令模式客户端

    现在完成一个简单的聊天程序来完成组群聊天。

    package com.journaldev.design.mediator;

    public class ChatClient {

    public static void main(String[] args) {

    ChatMediator mediator = new ChatMediatorImpl();

    User user1 = new UserImpl(mediator, "Pankaj");

    User user2 = new UserImpl(mediator, "Lisa");

    User user3 = new UserImpl(mediator, "Saurabh");

    User user4 = new UserImpl(mediator, "David");

    mediator.addUser(user1);

    mediator.addUser(user2);

    mediator.addUser(user3);

    mediator.addUser(user4);

    user1.send("Hi All");

    }

    }

    注意,此客户端程序非常简单,完全没有给出细节描述信息是如何被处理以及调解人是否将会使用用户对象。

    上述程序的输出如下:

    Pankaj: Sending Message=Hi All

    Lisa: Received Message:Hi All

    Saurabh: Received Message:Hi All

    David: Received Message:Hi All

    命令模式的UML图

    mediator-pattern.png

    JDK中的命令模式

    java.util.Timer类中scheduleXXX()方法

    java.lang.reflect.Method invoke()方法

    特别注意的地方

    命令模式中,当不同的对象的通讯逻辑很复杂是,我们可以使用中心化的交流方式来处理此通讯逻辑。

    Java Message Service(JMS)消息服务与观察者模式一起来完成消息在不同程序间的订阅与发布。

    命令模式仅仅是为了松耦合。如果调解人的数量变大,此时易维护性就变差了。

    d0c1501a6d8bb921cf36400dc89de69f.png

    展开全文
  • 命令模式解决了应用程序中对象职责以及它们之间通信方式 类型:行为型 适用场景: 请求调用者和请求接收者需要解耦,使得调用者和接收者不直接交互 需要抽象出等待执行行为 优点: 降低解耦 容易扩展新...
  • 管道和过滤器 管道和过滤器是八种体系结构模式之一,这八种体系结构模式是:层、管道和过滤器、黑板、代理者、模型-视图-控制器(MVC) 表示-抽象-控制(PAC)、微核、...按照《POSA(面向模式的软件架构)》里的说法...
  • 本系列文章主要介绍日常工作中用得较多设计模式如:**代理模式、装饰模式、适配器模式、桥接模式、模板方法模式、责任链模式、策略模式,命令模式、状态模式、**这九种模式在工作中比较常见。而创建型模式如**原型...
  • 命令模式是一种行为模式,因此,它处理是对象行为。命令模式为系统中不同对象提供中性化...在企业级应用中,命令模式是非常有用,它使得多个对象可以相互交流。如果一些对象与另一些对象直接交流,系统组件...
  • 原文链接作者:Pankaj Kumar译者:f0tlo <...命令模式是一种行为模式,因此,它处理是对象行为。命令模式为系统中不同对象提供中性化交流媒介。...在企业级应用中,命令模式是非常有用,它使得多个...
  • 命令模式概述 、命令模式结构与实现 、命令模式的应用实例 、命令模式的适用场景 、命令模式的优缺点
  • 具体过程如下:首先sed把当前正在处理行保存在一个临时缓存区中(也称为模式空间),然后处理临时缓冲区中行,完成后把该行发送到屏幕上。sed每处理完一行就将其从临时缓冲区删除,然后将下一行读...
  • sed命令详解及应用实例

    千次阅读 2013-10-13 09:08:13
    具体过程如下:首先sed把当前正在处理行保存在一个临时缓存区中(也称为模式空间),然后处理临时缓冲区中行,完成后把该行发送到屏幕上。sed每处理完一行就将其从临时缓冲区删除,然后将下一行读
  • 1.2 日常生活中看命令模式应用实例 1.3 Java代码实现 2、命令模式在源码中的应用 2.1 JDK源码中命令模式体现 2.2 JUnit源码中命令模式体现 3、命令模式优缺点 3.1 优点 3.2 缺点 3.3 使用场景 3.4 注意...
  • 实验上机十一 命令模式 实验上机目的 练习使用行为型设计模式 ...2命令模式的结构与实现 3命令模式的应用实例 4实现命令队列 5记录请求日志 6实现撤销操作 7宏命令 8命令模式的优缺点与适用环境 实验上机内容 为了用
  •  在手机进入工程模式后,modem确实起来后,就可以收发AT命令了。 import serial p = serial.Serial() #创建一个Serial实例 p.port = 10 #手动设置COM口,我这里是COM11 p.baudrate = 115200 #波特率,这个不...
  • 主要介绍了设计模式中备忘录模式解析及相关C++实例应用,备忘录模式也经常被用来在命令模式中维护可以撤销(Undo)操作状态,需要朋友可以参考下
  • 文章目录一、概念二、命令模式的UML类图三、命令模式的应用实例:智能家电项目3.1、项目介绍3.2、项目UML类图3.3、代码3.3.1、 Command(命令):Command3.3.2、Receiver(接收者):LightReceiver3.3.3、...
  • 1.hostname 命令(显示和更改系统主机名)命令格式为: #hostname 主机名 (设置主机名) #hostname (显示主机名) 2.iofconfig命令 (获取和修改网络接口配置信息) #ifconfig (显示当前系统中活动网卡...
  • 命令模式

    2021-04-02 11:38:51
    命令模式一、命令模式二、命令模式实例之1.实例说明2.实例类图3.实例代码参考文献 一、命令模式 命令模式(Template Method Pattern)是一种类行为型模式。 定义:定义一个操作中算法骨架,而将算法一些步骤延迟...
  • 命令模式应用实例 命令模式 命令模式:在软件系统中,“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合,比如要对行为进行“记录、撤销/重做、事务”等处理,这种无法抵御变化紧耦合是不合适...
  • 定义与类型适用场景优点缺点相关模式备忘录模式经常结合使用coding典型应用是GUI中绘图程序, 用命令模式实现“撤销”操作.命令接收者:执行实际任务。命令者:封装所有命令者信息。发起者:空着一个或者多个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,298
精华内容 519
关键字:

命令模式的应用实例