乐趣区

关于设计模式:设计模式学习笔记十七命令模式

1 概述

1.1 引言

日常生活中,能够通过开关管制一些电器的开启和敞开,比方电灯和排气扇。能够将开关了解成一个申请发送者,电灯是申请的最红接收者以及解决者,开关与电灯之间不存在间接的耦合关系,两者通过电线连贯在一起,使不同的电线能够连贯不同的申请接收者,只须要更换一根电线,雷同的发送者(开关)既可对应不同的接收者(电器)。

软件开发中常常须要向某些对象发送申请,然而并不知道具体的接收者是谁,也不晓得被申请的操作是哪个,此时心愿以一种松耦合的形式来设计软件,使得申请发送者与申请接收者之间可能打消彼此之间的耦合,让对象之间的调用关系更加灵便,能够灵便地指定申请接收者以及被申请的操作,此时能够应用命令模式进行设计。

命令模式能够将申请发送者和接收者齐全解耦,发送者与接收者之间没有间接援用关系,发送申请的对象只须要晓得如何发送申请,而不用晓得如何实现申请。

1.2 定义

命令模式:将一个申请封装成一个对象,从而可用不同的申请对客户进行参数化,对申请排队或者记录申请日志,以及反对可撤销的操作。

命令模式是一种对象行为型模式,别名为动作模式或者事务模式。

1.3 结构图

1.4 角色

  • Command(形象命令类):形象命令类个别是一个抽象类或者接口,在其中申明了用于执行申请的 execute() 办法,通过这些办法能够调用申请接收者的相干操作
  • ConcreteCommand(具体命令类):实现了形象命令类中申明的办法,对应具体的接收者对象,将接收者对象的动作绑定其中,在实现 execute() 办法时,将调用接收者对象的相干操作
  • Invoker(调用者):调用者即申请发送者,通过命令对象来执行申请。一个调用者并不需要设计时确定接收者,因而它只与形象命令类之间存在关联关系。程序运行时将具体命令对象注入,并调用其中的 execute() 办法,从而实现间接调用申请接收者的相干操作
  • Receiver(接收者):接收者执行与申请相干的操作,具体实现对申请的业务解决

2 典型实现

2.1 步骤

  • 定义形象命令类:定义执行申请的办法
  • 定义调用者:在调用办法外面蕴含对具体命令的调用,同时须要蕴含一个对形象命令的援用
  • 定义接收者:定义接管申请的业务办法
  • 定义具体命令类:继承 / 实现形象命令类,实现其中执行申请办法,转发到接收者的接管办法

2.2 形象命令类

这里实现为一个接口:

interface Command
{void execute();
}

2.3 调用者

class Invoker
{
    private Command command;

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

    public void call()
    {System.out.println("调用者操作");
        command.execute();}
}

调用者能够通过构造方法或者 setter 注入具体命令,对外提供一个调用办法call,当调用此办法时调用具体命令的execute

2.4 接收者

class Receiver
{public void action()
    {System.out.println("接收者操作");
    }
}

这里的接收者只有一个action,示意接管办法。

2.5 具体命令类

class ConcreteCommand implements Command
{private Receiver receiver = new Receiver();
    @Override
    public void execute()
    {receiver.action();
    }
}

具体命令类中须要蕴含一个对接收者的援用,以便在 execute 中调用接收者。

2.6 客户端

public static void main(String[] args) 
{Invoker invoker = new Invoker(new ConcreteCommand());
    invoker.call();}

通过构造方法注入具体命令到调用者中,接着间接调用即可。

输入如下:

3 实例

自定义功能键的设置,对于一个按钮,能够依据须要由用户设置为最小化 / 最大化 / 敞开性能,应用命令模式进行设计。

设计如下:

  • 形象命令类:Command
  • 调用者:Button
  • 接收者:MinimizeHandler+MaximizeHandler+CloseHandler
  • 具体命令类:MinimizeCommand+MaximizeCommand+CloseCommand

首先设计形象命令类,实现为一个接口,仅蕴含 execute 办法:

interface Command
{void execute();
}

接着是调用者类,蕴含一个形象命令的援用:

class Button
{
    private Command command;
    public Button(Command command)
    {this.command = command;}

    public void onClick()
    {System.out.println("按钮被点击");
        command.execute();}
}

而后是接收者类:

class MinimizeHandler
{public void handle()
    {System.out.println("最小化");
    }
}

class MaximizeHandler
{public void handle()
    {System.out.println("最大化");
    }
}

class CloseHandler
{public void handle()
    {System.out.println("敞开");
    }
}

最初是具体命令类,对应蕴含一个接收者成员即可,实现其中的 execute 并转发到接收者的办法:

class MinimizeCommand implements Command
{private MinimizeHandler handler = new MinimizeHandler();
    @Override
    public void execute()
    {handler.handle();
    }
}

class MaximizeCommand implements Command
{private MaximizeHandler handler = new MaximizeHandler();
    @Override
    public void execute()
    {handler.handle();
    }
}

class CloseCommand implements Command
{private CloseHandler handler = new CloseHandler();
    @Override
    public void execute()
    {handler.handle();
    }
}

测试类:

public static void main(String[] args) 
{Button button = new Button(new MinimizeCommand());
    button.onClick();

    button = new Button(new MaximizeCommand());
    button.onClick();

    button = new Button(new CloseCommand());
    button.onClick();}

输入:

如果须要新增一个命令,只须要命令接收者以及实现了 Command 的具体命令类,客户端再将具体命令注入申请发送者(Button),毋庸间接操作申请接收者。

4 命令队列

有时候须要将多个申请排队,当一个申请发送者发送实现一个申请后,不止一个申请接收者产生响应,这些申请接收者将一一执行业务办法实现对申请的解决。这种模式能够通过命令队列实现,实现命令队列很简略,个别是减少一个叫 CommandQueue 的类,由该类负责存储多个命令对象,不同的命令对象能够对应不同的申请接收者,比方在下面的例子中减少 CommandQueue 命令队列类:

class CommandQueue
{private ArrayList<Command> commands = new ArrayList<>();
    public void add(Command command)
    {commands.add(command);
    }

    public void remove(Command command)
    {commands.remove(command);
    }

    public void execute()
    {System.out.println("批量执行命令");
        commands.forEach(Command::execute);
    }
}

接着批改调用者类 Button(只需将原来的Command 改为CommandQueue):

class Button
{
    private CommandQueue queue;
    public Button(CommandQueue queue)
    {this.queue = queue;}

    public void onClick()
    {System.out.println("按钮被点击");
        queue.execute();}
}

最初是客户端定义命令队列并作为参数传入调用者的构造方法或者 setter 中,最初由调用者执行办法:

public static void main(String[] args) 
{CommandQueue queue = new CommandQueue();
    queue.add(new MinimizeCommand());
    queue.add(new MaximizeCommand());
    queue.add(new CloseCommand());
    Button button = new Button(queue);
    button.onClick();}

输入如下:

5 撤销与重做

设计一个繁难计算器,实现加法性能,还可能实现撤销以及重做性能,应用命令模式实现。

设计如下:

  • 形象命令类:Command
  • 调用者:Calculator
  • 接收者:Adder
  • 具体命令类:AddCommand

首先先不实现撤销以及重做性能:

public class Test
{public static void main(String[] args) 
    {Calculator calculator = new Calculator(new AddCommand());
        calculator.add(3);
        calculator.add(9);
    }
}

interface Command
{int execute(int value);
}

class Calculator
{
    private Command command;
    public Calculator(Command command)
    {this.command = command;}

    public void add(int value)
    {System.out.println(command.execute(value));
    }
}

class Adder
{
    private int num = 0;
    public int add(int value)
    {return num += value;}
}

class AddCommand implements Command
{private Adder adder = new Adder();
    @Override
    public int execute(int value)
    {return adder.add(value);
    }
}

代码与下面的实例相似,就不解释了。

这里要害的问题是如何实现撤销以及重做性能,撤销可能复原到进行加法之前的状态,而重做能复原到进行了加法之后的状态,而且这是有固定程序的,因而能够联想到数组,应用下标示意以后状态,下标左移示意撤销,下标右移示意重做:

应用一个状态数组存储每次进行加法的状态,用下标示意以后状态,当撤销时,使下标左移,当重做时,使下标右移。

首先须要批改形象命令类,增加撤销以及重做办法:

interface Command
{int execute(int value);
    int undo();
    int redo();}

接着批改调用者类,增加撤销以及重做办法:

class Calculator
{
    private Command command;
    public Calculator(Command command)
    {this.command = command;}

    public void add(int value)
    {System.out.println(command.execute(value));
    }

    public void undo()
    {System.out.println(command.undo());
    }

    public void redo()
    {System.out.println(command.redo());
    }
}

外围的实现位于接收者类 Adder,应用了List<Integer> 存储了状态,index示意下标,在撤销或重做之前首先判断下标地位是否非法,非法则进行下一步操作:

class Adder
{private List<Integer> nums = new ArrayList<>();
    private int index = 0;
    public Adder()
    {nums.add(0);
    }

    public int add(int value)
    {int result = nums.get(index)+value;
        nums.add(result);
        ++index;
        return result;
    }

    public int redo()
    {if(index + 1 < nums.size())
            return nums.get(++index);
        return nums.get(index);
    }

    public int undo()
    {if(index - 1 >= 0)
            return nums.get(--index);
        return nums.get(index);
    }
}

最初具体命令类简略增加撤销以及重做办法即可:

class AddCommand implements Command
{private Adder adder = new Adder();
    @Override
    public int execute(int value)
    {return adder.add(value);
    }

    @Override
    public int undo()
    {return adder.undo();
    }

    @Override
    public int redo()
    {return adder.redo();
    }
}

测试:

public static void main(String[] args) 
{Calculator calculator = new Calculator(new AddCommand());
    calculator.add(3);
    calculator.add(9);
    
    calculator.undo();
    calculator.undo();
    calculator.undo();
    calculator.undo();
    
    calculator.redo();
    calculator.redo();
    calculator.redo();
    calculator.redo();}

6 次要长处

  • 升高耦合度:因为请求者与接收者之间不存在间接援用,因而请求者与接收者之间实现齐全解耦,雷同的申请能够对应不同的接收者,同样雷同的接收者也能够供不同的请求者应用,两者之间具备良好的独立性
  • 满足 OCP:新的命令能够很容易增加到零碎中,因为减少新的具体命令类不会影响到其余类,因而减少新的具体命令类很容易,满足 OCP 的要求
  • 撤销 + 中作:为申请的撤销以及重做提供了一种设计和实现计划

7 次要毛病

  • 过多具体命令类:应用命令模式可能会导致系统有过多的具体命令类,因为针对每一个申请接收者的调用操作都须要设计一个具体工具类,因而在某些零碎中可能须要提供大量的具体命令类

8 实用场景

  • 零碎须要将申请调用者和申请接受者解耦,使得调用者和接收者不间接交互,申请调用者毋庸晓得接收者的存在,也无需晓得接收者是谁,接收者也毋庸关怀何时被调用
  • 零碎须要在不同工夫指定申请,将申请排队和执行申请
  • 零碎须要反对撤销以及复原操作
  • 零碎须要将一组操作组合一起造成宏命令,应用命令队列实现

9 总结

如果感觉文章难看,欢送点赞。

同时欢送关注微信公众号:氷泠之路。

退出移动版