COMMAND 模式
command模式非常简单，简单到你无法想象的地方。
public interface Command {
void execute();
}
这就是一个command模式的样子。也许你会觉得，这有点多此一举吗。但是当你使用他的时候，command模式就会闪现光华。
这样一个场景：经理张三叫leader王二去开发一个项目， 王二就安排李四 去开发这个功能A。 李四何时执行，怎么执行就是他自己的事情了。
UML图如上所示：
代码如下：
public interface CommandInterface {
void execute();
}
public class ContractCommand implements CommandInterface {
Member member;
public ContractCommand(Member member) {
this.member = member;
}
@Override
public void execute() {
member.action();
}
}
public class Member {
public void action()
{
TraceLog.i();
}
}
Leader，获取命令，然后执行命令。
public class Leader {
CommandInterface commandInterface;
public void setCommandInterface(CommandInterface commandInterface) {
this.commandInterface = commandInterface;
}
public void executeCommand()
{
commandInterface.execute();
}
}
public class Manager {
public static void main()
{
Member m = new Member();
CommandInterface c = new ContractCommand(m);
Leader wang2 = new Leader();
wang2.setCommandInterface(c);
wang2.executeCommand();
}
}
manager创建运行的平台。
这样命令模式就开启了。
Active Object
Active Object 模式
一开始蛮难理解这个模式的目的，而且GOF的23中经典模式里也没有这个模式。
/**
* @author deman.lu
* @version on 2016-06-02 14:45
*/
public class ActiveObjectEngine {
List<CommandInterface> itsCommands = new ArrayList(); /*need to running in main thread, should check with synchronized*/
public void addCommand(CommandInterface aCommand)
{
itsCommands.add(aCommand);
} public void run()
{
/*should running in background*/
while (itsCommands.size() > 0)
{
CommandInterface c = itsCommands.get(0);
itsCommands.remove(0);
c.execute();
}
}
}
这个就是ActiveObject的engine，2个函数。一个是把一条command添加到表里面。
另一个是一个循环，处理问题。仔细思考，这就是消费者，和生产者问题的变种。
but这里没有线程block的地方。先看完全部代码：
public class SleepCommand implements CommandInterface {
@Override
public void execute() {
Date currentTime = new Date();
if (!started) {
started = true;
this.startTime = currentTime;
this.engine.addCommand(this);
} else {
long elapsedTime = currentTime.getTime() - startTime.getTime();
if (elapsedTime < SleepTime) {
this.engine.addCommand(this);
} else {
this.engine.addCommand(this.wakeupCommand);
}
}
}
private CommandInterface wakeupCommand = null;
private ActiveObjectEngine engine = null;
private long SleepTime = 0;
private Date startTime;
private boolean started = false;
public SleepCommand(long milliSeconds, ActiveObjectEngine e,
CommandInterface wakeupCommand) {
this.SleepTime = milliSeconds;
this.engine = e;
this.wakeupCommand = wakeupCommand;
}
}
public class DelayedTyper implements CommandInterface {
private long itsDelay;
private char itsChar;
private static boolean stop = false;
static String printStr = "";
private static ActiveObjectEngine engin =
new ActiveObjectEngine();
static class StopCommand implements CommandInterface
{
@Override
public void execute() {
DelayedTyper.stop = true;
}
}
public static void Main()
{
engin.addCommand(new DelayedTyper(100, 'A'));
engin.addCommand(new DelayedTyper(300, 'B'));
engin.addCommand(new DelayedTyper(500, 'C'));
engin.addCommand(new DelayedTyper(700, 'D'));
CommandInterface stopCommand = new StopCommand();
engin.addCommand(new SleepCommand(2000, engin, stopCommand));
engin.run();
TraceLog.i(printStr);
}
public DelayedTyper(long delay, char c)
{
this.itsDelay = delay;
this.itsChar = c;
}
@Override
public void execute()
{
printStr +=itsChar;
if (!stop)
{
DelayAndRepeat();
}
}
private void DelayAndRepeat()
{
engin.addCommand(new SleepCommand(itsDelay, engin, this));
}
}
结果如下：
ABCDAAABACABAADAABCAAABAADABCAAABAACDB
当DelayedTyper没有到执行的时间点的时候，启动SleepCommand。
这个很关键，
if (elapsedTime < SleepTime) {
this.engine.addCommand(this);
} else {
this.engine.addCommand(this.wakeupCommand);
}
如果时间没到，就把自己加入到队列最后，等待下次执行。（此处没有用常见的线程block技术）
时间到了，就把wakeupCommand加入执行队列。
这里还有个关键是，没有stopcommand，命令会一直循环执行。
参考：
《敏捷软件开发》 Robert C. Martin