command设计模式和回调机制

总结command设计模式和回调机制，说明这两者之间的联系，并且用command模式来实现回调机制。command设计模式是回调机制的一个面向对象的替代品。

一、首先介绍回调机制

回调机制：一开始，一个类定义了一些个未实现的方法，并且该类并不知道这些方法具体的实现是怎么样的，因为只有等到运行时候才能够知道这些方法的具体实现。等到具体要用到该类对象的时候，才对该类中的抽象方法定义实现。该实现的过程由client来实现。具体的代码如下所示：

回调类

package callback;

/**
 * 回调接口
 * 
 * @author typ
 * 
 */
public abstract class ICallBack {
	/**
	 * 需要回调的方法。即在回调时候需要实现的方法
	 */
	public abstract void callback();
}

需要调用callback的类

package callback;

/**
 * 某个类需要调用回调接口中的方法
 * 
 * @author typ
 * 
 */
public class A {
	ICallBack iCallBack;

	/**
	 * 在此处调用回调接口时候，要先实现该接口
	 * 
	 * @param iCallBack
	 */
	public void setICallBack(ICallBack iCallBack) {
		this.iCallBack = iCallBack;
	}

	/**
	 * 调用回调接口中的方法，当然调用之前要先实现callback方法
	 */
	public void doSomeThing() {
		iCallBack.callback();
	}
}

测试类client

package callback;

/**
 * 在运行的时候才能确定回调方法的具体实现
 * 
 * @author typ
 * 
 */
public class Client {
	public static void main(String[] args) {
		A a = new A();

		a.setICallBack(new ICallBack() {

			/* 此处在创建ICallBack对象时候，定义callback函数的方法体
			 * (non-Javadoc)
			 * @see callback.ICallBack#callback()
			 */
			public void callback() {
				System.out.println("A is running, and call back is running!");
			}
		});

		a.doSomeThing();
	}
}

二、command设计模式

命令模式是对命令的封装。命令模式把发出命令的调用方和执行命令的接收方分割开，对两者之间解耦。

每一个命令都是一个操作：调用方发出请求要求执行一个操作；接收方收到请求，并执行操作。如果没有命令模式，那么，调用方要存放一个接收方的引用，这样增加了他们之间的耦合性。命令模式允许调用方和接收方独立开来，使得调用方不必知道接收方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。并且利用command模式还可以执行redo和undo操作。代码走起：

命令接收方，其实最终还是接收方来执行命令

package command;

/**
 * 命令的接收者
 * 
 * @author typ
 * 
 */
public class Receiver {
	public void execute() {
		System.out.println("receiver is executing!");
	}
}

command抽象类，保存一个指向接收方的引用，定义了一个execute方法，在子类中是想

package command;

/**
 * 命令的抽象类，用于封装不同类型的命令和接收者
 * 
 * @author typ
 * 
 */
public abstract class Command {
	Receiver receiver;

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

	public abstract void execute();

}

command的具体子类

package command;

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

	public void execute() {
		receiver.execute();
	}
}

调用方，保存一个指向命令command的引用，可以传入任何具体的command

package command;

/**
 * 调用者
 * 
 * @author typ
 * 
 */
public class Invoker {
	Command command;

	public Invoker() {
	}

	/**
	 * 执行command
	 */
	public void invoke() {
		command.execute();
	}

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

client测试类

package command;

/**
 * 测试类
 * 
 * @author typ
 * 
 */
public class Client {
	public static void main(String[] args) {
		Receiver receiver = new Receiver();
		Command command = new ConcreteCommand(receiver);
		Invoker invoker = new Invoker();
		invoker.setCommand(command);
		invoker.invoke();
	}
}

三、command模式如何替代回调机制

"CallBack"讲的便是先将一个函数登记上，然后在以后调用此函数。使用命令模式作为"CallBack"在面向对象系统中的替代。

下面我们就在回调机制上面改，如下：

回调类改为command类

package comm_call;

/**
 * 回调接口--相当于Command类
 * 
 * @author typ
 * 
 */
public abstract class ICallBack {
	/**
	 * 需要回调的方法。即在回调时候需要实现的方法
	 */
	public abstract void callback();
}

ICallBackImpl相当于ConcreteCommand

package comm_call;

/**
 * ICallBack的实现类，这个类相当于Command的具体实现类ConcreteCommand
 * @author typ
 *
 */
public class ICallBackImpl extends ICallBack {

	public void callback() {
		System.out.println("A is running, and call back is running!");
	}

}

调用方类

package comm_call;

/**
 * 该类作为调用方类
 * 
 * @author typ
 * 
 */
public class A {
	ICallBack iCallBack;

	/**
	 * 在此处调用回调接口时候，要先实现该接口
	 * 
	 * @param iCallBack
	 */
	public void setICallBack(ICallBack iCallBack) {
		this.iCallBack = iCallBack;
	}

	/**
	 * 调用回调接口中的方法，当然调用之前要先实现callback方法
	 */
	public void doSomeThing() {
		iCallBack.callback();
	}
}

测试类Client

package comm_call;

/**
 * 在运行的时候传入command对象，而不是实现回调方法
 * 
 * @author typ
 * 
 */
public class Client {
	public static void main(String[] args) {
		A a = new A();
		ICallBackImpl iCallBackImpl = new ICallBackImpl();
		// 此处传入iCallBackImpl是一个命令的对象，回调机制中此处传入的是一个回调类
		a.setICallBack(iCallBackImpl);
		a.doSomeThing();
	}
}