分享
 
 
 

Java Tip: 实现Command模式

王朝java/jsp·作者佚名  2008-05-31
窄屏简体版  字體: |||超大  

概述

有时需要向对象发送请求,但是不知道 "被请求的操作" 或 "请求的接受者" 的任何信息。在面向过程的程序设计语言中,这类通信是通过回调函数来完成的:在某个地方登记这个函数,然后在后面调用它。在面向对象程序中,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/

 
 
 
免责声明:本文为网络用户发布,其观点仅代表作者个人观点,与本站无关,本站仅提供信息存储服务。文中陈述内容未经本站证实,其真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。
2023年上半年GDP全球前十五强
 百态   2023-10-24
美众议院议长启动对拜登的弹劾调查
 百态   2023-09-13
上海、济南、武汉等多地出现不明坠落物
 探索   2023-09-06
印度或要将国名改为“巴拉特”
 百态   2023-09-06
男子为女友送行,买票不登机被捕
 百态   2023-08-20
手机地震预警功能怎么开?
 干货   2023-08-06
女子4年卖2套房花700多万做美容:不但没变美脸,面部还出现变形
 百态   2023-08-04
住户一楼被水淹 还冲来8头猪
 百态   2023-07-31
女子体内爬出大量瓜子状活虫
 百态   2023-07-25
地球连续35年收到神秘规律性信号,网友:不要回答!
 探索   2023-07-21
全球镓价格本周大涨27%
 探索   2023-07-09
钱都流向了那些不缺钱的人,苦都留给了能吃苦的人
 探索   2023-07-02
倩女手游刀客魅者强控制(强混乱强眩晕强睡眠)和对应控制抗性的关系
 百态   2020-08-20
美国5月9日最新疫情:美国确诊人数突破131万
 百态   2020-05-09
荷兰政府宣布将集体辞职
 干货   2020-04-30
倩女幽魂手游师徒任务情义春秋猜成语答案逍遥观:鹏程万里
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案神机营:射石饮羽
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案昆仑山:拔刀相助
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案天工阁:鬼斧神工
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案丝路古道:单枪匹马
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:与虎谋皮
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:李代桃僵
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:指鹿为马
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案金陵:小鸟依人
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案金陵:千金买邻
 干货   2019-11-12
 
推荐阅读
 
 
 
>>返回首頁<<
 
靜靜地坐在廢墟上,四周的荒凉一望無際,忽然覺得,淒涼也很美
© 2005- 王朝網路 版權所有