当前页面: 开发资料首页 → Java 专题 → Java Tip: 实现Command模式

Java Tip: 实现Command模式

摘要: Java Tip: 实现Command模式

概述有时需要向对象发送请求，但是不知道 "被请求的操作" 或 "请求的接受者" 的任何信息。在面向过程的程序设计语言中，这类通信是通过回调函数来完成的：在某个地方登记这个函数，然后在后面调用它。在面向对象程序中，command(命令)与回调函数等价，它封装了回调函数。本文演示如何在Java中实现Command模式。
---------------------------------------------------------------------------
设计模式不但可以加速面向对象工程的设计进度，而且可以提高开发小组的产出以及软件的质量。Commad模式是一种对象行为模式，它可以对发送者(sender)和接收者(receiver)完全解耦(decoupling)。（"发送者" 是请求操作的对象，"接收者" 是接收请求并执行某操作的对象。有了 "解耦"，发送者对接收者的接口一无所知。）这里，"请求"(request)这个术语指的是要被执行的命令。Command模式还让我们可以对 "何时" 以及 "如何" 完成请求进行改变。因此，Command模式为我们提供了灵活性和可扩展性。
在象C这样的程序设计语言中，函数指针常被用来消除庞大的switch语句。(参见 "Java Tip 30: Polymorphism and Java" 获得更详细的介绍)Java没有函数指针，所以我们可以用Command模式来实现回调函数。在下面的第一个代码示例TestCommand.java中，你将实际看到它是如何实现的。
一些开发者在其它语言中已经习惯于使用函数指针，因而他们往往禁不起诱惑，想以同样的方法使用Reflection API的Method对象。例如，在 "Java Reflection" 一文中，Paul Tremblett介绍了如何使用Reflection而不是switch语句来实现事务处理(Transaction) (参见 "相关资源" 获得Tremblett的文章和Sun的Reflection教程网址的链接)。我是不会为这样的诱惑所动的。正如Sun所指出的：在有其它更贴近于Java程序设计语言的工具满足使用要求的情况下，一般不提倡使用Reflect API。不使用Method对象，程序会更易于调试和维护。所以，你应该定义一个接口，并在类中实现它，以执行所需操作。
因此我建议，可以使用Command模式并结合Java的动态加载和绑定机制来实现函数指针。(关于Java的动态加载和绑定机制的详细介绍，参见Gosling和Henry McGilton的"The Java Language Environment -- A White Paper"，列于"相关资源"。)
遵循上面的建议，我们可以运用Command模式，利用它所提供的多态性来消除庞大的switch语句，从而设计出可扩展的系统。我们还可以利用Java独有的动态加载和绑定机制来构筑动态的、并且可以动态扩展的系统。这一点在下面第二个代码示例TestTransactionCommand.java中进行说明。
Command模式使请求本身成为一个对象。这个对象和其它对象一样可以被存储和四处传递。这种模式的关键在于一个Command接口：它声明了一个接口，用于执行操作。最简单的形式下，这个接口包含一个抽象的execute操作。每个具体的Command类把接收者作为一个实例变量进行存储，从而指定了一对 "接收者" 和 "行为"。它为execute()方法提供不同的实现以进行请求调用。接收者知道如何执行请求。
如下的图1表示了Switch--一个Command对象的集合体(aggregation)。它的接口中有flipUp()和flipDown()两种操作。Switch被称为 "调用者"(invoker)，因为它调用command接口中的execute操作。
具体的command，如LightOnCommand，实现command接口的execute操作。它知道去调用合适的接收者对象的操作。这种情况下它充当了一个适配器(adapter)。通过 "适配器"这一术语，我想说明：具体的Command对象是一个简单的连接器，它连接具有不同接口的 "调用者" 和 "接收者"。
客户实例化调用者，接收者以及具体的command对象。
图2为时序图，它表示对象间的相互作用。它说明了Command如何对调用者和接收者(以及它执行的请求)解耦。客户用合适的接收者作为构造函数的参数来创建具体的command。然后，它将Command保存在调用者中。调用者回调具体的command，后者知道如何完成想要的Action()操作。
客户(代码中的主程序)创建具体的Command对象并设置它的接收者。作为一个调用者对象，Switch保存具体的Command对象。调用者通过对Command对象调用execute来发送请求。具体的Command对象对它的接收者进行操作调用，从而完成操作请求。
这里最关键的思想在于，具体的command用调用者来注册自身，调用者进行回调，在接收者身上执行命令。
Command模式示例代码让我们来看一个简单的例子，它通过Command模式实现回调机制。
以Fan(风扇)和Light(灯)为例。我们的目标是设计一个Switch，它可以对任一个对象进行 "开" 和 "关" 的操作。Fan和Light具有不同的接口，这意味着Switch必须独立于接收者接口，或者说，它不清楚接收者的接口。为了解决这一问题，每个Switch都需要合适的command作为参数。很明显，连接到Light的Switch和连接到Fan的Switch具有不同的command。因此，Command类必须是抽象的，或者是个接口。
Switch的构造函数被调用时，它以一组合适的command作为参数。command作为Switch的私有变量保存下来。
调用flipUp()和flipDown()操作时，它们只是简单地让合适的command进行execute()操作。Switch对调用execute()后将发生些什么一无所知。
TestCommand.java class Fan { public void startRotate() { System.out.println("Fan is rotating"); } public void stopRotate() { System.out.println("Fan is not rotating"); } } class Light { public void turnOn( ) { System.out.println("Light is on "); } public void turnOff( ) { System.out.println("Light is off"); } } class Switch { private Command UpCommand, DownCommand; public Switch( Command Up, Command Down) { UpCommand = Up; // concrete Command registers itself with the invoker DownCommand = Down; } void flipUp( ) { // invoker calls back concrete Command, which executes the Command on the receiver UpCommand . execute ( ) ;
} void flipDown( ) { DownCommand . execute ( ); } } class LightOnCommand implements Command { private Light myLight; public LightOnCommand ( Light L) { myLight = L; } public void execute( ) { myLight . turnOn( ); } } class LightOffCommand implements Command { private Light myLight; public LightOffCommand ( Light L) { myLight = L; } public void execute( ) { myLight . turnOff( ); } } class FanOnCommand implements Command { private Fan myFan; public FanOnCommand ( Fan F) { myFan = F; } public void execute( ) { myFan . startRotate( ); } } class FanOffCommand implements Command { private Fan myFan; public FanOffCommand ( Fan F) { myFan = F; } public void execute( ) { myFan . stopRotate( ); } } public class TestCommand { public static void main(String[] args) { Light testLight = new Light( ); LightOnCommand testLOC = new LightOnCommand(testLight); LightOffCommand testLFC = new LightOffCommand(testLight); Switch testSwitch = new Switch(testLOC,testLFC);
testSwitch.flipUp( ); testSwitch.flipDown( ); Fan testFan = new Fan( ); FanOnCommand foc = new FanOnCommand(testFan); FanOffCommand ffc = new FanOffCommand(testFan); Switch ts = new Switch( foc,ffc); ts.flipUp( ); ts.flipDown( ); } }
Command.java public interface Command { public abstract void execute ( ); }
在上面的示例代码中，Command模式将 "调用操作的对象" (Switch)和 "知道如何执行操作的对象" (Light和Fan)完全分离开来。这带来了很大的灵活性：发送请求的对象只需要知道如何发送；它不必知道如何完成请求。
Command模式实现Transaction Command模式也被称为action(动作)模式或transaction(事务)模式。假设有一个服务器，它接收并处理客户通过TCP/IP socket连接发送的transaction。这些transaction包含一个命令，后跟零个或多个参数。
一些设计者可能会使用switch语句，每个command对应一个case。在一个面向对象工程的设计中，代码中如果使用switch语句，往往表示这是一个糟糕的设计。Command模式展现的是支持transaction的面向对象的方法，它可以用于解决这类设计问题。
在TestTransactionCommand.java程序的客户代码中，所有请求都被封装在通用的TransactionCommand对象中。TransactionCommand对象由客户创建并用CommandManager进行登记。等待的请求可以通过调用runCommands()在不同时期被执行，这带来了很大的灵活性。而且我们还可以将多个command组装成一个复合command。示例代码中还有CommandArgument，CommandReceiver，CommandManager这些类，以及TransactionCommand的子类--AddCommand和SubtractCommand。下面是对这些类的介绍。
· CommandArgument是一个helper类，它保存命令的参数。如果是大量(或可变数量)的任何类型的参数，它可以被重写，以简化参数的传递工作。
· CommandReceiver实现所有的命令处理方法(command-processing method)，它用Singleton模式来实现。
· CommandManager是调用者，和前面例子中的Switch相当。它在其私有myCommand变量中保存通用TransactionCommand对象。runCommands()被调用时，它调用合适的TransactionCommand对象的execute()。
Java中，可以根据一个包含类名的字符串查找类的定义。在TransactionCommand类的execute ()操作中，我先计算出类名，然后将它链接到运行系统中--也就是说，类是根据需要被即时载入的。这里所采用的命名方式是，在命令名后连接一个 "Command" 字符串作为transaction command子类名，这样它就可以被动态载入。
注意，newInstance()返回的Class对象必须被转换为合适的类型。这意味着新的类要么必须实现一个接口，要么继承一个在编译期就为程序所知道的现有的类。本例中我们是实现Command接口，所以不存在问题。 file://TestTransactionCommand.java import java.util.*;
final class CommandReceiver { private int[] c;
private CommandArgument a;
private CommandReceiver(){
c = new int[2];
} private static CommandReceiver cr = new CommandReceiver(); public static CommandReceiver getHandle() { return cr; } public void setCommandArgument(CommandArgument a) { this.a = a;
} public void methAdd() { c = a.getArguments();
System.out.println("The result is " + (c[0]+c[1]));
} public void methSubtract() { c = a.getArguments();
System.out.println("The result is " + (c[0]-c[1]));
} } class CommandManager { private Command myCommand; public CommandManager(Command myCommand) {
this.myCommand = myCommand ;
} public void runCommands( ) {
myCommand.execute(); } }
class TransactionCommand implements Command { private CommandReceiver commandreceiver;
private Vector commandnamelist,commandargumentlist;
private String commandname;
private CommandArgument commandargument;
private Command command; public TransactionCommand () { this(null,null);
} public TransactionCommand ( Vector commandnamelist, Vector commandargumentlist){
this.commandnamelist = commandnamelist;
this.commandargumentlist = commandargumentlist;
commandreceiver = CommandReceiver.getHandle();
} public void execute( ) { for (int i = 0; i < commandnamelist.size(); i++) { commandname = (String)(commandnamelist.get(i));
commandargument = (CommandArgument)((commandargumentlist.get(i)));
commandreceiver.setCommandArgument(commandargument);
String classname = commandname + "Command"; try {
Class cls = Class.forName(classname);
command = (Command) cls.newInstance(); }
catch (Throwable e) {
System.err.println(e); }
command.execute(); } } } class AddCommand extends TransactionCommand { private CommandReceiver cr; public AddCommand () {
cr = CommandReceiver.getHandle(); } public void execute( ) {
cr.methAdd();
} } class SubtractCommand extends TransactionCommand {
private CommandReceiver cr; public SubtractCommand () {
cr = CommandReceiver.getHandle();
} public void execute( ) {
cr.methSubtract(); } }
class CommandArgument {
private int[] args; CommandArgument() {
args = new int[2]; }
public int[] getArguments() { return args;
}
public void setArgument(int i1, int i2) {
args[0] = i1; args[1] = i2; } } public class TestTransactionCommand {
private Vector clist,alist; public TestTransactionCommand() { clist = new Vector();
alist = new Vector();
} public void clearBuffer(Vector c, Vector a) { clist.removeAll(c);
alist.removeAll(a); } public Vector getClist() { return clist;
} public Vector getAlist() { return alist;
} public static void main(String[] args) {
CommandArgument ca,ca2; TestTransactionCommand t = new TestTransactionCommand(); ca = new CommandArgument();
ca.setArgument(2,8);
Vector myclist = t.getClist();
Vector myalist = t.getAlist();
myclist.addElement("Add"); myalist.addElement(ca); TransactionCommand tc = new TransactionCommand(myclist,myalist);
CommandManager cm = new CommandManager(tc);
cm.runCommands(); t.clearBuffer(myclist,myalist);
ca2 = new CommandArgument();
ca2.setArgument(5,7);
myclist = t.getClist();
myalist = t.getAlist();
myclist.addElement("Subtract"); myalist.addElement(ca2);
myclist.addElement("Add"); myalist.addElement(ca2); TransactionCommand tc2 = new TransactionCommand(myclist,myalist);
CommandManager cm2 = new CommandManager(tc2);
cm2.runCommands(); } }
命令及其参数保存在列表中，并被封装成通用TransactionCommand对象。通用TransactionCommand用CommandManager来注册。任何时候，命令可以在CommandManager类中通过调用runCommands()接口来执行。
客户代码不依赖于任何具体的TransactionCommand子类，也就是说，我的设计是针对接口而不是实现。这带来了灵活性：要想增加一个新的命令，只需要定义一个新的TransactionCommand子类，并在CommandReceiver类中提供新的命令处理方法的实现。仅此而已。
结论 Command模式具有以下优点：
1. command将 "进行操作请求" 的对象和 "知道如何执行操作" 的对象分离开来(即，解耦)。
2. command是个很棒的对象。它可以象任何其它对象一样被使用和继承。
3. 多个command可以被组装成一个复合command。
4. 很容易增加新的command，因为不需要修改现有的类。
如果执行过的命令序列被保存在一个历史列表中，就可以遍历这个列表来提供undo和redo操作。要想实现这一功能，必须在Command接口中有一个unexecute()操作。这一练习留给读者自己去完成。
---------------------------------------------------------------------------
相关资源 · Design Patterns by Gamma, Helm, Johnson, Vlissides, Addison-Wesley, 1994, ISBN 0-201-63361-2 http://www.bookbuyer.com/cgi-bin/getTitle.cgi?ISBN=0201633612
· Dr. Dobb's Journal, January 1998: "Java Reflection: Not just for tool developers," by Paul Tremblett http://www.ddj.com/articles/1998/9801/9801c/9801c.htm
· Sun's Reflection page http://java.sun.com/docs/books/tutorial/reflect/index.html
· "The Java Language Environment -- A White Paper" (May 1996), by James Gosling and Henry McGilton covers details about Java's dynamic loading and binding mechanism http://java.sun.com/docs/white/langenv/ For more on taking advantage of Java's unique feature of dynamic loading and binding mechanism to build a dynamic and dynamically-extensible system, see http://java.sun.com/docs/white/langenv/
↑返回目录
前一篇: Java Tip: 用Reflection实现Visitor模式
后一篇: Java Thread应该注意的问题