HeadFirst（六）Command 命令设计模式

 

命令模式

将“请求”封装成对象，以便使用不同的请求，队列或日志来参数化其它对象。

命令模式也可以支持撤销的操作。

 

使用命令模式来实现“队列、日志、支持撤销操作”

 

 

===========================================================================

 

示例：遥控器功能的实现---开/关/撤销

 

 

 

接收命令的对象

 

package receiver;

public abstract class Receiver {
	
	protected String location;
	
}

 

package receiver.impl;

import receiver.Receiver;

/**
 * 灯
 */
public class Light extends Receiver {
	
	public Light(String location) {
		this.location = location;
	}
	
	public void on() {
		System.out.println(location+"light on");
	}
	
	public void off() {
		System.out.println(location+"light off");
	}
}

 

package receiver.impl;

import receiver.Receiver;

/**
 * 车库门
 */
public class GarageDoor extends Receiver {
	
	public GarageDoor(String location) {
		this.location = location;
	}

	public void up() {
		System.out.println("Grarge Door is open");
	}


	public void down() {
		System.out.println("Grarge Door is close");
	}

}

 

package receiver.impl;

import receiver.Receiver;

/**
 * 音响
 */
public class Stereo extends Receiver {
	
	public Stereo(String location) {
		this.location = location;
	}

	public void on() {
		System.out.println("stereo is open,put cd in,set volume 11");
	}

	public void off() {
		System.out.println("stereo off");
	}

}

 

 

各种具体的命令

package command;

/**
 * 命令对象，对外只暴露execute()，内部如何执行外界无需关心 
 */
public abstract interface Command {
	//执行指令
	public abstract void execute();
	//撤销上一步操作
	public abstract void undo();
}

 

package command.impl;

import receiver.impl.Light;
import command.Command;

public class LightOffCommand implements Command {
	
	Light light;
	
	public LightOffCommand(Light light) {
		this.light = light;
	}

	@Override
	public void execute() {
		light.off();
	}

	@Override
	public void undo() {
		light.on();
	}

}

 

package command.impl;

import receiver.impl.Light;
import command.Command;

public class LightOnCommand implements Command {
	
	Light light;
	
	public LightOnCommand(Light light) {
		this.light = light;
	}

	@Override
	public void execute() {
		light.on();
	}

	@Override
	public void undo() {
		light.off();
	}

}

 

package command.impl;

import receiver.impl.GarageDoor;
import command.Command;

public class GarageDoorDownCommand implements Command {
	
	GarageDoor garageDoor;
	
	public GarageDoorDownCommand(GarageDoor garageDoor) {
		this.garageDoor = garageDoor;
	}


	@Override
	public void execute() {
		garageDoor.down();
	}


	@Override
	public void undo() {
		garageDoor.up();
	}

}

 

package command.impl;

import receiver.impl.GarageDoor;
import command.Command;

public class GarageDoorUpCommand implements Command {
	
	GarageDoor garageDoor;
	
	public GarageDoorUpCommand(GarageDoor garageDoor) {
		this.garageDoor = garageDoor;
	}


	@Override
	public void execute() {
		garageDoor.up();
	}


	@Override
	public void undo() {
		garageDoor.down();
	}

}

 

package command.impl;

import receiver.impl.Stereo;
import command.Command;

public class StereoOffCommand implements Command {

	Stereo stereo;

	public StereoOffCommand(Stereo stereo) {
		this.stereo = stereo;
	}


	@Override
	public void execute() {
		stereo.off();
	}


	@Override
	public void undo() {
		stereo.on();
	}

}

 

package command.impl;

import receiver.impl.Stereo;
import command.Command;

public class StereoOnWithCDCommand implements Command {

	Stereo stereo;

	public StereoOnWithCDCommand(Stereo stereo) {
		this.stereo = stereo;
	}


	@Override
	public void execute() {
		stereo.on();
	}


	@Override
	public void undo() {
		stereo.off();
	}

}

 

命令调用者---Invoker

完成命令的绑定

负责将命令绑定到对应的具体对象上去执行

package controller;

import java.util.Arrays;

import command.Command;
import command.NoCommand;

/**
 * 遥控器---Invoker
 * 负责发出各种命令
 */
public class RemoteController {
	
	//一组开的命令
	Command[] onCommands;
	//一组关的命令
	Command[] offCommands;
	//记录上次执行的命令，以便完成撤销
	Command undoCommand;
	
	public RemoteController() {
		init();
	}
	
	/**
	 * 初始化遥控器
	 */
	private void init() {
		onCommands = new Command[7];//看到没有，“接口也可以new”!
		offCommands = new Command[7];
		
		Command noCommand = new NoCommand();
		Arrays.fill(onCommands, noCommand);
		Arrays.fill(offCommands, noCommand);
		
		undoCommand = noCommand;
	}
	
	/**
	 * 为每个插槽指定对应的命令对象
	 * @param slot 插槽序号
	 * @param onCommand 开
	 * @param offCommand 关
	 */
	public void setCommand(int slot, Command onCommand, Command offCommand) {
		onCommands[slot] = onCommand;
		offCommands[slot] = offCommand;
	}
	
	/**
	 * 事件触发，执行对应的命令
	 * @param slot 扩展槽序号
	 */
	public void onButtonPressed(int slot) {
		onCommands[slot].execute();//执行命令
		undoCommand = onCommands[slot];//记录本次执行的命令对象
	}
	
	/**
	 * 事件触发，执行对应的命令
	 * @param slot 扩展槽序号
	 */	
	public void offButtonPressed(int slot) {
		offCommands[slot].execute();//执行命令
		undoCommand = offCommands[slot];//记录本次执行的命令对象
	}
	
	/**
	 * 撤销
	 */
	public void undoButtonPressed() {
		undoCommand.undo();
	}
	
	/**
	 * 输出遥控器各个扩展槽所绑定的命令对象
	 */
	public String toString() {
		StringBuffer stringBuff = new StringBuffer();
		stringBuff.append("----- Remote Control ----\n");
		for(int i=0; i<onCommands.length; i++) {
			stringBuff.append("[slot"+ i +"]" + onCommands[i].getClass().getName() 
					+ "       " + offCommands[i].getClass().getName() + "\n");
		}
		stringBuff.append("[undo]" + undoCommand.getClass().getName());
		return stringBuff.toString();
		
	}
}

 

测试

 

package test;

import receiver.impl.GarageDoor;
import receiver.impl.Light;
import receiver.impl.Stereo;

import command.impl.GarageDoorDownCommand;
import command.impl.GarageDoorUpCommand;
import command.impl.LightOffCommand;
import command.impl.LightOnCommand;
import command.impl.StereoOffCommand;
import command.impl.StereoOnWithCDCommand;

import controller.RemoteController;

public class RemoteLoader {
	public static void main(String[] args) {
		testCommand();
		testUndo();
	}

	

	private static void testCommand() {
		//Invoker---遥控器
		RemoteController remoteController = new RemoteController();
		
		//Receiver---各种被控制的对象
		Light livingRoomLight = new Light("Living Room");
		Light kitchenLight = new Light("Kitchen");
		GarageDoor garageDoor = new GarageDoor("");
		Stereo stereo = new Stereo("Living Room");
		
		//为每个插槽绑定命令
		remoteController.setCommand(0, new LightOnCommand(livingRoomLight), new LightOffCommand(livingRoomLight));
		remoteController.setCommand(1, new LightOnCommand(kitchenLight), new LightOffCommand(kitchenLight));
		remoteController.setCommand(2, new GarageDoorUpCommand(garageDoor), new GarageDoorDownCommand(garageDoor));
		remoteController.setCommand(3, new StereoOnWithCDCommand(stereo), new StereoOffCommand(stereo));
		
		//查看遥控器每个插槽所绑定的命令
		System.out.println(remoteController);
		
		//测试遥控器插槽对应的命令
		remoteController.onButtonPressed(0);
		remoteController.offButtonPressed(0);
		remoteController.onButtonPressed(1);
		remoteController.offButtonPressed(1);
		remoteController.onButtonPressed(2);
		remoteController.offButtonPressed(2);
		remoteController.onButtonPressed(3);
		remoteController.offButtonPressed(3);
	}
	
	private static void testUndo() {
		//Invoker---遥控器
		RemoteController remoteController = new RemoteController();
		
		//命令接收对象
		Light livingRoomLight = new Light("Living Room");
		
		//命令
		LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
		LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);
		
		//将卧室灯的命令绑定到0号插槽
		remoteController.setCommand(0, livingRoomLightOn, livingRoomLightOff);
		
		remoteController.onButtonPressed(0);//开
		remoteController.offButtonPressed(0);//关
		
		System.out.println(remoteController);
		
		remoteController.undoButtonPressed();//撤销->开
		remoteController.offButtonPressed(0);//关
		remoteController.onButtonPressed(0);//开
		remoteController.onButtonPressed(0);//开
		
		System.out.println(remoteController);
		
		remoteController.undoButtonPressed();
	}
}

 

 

===========================================================================

 

使用状态实现撤销

package receiver.impl;

import receiver.Receiver;

public class CeilingFan extends Receiver{
	public static final int HIGH = 3;
	public static final int MEDIUM = 2;
	public static final int LOW = 1;
	public static final int OFF = 0;
	
	int speed;//当前速度
	
	public CeilingFan(String location) {
		this.location = location;
	}
	
	public void high() {
		speed = HIGH;
		System.out.println("高速狂转");
	}
	
	public void medium() {
		speed = MEDIUM;
		System.out.println("中速转动");
	}
	
	public void low() {
		speed = LOW;
		System.out.println("慢速转动");
	}
	
	public void off() {
		speed = OFF;
		System.out.println("停止转动");
	}
	
	public int getSpeed() {
		return speed;
	}
	
}

 

package command.impl;

import receiver.impl.CeilingFan;
import command.Command;

public class CeilingFanHighCommand implements Command {

	CeilingFan ceilingFan;
	
	int preSpeed;//上一次的速度【如果使用堆栈记录信息，可以实现多层次的撤销】
	
	public CeilingFanHighCommand(CeilingFan ceilingFan) {
		this.ceilingFan = ceilingFan;
	}
	
	@Override
	public void execute() {
		preSpeed = ceilingFan.getSpeed();
		run(CeilingFan.HIGH);
	}

	@Override
	public void undo() {
		run(preSpeed);
	}
	
	private void run(int speed) {
		switch(speed) {
		case CeilingFan.HIGH:
			ceilingFan.high();
			break;
		case CeilingFan.MEDIUM:
			ceilingFan.medium();
			break;
		case CeilingFan.LOW:
			ceilingFan.low();
			break;
		case CeilingFan.OFF:
			ceilingFan.off();
			break;
		}
	}
}

 

package command.impl;

import receiver.impl.CeilingFan;
import command.Command;

public class CeilingFanMediumCommand implements Command {

	CeilingFan ceilingFan;
	
	int preSpeed;
	
	public CeilingFanMediumCommand(CeilingFan ceilingFan) {
		this.ceilingFan = ceilingFan;
	}
	
	@Override
	public void execute() {
		preSpeed = ceilingFan.getSpeed();
		run(CeilingFan.MEDIUM);
	}

	@Override
	public void undo() {
		run(preSpeed);
	}
	
	private void run(int speed) {
		switch(speed) {
		case CeilingFan.HIGH:
			ceilingFan.high();
			break;
		case CeilingFan.MEDIUM:
			ceilingFan.medium();
			break;
		case CeilingFan.LOW:
			ceilingFan.low();
			break;
		case CeilingFan.OFF:
			ceilingFan.off();
			break;
		}
	}
}

 

 

package command.impl;

import receiver.impl.CeilingFan;
import command.Command;

public class CeilingFanLowCommand implements Command {

	CeilingFan ceilingFan;
	
	int preSpeed;
	
	public CeilingFanLowCommand(CeilingFan ceilingFan) {
		this.ceilingFan = ceilingFan;
	}
	
	@Override
	public void execute() {
		preSpeed = ceilingFan.getSpeed();
		run(CeilingFan.LOW);
	}

	@Override
	public void undo() {
		run(preSpeed);
	}
	
	private void run(int speed) {
		switch(speed) {
		case CeilingFan.HIGH:
			ceilingFan.high();
			break;
		case CeilingFan.MEDIUM:
			ceilingFan.medium();
			break;
		case CeilingFan.LOW:
			ceilingFan.low();
			break;
		case CeilingFan.OFF:
			ceilingFan.off();
			break;
		}
	}
}

 

package command.impl;

import receiver.impl.CeilingFan;
import command.Command;

public class CeilingFanOffCommand implements Command {

	CeilingFan ceilingFan;
	
	int preSpeed;//跟踪上一次的运行状态
	
	public CeilingFanOffCommand(CeilingFan ceilingFan) {
		this.ceilingFan = ceilingFan;
	}
	
	@Override
	public void execute() {
		preSpeed = ceilingFan.getSpeed();
		run(CeilingFan.OFF);
	}

	@Override
	public void undo() {
		run(preSpeed);
	}
	
	private void run(int speed) {
		switch(speed) {
		case CeilingFan.HIGH:
			ceilingFan.high();
			break;
		case CeilingFan.MEDIUM:
			ceilingFan.medium();
			break;
		case CeilingFan.LOW:
			ceilingFan.low();
			break;
		case CeilingFan.OFF:
			ceilingFan.off();
			break;
		}
	}
}

 

测试

private static void testCeilingFan() {
		
		RemoteController invoker = new RemoteController();
		
		CeilingFan ceilingFan = new CeilingFan("Living Room");
		
		CeilingFanHighCommand ceilingHighCmd = new CeilingFanHighCommand(ceilingFan);
		CeilingFanMediumCommand ceilingMediumCmd = new CeilingFanMediumCommand(ceilingFan);
		CeilingFanLowCommand ceilingLowCmd = new CeilingFanLowCommand(ceilingFan);
		CeilingFanOffCommand ceilingOffCmd = new CeilingFanOffCommand(ceilingFan);
		
		invoker.setCommand(0, ceilingHighCmd, ceilingOffCmd);
		invoker.setCommand(1, ceilingMediumCmd, ceilingOffCmd);
		invoker.setCommand(2, ceilingLowCmd, ceilingOffCmd);
		
		invoker.onButtonPressed(0);
		invoker.offButtonPressed(0);
		invoker.undoButtonPressed();
		
		invoker.onButtonPressed(2);
		invoker.onButtonPressed(1);
		invoker.undoButtonPressed();
	}

 

 

===========================================================================

 

Party模式

 

把命令对象封装到一个数组中，完成命令的批量执行

 

package command.impl;

import command.Command;

/**
 * Party模式
 * 宏命令：将一组命令集合起来，一起执行
 */
public class MacroCommand implements Command {
	
	Command[] commands;
	
	public MacroCommand(Command[] commands) {
		this.commands = commands;
	}

	@Override
	public void execute() {
		for(Command c : commands) {
			c.execute();
		}
	}

	@Override
	public void undo() {
		for(Command c : commands) {
			c.undo();
		}
	}

}

 

测试

	private static void testMacroCommand() {
		RemoteController remoteController = new RemoteController();
		
		Light light = new Light("Living Room");
		Stereo stereo = new Stereo("");
		CeilingFan ceilingFan = new CeilingFan("Living Room");
		
		LightOnCommand lightOn = new LightOnCommand(light);
		StereoOnWithCDCommand stereoOn = new StereoOnWithCDCommand(stereo);
		CeilingFanMediumCommand celingFanMedium = new CeilingFanMediumCommand(ceilingFan);
		
		LightOffCommand lightOff = new LightOffCommand(light);
		StereoOffCommand stereoOff = new StereoOffCommand(stereo);
		CeilingFanOffCommand ceilingFanOff = new CeilingFanOffCommand(ceilingFan);
		
		
		Command[] partyOn = {lightOn, stereoOn, celingFanMedium};
		Command[] partyOff = {lightOff, stereoOff, ceilingFanOff};
		
		MacroCommand partyOnMacro = new MacroCommand(partyOn);
		MacroCommand partyOffMacro = new MacroCommand(partyOff);
		
		remoteController.setCommand(0, partyOnMacro, partyOffMacro);
//		remoteController.onButtonPressed(0);
		remoteController.offButtonPressed(0);
		remoteController.undoButtonPressed();
		
	}