【转】设计模式学习笔记之命令模式

定义：将请求封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式支持可撤销等操作。

命令模式将发出请求的对象和执行请求的对象解耦。在被解耦的两者之间是通过命令对象进行沟通的。

案例代码下载

案例情景：开灯和关灯操作是电灯的基本操作。我们用命令模式模拟这种情景。

Handler.java

[java] view plain copy print ?

1. public class Handler { 
2.     public static final int LIGHT_OPEN = 0; 
3.     public static final int LIGHT_CLOSE= 1; 
4.     public void handleMessage(Message msg){ 
5.         int what = msg.what; 
6.         Light l = (Light) msg.obj; 
7.         switch(what){ 
8.         case LIGHT_OPEN : 
9.             l.lightOn(); 
10.             break; 
11.         case LIGHT_CLOSE: 
12.             l.lightOff(); 
13.             break; 
14.         } 
15.     } 
16. } 

public class Handler {
	public static final int LIGHT_OPEN = 0;
	public static final int LIGHT_CLOSE= 1;
	public void handleMessage(Message msg){
		int what = msg.what;
		Light l = (Light) msg.obj;
		switch(what){
		case LIGHT_OPEN :
			l.lightOn();
			break;
		case LIGHT_CLOSE:
			l.lightOff();
			break;
		}
	}
}

Message.java

[java] view plain copy print ?

1. public class Message { 
2.     int what; 
3.     int arg1; 
4.     int arg2; 
5.     Object obj; 
6.     Handler mHandler; 
7.     public Message(int what,Object obj){ 
8.         this.what = what; 
9.         this.obj = obj; 
10.     } 
11.     public void setTarget(Handler handler){ 
12.         mHandler = handler; 
13.     } 
14.     public void sendMessage(){ 
15.         mHandler.handleMessage(this); 
16.     } 
17. } 

public class Message {
	int what;
	int arg1;
	int arg2;
	Object obj;
	Handler mHandler;
	public Message(int what,Object obj){
		this.what = what;
		this.obj = obj;
	}
	public void setTarget(Handler handler){
		mHandler = handler;
	}
	public void sendMessage(){
		mHandler.handleMessage(this);
	}
}

Light.java

[java] view plain copy print ?

1. public class Light { 
2.     public void lightOn(){ 
3.         System.out.println("开灯"); 
4.     } 
5.     public void lightOff(){ 
6.         System.out.println("关灯"); 
7.     } 
8. } 

public class Light {
	public void lightOn(){
		System.out.println("开灯");
	}
	public void lightOff(){
		System.out.println("关灯");
	}
}

Test.java

[java] view plain copy print ?

1. /**
2. * 命令模式使命令发送者与命令接收者完全解耦，他们互相不需要知道对方的逻辑实现。
3. * Message即是命令的包装者，也是命令的发送者，其实真正的发送者是Handler
4. * 客户端也就是命令的接收者，Light，怎么开灯，怎么关灯，我们不需要知道其内部逻辑，我们只需发出命令。
5. * @author
6. *
7. */ 
8. public class Test { 
9.     public static void main(String args[]){ 
10.         Handler handler = new Handler(); 
11.         Light light = new Light();//命令接收者 
12.          
13.         Message lightOn = new Message(handler.LIGHT_OPEN, light);//包装一条开灯的消息 
14.         Message lightOff = new Message(handler.LIGHT_CLOSE, light);//包装一条关灯的消息 
15.          
16.         lightOff.setTarget(handler); 
17.         lightOn.setTarget(handler); 
18.          
19.         lightOn.sendMessage();//发出命令 
20.         System.out.println("--------------------"); 
21.         lightOff.sendMessage();//发出命令 
22.  
23.     } 
24. } 

/**
 * 命令模式使命令发送者与命令接收者完全解耦，他们互相不需要知道对方的逻辑实现。
 * Message即是命令的包装者，也是命令的发送者，其实真正的发送者是Handler
 * 客户端也就是命令的接收者，Light，怎么开灯，怎么关灯，我们不需要知道其内部逻辑，我们只需发出命令。
 * @author
 *
 */
public class Test {
	public static void main(String args[]){
		Handler handler = new Handler();
		Light light = new Light();//命令接收者
		
		Message lightOn = new Message(handler.LIGHT_OPEN, light);//包装一条开灯的消息
		Message lightOff = new Message(handler.LIGHT_CLOSE, light);//包装一条关灯的消息
		
		lightOff.setTarget(handler);
		lightOn.setTarget(handler);
		
		lightOn.sendMessage();//发出命令
		System.out.println("--------------------");
		lightOff.sendMessage();//发出命令

	}
}

测试结果：

[java] view plain copy print ?

1. 开灯 
2. -------------------- 
3. 关灯 

开灯
--------------------
关灯

总结：命令模式有很多变种，规整的命令模式会将命令委托给接收者，但我们也可以在命令包装类中就实现命令处理逻辑。