命令( Command )模式

命令( Command )模式

命令模式的动机(Motivation)
在软件构建过程中，“行为请求者” 与“行为实现者须通常呈现一种“紧耦合”。但在某些场合一比 如需要对行为进行“记录、撤销/重(undo/redo)、事务”等处理，这种无法抵御变化的紧耦合是不合适的。
在这种情况下，如何将“行为请求者”与“行为实现者解耦?将一组行为抽象为对象，可以实现二者之间的松耦合。
问题的引入——烧烤摊和烧烤店

class Barbecuer {
	// 烤羊肉
	public void BakeMutton() {
		System.out.println("烤羊肉串!");
	}

	// 烤鸡翅
	public void BakeChickenWing() {
		System.out.println("烤鸡翅!");
	}
}

public class Main {
	public static void main(String[] args) {
		Barbecuer boy = new Barbecuer();
		boy.BakeMutton();// 烤羊肉串!
		boy.BakeMutton(); // 烤羊肉串!
		boy.BakeMutton();// 烤羊肉串!
		boy.BakeChickenWing();// 烤鸡翅!
		boy.BakeMutton();// 烤羊肉串!
		boy.BakeMutton();// 烤羊肉串!
		boy.BakeChickenWing();// 烤鸡翅!
	}
}

存在的问题
客户端发出命令或者请求，不关心请求的真正接收者是谁，也不关心具体如何实现，而且同一个请求的动作可以有不同的请求内容，当然具体的处理功能也不一样，该怎么实现?

松耦合设计

class Barbecuer {
	// 烤羊肉
	public void BakeMutton() {
		System.out.println("烤羊肉串!");
	}

	// 烤鸡翅
	public void BakeChickenWing() {
		System.out.println("烤鸡翅!");
	}
}

//抽象命令类
abstract class Command { // 声明执行的接口
	protected Barbecuer receiver;

	public Command(Barbecuer receiver) {
		this.receiver = receiver;
	}

//执行命令
	public abstract void ExcuteCommand();
}

//烤羊肉串命令
class BakeMuttonCommand extends Command {
	public BakeMuttonCommand(Barbecuer receiver) {
		super(receiver);
	}

	public void ExcuteCommand() {
		receiver.BakeMutton();
	}
}

//烤鸡翅命令
class BakeChickenWingCommand extends Command {
	public BakeChickenWingCommand(Barbecuer receiver) {
		super(receiver);
	}

	public void ExcuteCommand() {
		receiver.BakeChickenWing();
	}
}

//服务员
class Waiter {
//增加存放具体命令的容器
	private Command command;

//设置订单
	public void SetOrder(Command command) {
		this.command = command;
	}

//通知执行
	public void Notify() {
		command.ExcuteCommand();
	}
}

public class Main {
	public static void main(String[] args) {
//开店前的准各
		Barbecuer boy = new Barbecuer();
		Command bakeMuttonCommand1 = new BakeMuttonCommand(boy);
		Command bakeMuttonCommand2 = new BakeMuttonCommand(boy);
		Command bakeChikenWingCommand1 = new BakeChickenWingCommand(boy);
		Waiter girl = new Waiter();
//开门营业顾客点菜
		girl.SetOrder(bakeMuttonCommand1);
		girl.Notify();
		girl.SetOrder(bakeMuttonCommand2);
		girl.Notify();
		girl.SetOrder(bakeChikenWingCommand1);
		girl.Notify();
	}
}

缺点：客户点一个菜，服务员通知一下，不符合实际，应该点菜完成后一次性通知。再次修改！

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;

class Barbecuer {
	// 烤羊肉
	public void BakeMutton() {
		System.out.println("烤羊肉串!");
	}

	// 烤鸡翅
	public void BakeChickenWing() {
		System.out.println("烤鸡翅!");
	}
}

//抽象命令类
abstract class Command { // 声明执行的接口
	protected Barbecuer receiver;

	public Command(Barbecuer receiver) {
		this.receiver = receiver;
	}

//执行命令
	public abstract void ExcuteCommand();
}

//烤羊肉串命令
class BakeMuttonCommand extends Command {
	public BakeMuttonCommand(Barbecuer receiver) {
		super(receiver);
	}

	public void ExcuteCommand() {
		receiver.BakeMutton();
	}
}

//烤鸡翅命令
class BakeChickenWingCommand extends Command {
	public BakeChickenWingCommand(Barbecuer receiver) {
		super(receiver);
	}

	public void ExcuteCommand() {
		receiver.BakeChickenWing();
	}
}

// 增加存放具体命令的容器
class waiterlst {

	private ArrayList<Command> orders = new ArrayList<Command>();

	public void SetOrder(Command command) // 设置订单
	{
		if (command.getClass().getName() == "Barbecucom.BakeChickenWingCommand")
			System.out.println("服务员:鸡翅没有了。");
		else {
			orders.add(command);
			SimpleDateFormat df = new SimpleDateFormat("yyyy MM dd HH:mmss");
			// 设置日期格式
			// 记录日志，以各结账。newDate(为获取当前系统时间
			System.out.println("增加订单:" + command.getClass().getName() + "时间:" + df.format(new Date()));
		}
	}

	public void CancelOrder(Command command) { // 取消订单
		orders.remove(command);
		SimpleDateFormat df = new SimpleDateFormat("yyyv-MM _dd HH:mm:ss");
		// 设置日期格式
		System.out.println("取消订单:" + command.getClass().getName() + "时间: " + df.format(new Date()));
	}

	public void Notify() { // 通知全部执行
		Iterator<Command> cmd = orders.iterator();
		while (cmd.hasNext()) {
			cmd.next().ExcuteCommand();
		}
	}
}

public class Main {
	public static void main(String[] args) { // 开店前的准备
		Barbecuer boy = new Barbecuer();
		Command bakeMuttonCommand1 = new BakeMuttonCommand(boy);
		Command bakeMuttonCommand2 = new BakeMuttonCommand(boy);
		Command bakeChikenWingCommand1 = new BakeChickenWingCommand(boy);
		waiterlst girl = new waiterlst();
//开门营业顾客点菜
		girl.SetOrder(bakeMuttonCommand1);
		girl.SetOrder(bakeMuttonCommand2);
		girl.SetOrder(bakeChikenWingCommand1);
		girl.CancelOrder(bakeMuttonCommand1);
//点菜完毕，一次性通知厨房
		girl.Notify();
	}
}

命令模式基本介绍
1、命令模式(Command Pattern) :在软件设计中，经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不
知道被请求的操作是哪个，只需在程序运行时指定具体的请求接收者即可，比时，可以使用命令模式来进行设计。
2、命令模式使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵话，实现解耦。
3、在命令模式中，将一个请求封装为一个时象，以便使用不同参数来表示不同的请求(即命令)，同时命令模式也支持可撤销的操作。
4、Invoker是调用者(将军)，Receiver是 被调用者(士兵),MyCommand是命令，实现了Command接口，持有接收对象

命令( Command)模式

• 命令模式又称为行动( Action)模式或交易( Transaction ) 模式。
• 命令模式把一个请求或者操作封装到一个对象中。命令模 式允许系统使用不同的请求把客户端参数化;对请求排队
  或者记录请求日志，可以提供命令的撤销和恢复功能。
• 命令模式是对命令的封装。把发出命令的责任和执行命令 的责任分割开，委派给不同的对象。
• 命令模式允许请求的一方和接收的一方独立开来，使得请 求的一方不必知道接收请求的一方的接口，更不必知道请
  求是怎么被接收，以及操作是否被执行、何时被执行，以 及是怎么被执行的。

class Receiver {
	public void Action() {
		System.out.println("执行请求！");
	}
}

abstract class Command {
	protected Receiver receiver;

	public Command(Receiver receiver) {
		this.receiver = receiver;
	}

	abstract public void Excute();
}

class ConcreteCommand extends Command {
	public ConcreteCommand(Receiver receiver) {
		super(receiver);
	}

	@Override
	public void Excute() {
		// TODO Auto-generated method stub
		receiver.Action();
	}
}

class Invoker {
	private Command command;

	public void setCommand(Command command) {
		this.command = command;
	}

	public void ExecuteCommand() {
		command.Excute();
	}
}

public class Main {
	public static void main(String[] args) {
		Receiver r = new Receiver();
		Command c = new ConcreteCommand(r);
		Invoker i = new Invoker();
		i.setCommand(c);
		i.ExecuteCommand();
	}
}

在什么情况下应当使用命令模式

• 如果需要在不同的时刻指定、排列和执行请求，可以选用命令模式，把这些请求封装成为命令对象，然后实现把请求队列化
• 如果需安支持取消操作，可以选用命令模式，通过管理命令对象，能很容易的实现命令的恢复和重做的功能

命令模式优点

• 命令模式允许请求的一方和接收请求的一方能够 独立演化，从而有以下的优点:
  • .命令模式使新的命令很容易地被加入到系统里。
  • 允许接收请求的一方决定是否要否决( Veto) 请求。
  • 能较容易地设计一个命令队列。
  • 可以容易地实现对请求的Undo和Redo.
  • 在需要的情况下，可以较容易地将命令记入日志。
  • 命令模式把请求一个操作的对象与执行操作的对象分 割开。
  • 命令类与其他任何别的类一样，可以修改和推广。

本质

• 封装请求。