文章目录
- 思考命令模式
- 1.命令模式的本质
- 2.何时选用命令模式
- 3.优缺点
- 4.实现
- 耦合写法
- 命令模式优化耦合写法
- 命令模式实现撤销
- 命令模式实现厨师做菜
- 命令模式实现排队
- 命令模式实现日志持久化
思考命令模式
命令模式就是解耦强耦合代码,用户只关心功能的实现,开发者却可以利用命令模式在这之间加一些小动作,比如:撤销命令、命令排队、记录命令日志等
1.命令模式的本质
命令模式的本质:封装请求。
命令模式的关键就是把请求封装成为命令对象,然后就可以对这个对象进行一系列的处理了,比如上面讲到的参数化配置、可撤销操作、宏命令、队列请求、日志请求等功能处理。
2.何时选用命令模式
建议在以下情况时选用命令模式。
-
如果需要抽象出需要执行的动作,并参数化这些对象,可以选用命令模式。将这些需要执行的动作抽象成为命令,然后实现命令的参数化配置。
-
如果需要在不同的时刻指定、排列和执行请求,可以选用命令模式。将这些请求封装成为命令对象,然后实现将请求队列化。
-
如果需要支持取消操作,可以选用命令模式,通过管理命令对象,能很容易地实现命令的恢复和重做功能。
-
如果需要支持当系统崩溃时,能将系统的操作功能重新执行一遍,可以选用命令模式。将这些操作功能的请求封装成命令对象,然后实现日志命令,就可以在系统恢复以后,通过日志获取命令列表,从而重新执行一遍功能。
-
在需要事务的系统中,可以选用命令模式。命令模式提供了对事务进行建模的方法。命令模式有一个别名就是Transaction。
3.优缺点
命令模式的优点
-
更松散的耦合
命令模式使得发起命令的对象——客户端,和具体实现命令的对象——接收者对象完全解耦,也就是说发起命令的对象完全不知道具体实现对象是谁,也不知道如何实现。 -
更动态的控制
命令模式把请求封装起来,可以动态地对它进行参数化、队列化和日志化等操作,从而使得系统更灵活。 -
很自然的复合命令
命令模式中的命令对象能够很容易地组合成复合命令,也就是前面讲的宏命令,从而使系统操作更简单,功能更强大。 -
更好的扩展性
由于发起命令的对象和具体的实现完全解耦,因此扩展新的命令就很容易,只需要实现新的命令对象,然后在装配的时候,把具体的实现对象设置到命令对象中,然后就可以使用这个命令对象,已有的实现完全不用变化。
4.实现
耦合写法
模拟电脑开机,点击机箱开机按钮,调用主板初始化系统,然后用户就能操作了
主板类
/*** @description:主板接口*/
public interface MainBoardApi {/*** 开机*/void open();
}/*** @description:技嘉主板*/
public class JiJiaMainBoard implements MainBoardApi{@Overridepublic void open() {System.out.println("技嘉主板正在开机,请稍后");System.out.println("接通电源.............");System.out.println("设备检查.............");System.out.println("装载系统.............");System.out.println("机器正常运行,请操作....");}
}/*** @description:微星主板*/
public class WeiXinMainBoard implements MainBoardApi{@Overridepublic void open() {System.out.println("微星主板正在开机,请稍后");System.out.println("接通电源.............");System.out.println("设备检查.............");System.out.println("装载系统.............");System.out.println("机器正常运行,请操作....");}
}
开机按钮类
/*** @description:机箱开机按钮*/
public class BoxButton {/*** 点击开机按钮,就开机*/public void boot(int flag){if (1==flag){new JiJiaMainBoard().open();}else {new WeiXinMainBoard().open();}}
}
测试类
/*** @description:最开始耦合写法*/
public class Test1 {public static void main(String[] args) {//点击按钮开机new BoxButton().boot(2);}
}
现在,机箱按钮直接调用主板,是强耦合的关系,很不利于维护
命令模式优化耦合写法
改造上面的耦合写法,主板接口和实现类不变
调用程序类(也就是上面的机箱按钮)
/*** @description:调用程序(机箱开机按钮)*/
public class Invoker {/*** 持有命令对象*/private Command command=null;public void setCommand(Command command) {this.command = command;}/*** 开机*/public void boot(){command.execute();}
}
命令类
/*** @description:命令接口*/
public interface Command {/*** 执行命令*/void execute();
}/*** @description:具体命令类(这里是开机命令)*/
@AllArgsConstructor
public class ConcreteCommand implements Command{/*** 持有主板对象*/private MainBoardApi mainBoardApi;@Overridepublic void execute() {//命令类不能进行开机操作//调用主板进行开机mainBoardApi.open();}
}
测试类
/*** @description:测试类* @createTime 2022/11/30 13:06*/
public class Client {public static void main(String[] args) {//把命令和实现组装起来Command command=new ConcreteCommand(new WeiXinMainBoard());//为机箱按钮设置命令Invoker invoker = new Invoker();invoker.setCommand(command);//模拟开机按钮invoker.boot();}
}
效果
命令模式实现撤销
撤销有两种:
- 补偿式(反操作式)
- 存储恢复式
模拟假如存在一个存在一个撤销按钮,电脑开机后,点击撤销按钮,撤销开机操作,也就是进行关机
主板类增加关机功能
/*** @description:主板接口*/
public interface MainBoardApi {/*** 开机*/void open();/*** 关机*/void close();
}/*** @description:技嘉主板*/
public class JiJiaMainBoard implements MainBoardApi{@Overridepublic void open() {System.out.println("技嘉主板正在开机,请稍后");System.out.println("接通电源.............");System.out.println("设备检查.............");System.out.println("装载系统.............");System.out.println("机器正常运行,请操作....");}@Overridepublic void close() {System.out.println("技嘉主板正在关机,请稍后");System.out.println("关机成功.............");}
}/*** @description:微星主板*/
public class WeiXinMainBoard implements MainBoardApi{@Overridepublic void open() {System.out.println("微星主板正在开机,请稍后");System.out.println("接通电源.............");System.out.println("设备检查.............");System.out.println("装载系统.............");System.out.println("机器正常运行,请操作....");}@Overridepublic void close() {System.out.println("微星主板正在关机,请稍后");System.out.println("关机成功.............");}
}
命令接口增加撤销命令
/*** @description:命令接口*/
public interface Command {/*** 执行命令*/void execute();/*** 撤销命令*/void undo();
}/*** @description:具体命令类(这里是开机命令)*/
@AllArgsConstructor
public class ConcreteCommand implements Command{/*** 持有主板对象*/private MainBoardApi mainBoardApi;@Overridepublic void execute() {//命令类不能进行开机操作//调用主板进行开机mainBoardApi.open();}@Overridepublic void undo() {//撤销开机,也就是关机mainBoardApi.close();}
}
调用程序增加关机功能
/*** @description:调用程序(机箱开机按钮)*/
public class Invoker {/*** 持有命令对象*/private Command command=null;public void setCommand(Command command) {this.command = command;}/*** 开机*/public void boot(){command.execute();}/*** 关机*/public void shutdown(){command.undo();}
}
测试类
public class Client {public static void main(String[] args) {//把命令和实现组装起来Command command=new ConcreteCommand(new WeiXinMainBoard());//为机箱按钮设置命令Invoker invoker = new Invoker();invoker.setCommand(command);//模拟开机按钮invoker.boot();//模拟点击撤销按钮,电脑关机invoker.shutdown();}
}
命令模式实现厨师做菜
模拟两个厨师,一个做热菜,一个做凉菜,服务员点菜
厨师类
/*** @description:厨师接口*/
public interface CookApi {/*** 做菜* @param name*/void cook(String name);
}/*** @description:热菜*/
public class HotCook implements CookApi{@Overridepublic void cook(String name) {System.out.println("厨师正在做:"+name);}
}/*** @description:凉菜*/
public class CoolCook implements CookApi{@Overridepublic void cook(String name) {System.out.println("厨师正在做:"+name);}
}
命令类
/*** @description:命令接口*/
public interface Command {/*** 执行命令*/void execute();
}/*** @description:生鱼刺身*/
public class FishCommand implements Command{private CookApi cookApi=null;public void setCookApi(CookApi cookApi) {this.cookApi = cookApi;}@Overridepublic void execute() {cookApi.cook("生鱼刺身");}
}/*** @description:北京烤鸭*/
public class MeatCommand implements Command{private CookApi cookApi=null;public void setCookApi(CookApi cookApi) {this.cookApi = cookApi;}@Overridepublic void execute() {cookApi.cook("北京烤鸭");}
}
菜单类
/*** @description:菜单*/
public class Menu{private Collection<Command> menu=new ArrayList<>();/*** 点菜,将菜品加入菜单* @param cmd*/public void addCommand(Command cmd){menu.add(cmd);}public void execute() {//遍历菜单,做菜for (Command cmd:menu){cmd.execute();}}
}
服务员(调用程序)
/*** @description:调用程序(服务员)*/
public class Waiter {private Menu menu=new Menu();/*** 客人点菜* @param cmd*/public void orderDish(Command cmd){//判断菜品是热菜还是凉菜if (cmd instanceof FishCommand){((FishCommand)cmd).setCookApi(new HotCook());}else {((MeatCommand)cmd).setCookApi(new CoolCook());}//加到菜单中menu.addCommand(cmd);}/*** 点菜完毕,执行命令去做菜*/public void orderOver(){menu.execute();}
}
测试类
public class Client {public static void main(String[] args) {Waiter waiter = new Waiter();//点菜waiter.orderDish(new FishCommand());waiter.orderDish(new MeatCommand());//点菜完毕waiter.orderOver();}
}
命令模式实现排队
修改代码如下
测试类
public class Client {public static void main(String[] args) {//创建3位厨师HotCook cook1 = new HotCook("张三");HotCook cook2 = new HotCook("李四");HotCook cook3 = new HotCook("王五");//启动线程new Thread(cook1).start();new Thread(cook2).start();new Thread(cook3).start();//模拟10桌客人for (int i=0;i<10;i++){Waiter waiter = new Waiter();//每个客人都点了北京烤鸭和生鱼刺身waiter.orderDish(new FishCommand(i));waiter.orderDish(new MeatCommand(i));//点菜完毕waiter.orderOver();}}
}
服务员类
/*** @description:调用程序(服务员)*/
public class Waiter {private Menu menu =new Menu();/*** 客人点菜* @param cmd*/public void orderDish(Command cmd){//加到菜单中menu.addCommand(cmd);}/*** 点菜完毕,执行命令去做菜*/public void orderOver(){menu.execute();}
}
菜单类
/*** @description:菜单*/
public class Menu {private Collection<Command> menu=new ArrayList<>();/*** 点菜,将菜品加入菜单* @param cmd*/public void addCommand(Command cmd){menu.add(cmd);}/*** 获取菜单中所有命令* @return*/public Collection<Command> getCommands(){return this.menu;}public void execute() {//将菜单传给后厨CommandQueue.addMenu(this);}
}
后厨管理类(队列)
/*** @description:菜单队列*/
public class CommandQueue {private static List<Command> cmds=new ArrayList<>();/*** 将菜单中做菜的命令取出来,加入一个队列* @param menu*/public synchronized static void addMenu(Menu menu){for (Command cmd:menu.getCommands()){cmds.add(cmd);}}/*** 按顺序取出一个命令* @return*/public synchronized static Command getOneCommand(){Command cmd=null;if (cmds.size()>0){//按顺序取出第一个命令cmd=cmds.get(0);//取完就移除cmds.remove(0);}return cmd;}
}
命令类
/*** @description:命令接口*/
public interface Command {/*** 执行命令*/void execute();/*** 设置命令接收者* @param cookApi*/void setCookApi(CookApi cookApi);
}/*** @description:生鱼刺身*/
public class FishCommand implements Command{private CookApi cookApi=null;/*** 桌号*/private int tableId;@Overridepublic void setCookApi(CookApi cookApi) {this.cookApi = cookApi;}public FishCommand(int tableId) {this.tableId = tableId;}@Overridepublic void execute() {cookApi.cook(tableId,"生鱼刺身");}
}/*** @description:北京烤鸭*/
public class MeatCommand implements Command{private CookApi cookApi=null;/*** 桌号*/private int tableId;@Overridepublic void setCookApi(CookApi cookApi) {this.cookApi = cookApi;}public MeatCommand(int tableId) {this.tableId = tableId;}@Overridepublic void execute() {cookApi.cook(tableId,"北京烤鸭");}
}
厨师类,暂时只用了一个实现类,可以不使用接口
/*** @description:厨师接口*/
public interface CookApi {/*** 做菜* @param tableId 桌号* @param name*/void cook(int tableId,String name);
}/*** @description:热菜*/
@AllArgsConstructor
public class HotCook implements CookApi,Runnable{private String name;@Overridepublic void cook(int tableId, String name) {//做菜时间int cookTime=(int)(20*Math.random());System.out.println(this.name+"厨师正在做"+tableId+"号桌的热菜:"+name);try {Thread.sleep(cookTime);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(this.name+"厨师做好了"+tableId+"号桌的热菜:"+name+",共耗时"+cookTime);}@Overridepublic void run() {while (true){//从后厨取一个做菜命令Command oneCommand = CommandQueue.getOneCommand();if (oneCommand!=null){//设置自己为做菜厨师oneCommand.setCookApi(this);//执行命令oneCommand.execute();}//做完菜休息1stry {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}
命令模式实现日志持久化
1.FishCommand和MeatCommand实现序列化接口
public class MeatCommand implements Command, Serializable {}public class FishCommand implements Command, Serializable {}
2.序列化和反序列化工具类
/*** @description:文件操作类*/
public class FileUtil {/*** 读文件,反序列化* @param pathName* @return*/public static List readFile(String pathName){List list=new ArrayList();ObjectInputStream oin=null;File file = new File(pathName);if (file.exists()){try {oin=new ObjectInputStream(new BufferedInputStream(new FileInputStream(file)));//反序列化list= (List) oin.readObject();} catch (Exception e) {e.printStackTrace();}finally {if (oin!=null){try {oin.close();} catch (IOException e) {e.printStackTrace();}}}}return list;}/*** 写入文件,序列化* @param pathName* @param list*/public static void writeFile(String pathName,List list){File file = new File(pathName);ObjectOutputStream oos=null;try {oos=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(file)));//序列化oos.writeObject(list);} catch (Exception e) {e.printStackTrace();}finally {if (oos!=null){try {oos.close();} catch (IOException e) {e.printStackTrace();}}}}
}
3.后厨管理类
/*** @description:菜单队列*/
public class CommandQueue {private final static String FILE_NAME="C:\\Users\\Lenovo\\Desktop\\commandqueue.txt";private static List<Command> cmds=null;/*** 静态代码块,每次重启先加载*/static {cmds= FileUtil.readFile(FILE_NAME);if (cmds==null){cmds=new ArrayList<>();}}/*** 将菜单中做菜的命令取出来,加入一个队列* @param menu*/public synchronized static void addMenu(Menu menu){for (Command cmd:menu.getCommands()){cmds.add(cmd);}//覆盖写入文件FileUtil.writeFile(FILE_NAME,cmds);}/*** 按顺序取出一个命令* @return*/public synchronized static Command getOneCommand(){Command cmd=null;if (cmds.size()>0){//按顺序取出第一个命令cmd=cmds.get(0);//取完就移除cmds.remove(0);//覆盖写入文件FileUtil.writeFile(FILE_NAME,cmds);}return cmd;}
}
执行
在第八桌的时候终止程序,然后再重启看效果,会从上次中断的地方继续做菜,然后再开始新得做菜