设计模式实例——基于命令模式的事件处理框架

在面向对象程序设计中，命令模式是一种很常用的模式。

定义：通常情况下，行为的发送者与接收者之间是一种紧耦合，命令模式就是将一组行为封装成对象，实现二者之间的松耦合。

角色定义：

Command：命令封装对象，可以在其中存储一些有关行为信息和数据。

Invoker：实际的命令发送者，它相当于一个调度中心。

Receiver：事件的接收者，也就是实际做事的那个对象。

Client：客户端，它创建出命令。

今天我们基于命令模式来做一个简单的事件处理模型。总体思路就是用一个队列去保存这些命令，然后有一个线程去检测这个队列，当这个队列中有命令时，则取出来实现它。

首先，我们新建一个Command的接口

public interface ICommand {
    void execute();
}

然后再定义一个Receiver，实际做工作的那个对象。这个类有两个行为，一个是上传文件，一个是获取网络数据。

public class HttpWorker extends Worker{
    public void uploadFile() {
        System.out.println("HttpWorker->uploadFile");
    }

    public void getNetworkData() {
        System.out.println("HttpWorker->getNetworkData");
    }
}

下来为这两个行为定义两个Command，及他们的父类，用来做一些相同的工作

public abstract class HttpCommand implements ICommand{
    protected HttpWorker httpWorker;
    public HttpCommand() {
        super();
        httpWorker = new HttpWorker();
    }
}

public class UploadFileCommand extends HttpCommand {
    @Override
    public void execute() {
        httpWorker.uploadFile();
    }
}

public class GetNetworkDataCommand extends HttpCommand {
    @Override
    public void execute() {
        httpWorker.getNetworkData();
    }
}

下来就是消息处理的核心——消息队列

public class EventWorker {
    private Queue<ICommand> commandQueue;
    private WorkerThread workerThread;
    private Object lock;

    public void start() {
        lock = new Object();
        commandQueue = new LinkedBlockingQueue<>();
        workerThread = new WorkerThread();
        workerThread.start();
    }
    public void add(ICommand command) {
        synchronized (commandQueue) {
            System.out.println("add a command");
            commandQueue.add(command);
            synchronized (lock) {
                lock.notify();
            }
        }

    }

    public void remove(ICommand command) {
        synchronized (commandQueue) {
            commandQueue.remove(command);
        }
    }

    public void stop() {
        workerThread.setStart(false);

        //在停止的时候，有可能工作线程在等待，所以要notify一下
        synchronized (lock) {
            lock.notify();
        }
        commandQueue.clear();
        commandQueue = null;
        workerThread = null;
        lock = null;
    }

    private class WorkerThread extends Thread {
        private boolean isStart = false;

        public void setStart(boolean b) {
            isStart = b;
        }
        @Override
        public synchronized void start() {
            isStart = true;
            super.start();
        }
        
        //这种写法会出现死锁，注意！！！
//        public void run() {
//            System.out.println("EventWorkerThread work!");
//            while(true) {
//                synchronized (commandQueue) {
//                if(!isStart) break;
//                    if(commandQueue.isEmpty()) {
//                        System.out.println("queue is empty->wait\n\n");
//                        synchronized (lock) {
//                            try {
//                                lock.wait();
//                            } catch (InterruptedException e) {
//                                e.printStackTrace();
//                            }
//                        }
//                    } else {
//
//                        ICommand c = commandQueue.poll();
//                        if(c != null) {
//                            c.execute();
//                        }
//                    }
//                }
//            }
//            System.out.println("EventWorkerThread stop!");
//        }
        
        public void run() {
            System.out.println("EventWorkerThread work!");
            while(true) {
                //如果停止循环则退出
                if(!isStart) break;

                //线程同步，先获取commandQueue的锁
                synchronized (commandQueue) {
                    //如果命令队列不为空，则取出顶部的消息
                    if(!commandQueue.isEmpty()) {
                        ICommand c = commandQueue.poll();
                        if(c != null) {
                            c.execute();
                        }
                        //继续循环
                        continue;
                    }
                }
                //如果队列为空，是进行等待
                synchronized (lock) {
                    try {
                        System.out.println("queue is empty->wait\n\n");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("EventWorkerThread stop!");
        }
    }
}

上面主要的代码都做了注释，大家都能看懂它的工作原理。就是做一个队列，然后有一个线程不停的去检测这个队列，如果有命令就执行，反之，等待。当添加一个命令时，则notify检测线程继续工作。

在多线程中，一定要注意线程的同步，否则会出现脏数据，还有就是锁的运用，不然会出现死锁等一些问题，而且这些问题都不容易查出来，所以在多个线程操作同一个数据时一定要加锁。

下来就是客户端对象，客户端是创建命令的地方。

public class Client {
    public static void main(String[] args) throws InterruptedException {
        EventWorker eventWorker = new EventWorker();
        eventWorker.start();
        ICommand uploadFileCommand = new UploadFileCommand();
        ICommand getNetworkDataCommand = new GetNetworkDataCommand();
        Thread.sleep(3000);
        for(int i = 0; i < 10; i++) {
            if(i % 2 == 0) {
                eventWorker.add(uploadFileCommand);
            } else {
                eventWorker.add(getNetworkDataCommand);
            }
            Thread.sleep(2000);
        }
        eventWorker.stop();
    }
}

好了，这个框架就算大概完成了，这只是一个很简单的例子，在实际工作中，可能要比这复杂的多。运用模式可以使我们的代码更加高效和可维护，但是也不要滥用模式，23种设计模式没有谁好谁坏，适合的才是最好的。