Command设计模式

    参考：http://www.bianceng.cn/Programming/Java/201104/26402.htm
    Command模式用来封装一个命令/请求，简单的说，一个Command对象中包含了待执行的一 个动作（语句）序列，以执行特定的任务。当然，并不是随便怎么样的语句序列都可以构成 一个Command对象的，按照Command模式的设计，Command对象和它的调用者Incvoker之间应该 具有接口约定的。也就是说，Invoker得到Command对象的引用，并调用其中定义好的方法， 而当Command对象改变（或者是对象本身代码改变，或者干脆完全另外的一个Command对象） 之后，Invoker中的代码可以不用更改。这样，通过封装请求，可以把任务和任务的实现加以 分离。
图二：Command模式的类图

而对于请求的处理又有两种不同的方法，一种是Command只充当代理，将请求转发给某个 接受者对象，还有一种是Command对象自己处理完所有的请求操作。当然，这只是两个极端， 更多的情况是Command完成一部分的工作，而另外的一部分这则交给接受者对象来处理。
在新的JDK的代理事件模型中，就可以看作是这样的一个Command模式。在那个模型中，一 个事件监听者类EventListener监听某个事件，并根据接口定义，实现特定的操作。比如，当 用Document对象的addDocumentListener(DocumentListener listener) 方法注册了一个 DocumentListener后，以后如果在Document对象中发生文本插入的事件，DocumentListener 中实现的insertUpdate(DocumentEvent e)方法就会被调用，如果发生文本删除事件， removeUpdate(DocumentEvent e)方法就会被调用。怎么样，想想看，这是不是一个Command 模式的应用呢？
然而，最经典的Command模式的应用，莫过于Swing中的Action接口。Action实际上继承的 是ActionListener，也就是说，它也是一个事件监听者（EventListener）。但是Action作为 一种ActionListener的扩展机制，提供了更多的功能。它可以在其中包含对这个Action动作 的一个或者多个文字的或图标的描叙，它提供了Enable/Disable的功能许可性标志。并且， 一个Action对象可以被多个Invoker，比如实现相同功能的按钮，菜单，快捷方式所共享。而 这些Invoker都知道如何加入一个Action，并充分利用它所提供的扩展机制。可以说，在这儿 Action更像一个对象了，因为它不仅仅提供了对方法的实现，更提供了对方法的描叙和控制 。可以方便的描叙任何的事务，这更是面向对象方法的威力所在。
    下面我们看一个Command模式的应用的例子。假设要实现这样的一个任务：Task Schedule 。也就是说，我想对多个任务进行安排，比如扫描磁盘，我希望它每1个小时进行一次，而备 份数据，我希望它半个小时进行一次，等等等等。但是，我并不希望作为TaskSchedule的类 知道各个任务的细节内容，TaskSchedule应该只是知道Task本身，而对具体的实现任务的细 节并不理会。因而在这儿，我们就需要对TaskSchedule和Task进行解耦，将任务和具体的实 现分离出来，这不正是Command模式的用武之地吗？
图三：Command模式的应用例子

程序清单：
//抽象的Task接口，作为回调的Command模式的主体
public interface Task {
　 public void taskPerform();
}
//具体的实现了Task接口的子类，实现特定的操作。
public class BackupTask implements Task{
　 public void taskPerform(){
　　 System.out.println("Backup Task has been performed");
　 }
}
//具体的实现了Task接口的子类，实现特定的操作。
public class ScanDiskTask implements Task{
　 public void taskPerform(){
　　 System.out.println("ScanDisk Task has been performed");
　 }
}
//一个封装了Task的一个封装类，提供了一些与Task相关的内容，也可以把这些内容
//这儿不过为了突出Command模式而把它单另出来，实际上可以和Task合并。
public class TaskEntry {
　 private Task task;
　 private long timeInterval;
　 private long timeLastDone;
　 public Task getTask() {
　　 return task;
　 }
　 public void setTask(Task task) {
　　 this.task = task;
　 }
　 public void setTimeInterval(long timeInterval) {
　　 this.timeInterval = timeInterval;
　 }
　 public long getTimeInterval() {
　　 return timeInterval;
　 }
　 public long getTimeLastDone() {
　　 return timeLastDone;
　 }
　 public void setTimeLastDone(long timeLastDone) {
　　 this.timeLastDone = timeLastDone;
　 }
　 public TaskEntry(Task task,long timeInteral){
　　 this.task=task;
　　 this.timeInterval =timeInteral;
　 }
}
//调度管理Task的类，继承Thread只是为了调用其sleep()方法，
//实际上，如果真的作Task调度的话，每个Task显然应该用单独的Thread来实现。
public class TaskSchedule extends java.lang.Thread {
　 private java.util.Vector taskList=new java.util.Vector();
　 private long sleeptime=10000000000l;//最短睡眠时间
　 public void addTask(TaskEntry taskEntry){
　　 taskList.add(taskEntry);
　　 taskEntry.setTimeLastDone(System.currentTimeMillis());
　　 if (sleeptime>taskEntry.getTimeInterval())
　　 sleeptime=taskEntry.getTimeInterval();
　 }
　 //执行任务调度
　 public void schedulePermorm(){
　　 try{
　　　 sleep(sleeptime);
　　　 Enumeration e = taskList.elements();
　　　 while (e.hasMoreElements()) {
　　　　 TaskEntry te = (TaskEntry) e.nextElement();
　　　　 if (te.getTimeInterval() + te.getTimeLastDone() <
　　　　　　　　 System.currentTimeMillis()) {
　　　　　 te.getTask().taskPerform();
　　　　　 te.setTimeLastDone(System.currentTimeMillis());
　　　　　 }
　　　 }
　　 }catch (Exception e1){
　　　 e1.printStackTrace();
　　 }
　 }
　 public static void main (String args[]){
　　 TaskSchedule schedule=new TaskSchedule();
　　 TaskEntry taks1=new TaskEntry(new ScanDiskTask(),10000);
　　 TaskEntry taks2=new TaskEntry(new BackupTask(),3000);
　　 schedule.addTask(taks1);
　　 schedule.addTask(taks2);
　　 while (true){
　　　　 schedule.schedulePermorm();
　　　 }
　 }
}