java设计模式之命令
命令模式将请求封装成一系列对象，对象里包含指令和数据。
在分布式架构中，master需要给worker分发任务，worker完成后需要把任务处理结果返回给master。
master/worker之间的信息交互会有很多不同的指令和数据，这种不同消息的实现就可以采用命令模式。
我们首先定义一个命令对象
一、命令模式同步实现
public class Command implements Serializable,Cloneable { private static AtomicLong idGenerator=new AtomicLong(1L); private Long id; private String request; private String response; public Command( String content) { this.id = idGenerator.getAndIncrement(); this.request = content; } public String getResponse() { return response; } public void setResponse(String response) { this.response = response; } protected Command clone() { try { return (Command) super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return null; } @Override public String toString() { return "Command{" + "id=" + id + ", request='" + request + '\'' + ", response='" + response + '\'' + '}'; } }
然后定义一个master，master负责向worker发送命令
public class Master { void dispatch(Worker worker,Command command){ System.out.println("dispatch a command:"+command +"to "+worker.getClass().getSimpleName()); Command response = worker.process(command); System.out.println("receive a command"+response); } public static void main(String[] args) { Command command1 = new Command("hello,python!"); Command command2 = new Command("hello,java!"); Master master = new Master(); Worker worker1 = new Worker1(); Worker worker2 = new Worker2(); master.dispatch(worker1,command1); master.dispatch(worker2,command2); } }
定义一个worker接口，用于处理命令，并返回任务的结果
public interface Worker { Command process(Command command); } public class Worker1 implements Worker { @Override public Command process(Command command) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } Command clone = command.clone(); clone.setResponse("worker1 ok"); return clone; } } public class Worker2 implements Worker { @Override public Command process(Command command) { try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } Command clone = command.clone(); clone.setResponse("worker2 ok"); return clone; } }
执行master，输出：
dispatch a command:Command{id=1, request='hello,python!', response='null'}to Worker1
receive a commandCommand{id=1, request='hello,python!', response='worker1 ok'}
dispatch a command:Command{id=2, request='hello,java!', response='null'}to Worker2
receive a commandCommand{id=2, request='hello,java!', response='worker2 ok'}
二、命令模式异步实现
其实分布式系统中，更常见的实现是异步io,我们给Worker接口添加一个异步处理方法
public interface Worker { /** * 同步处理 * @param command * @return */ Command process(Command command); /** * 异步处理 * @param command */ void asyncProcess(Command command); }
定义一个实现了Worker接口的实现类
public class AsyncWorker implements Worker { @Override public Command process(Command command) { return null; } @Override public void asyncProcess(Command command){ try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } Command clone = command.clone(); Long id = clone.getId(); clone.setResponse("AsyncWorker ok"); ResponseFuture future = ResponseFuture.getFuture(id); future.putResponse(clone); } }
因为是异步处理，我们定义一个Future类
/** * 任务结果future类 */ public class ResponseFuture { private static final Map<Long,ResponseFuture> futures=new ConcurrentHashMap<>(256); private long requestId; private CountDownLatch latch=new CountDownLatch(1); private Command response; private final InvokeCallback invokeCallback; public ResponseFuture(long requestId, InvokeCallback invokeCallback) { this.requestId = requestId; this.invokeCallback = invokeCallback; futures.put(requestId, this); } public void executeInvokeCallback() { if (invokeCallback != null) { invokeCallback.operationComplete(this); } } public void putResponse(final Command responseCommand) { this.response = responseCommand; this.latch.countDown(); futures.remove(requestId); } public Command getResponseCommand() { return response; } public static ResponseFuture getFuture(long requestId) { return futures.get(requestId); } }
定义一个回调接口，用于获得结果后的回调
/** * 回调接口 */ public interface InvokeCallback { void operationComplete(final ResponseFuture responseFuture); }
因为需要异步获取结果，我们对command类进行了扩展
public class Command implements Serializable,Cloneable { private static AtomicLong idGenerator=new AtomicLong(1L); private Long id; private String request; private String response; public Command( String content) { this.id = idGenerator.getAndIncrement(); this.request = content; } public Long getId() { return id; } public String getResponse() { return response; } public void setResponse(String response) { this.response = response; } protected Command clone() { try { return (Command) super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return null; } @Override public String toString() { return "Command{" + "id=" + id + ", request='" + request + '\'' + ", response='" + response + '\'' + '}'; } }
master发生异步请求
public class Master { // void dispatch(Worker worker, Command command) { // System.out.println("dispatch a command:" + command + "to " + worker.getClass().getSimpleName()); // Command response = worker.process(command); // System.out.println("receive a command" + response); // } void dispatchAsync(Worker worker, Command command, final InvokeCallback invokeCallback) { System.out.println("dispatch a command:" + command + "to " + worker.getClass().getSimpleName()); Long requestId = command.getId(); ResponseFuture responseFuture = new ResponseFuture(requestId, invokeCallback); worker.asyncProcess(command); responseFuture.executeInvokeCallback(); } public static void main(String[] args) { Master master = new Master(); // Command command1 = new Command("hello,sync!"); // Worker worker1 = new SyncWorker(); // System.out.println("dispatch Sync"); // master.dispatch(worker1, command1); Command command2 = new Command("hello,async!"); Worker worker2 = new AsyncWorker(); System.out.println("dispatch ASync"); master.dispatchAsync(worker2, command2, new InvokeCallback() { @Override public void operationComplete(ResponseFuture responseFuture) { Command responseCommand = responseFuture.getResponseCommand(); System.out.println(responseCommand); } }); } }
输出：
dispatch ASync dispatch a command:Command{id=1, request='hello,async!', response='null'}to AsyncWorker Command{id=1, request='hello,async!', response='AsyncWorker ok'}
上面的实现是分布式架构的一种简化，以方便在单机进行演示。
实际的分布式架构中，master拿不到worker对象，worker也不可能拿到Future对象，异步消息的传递一般是基于异步io框架（比如netty）的channel来实现的。
netty不是我们本文讨论的重点，这里就不做更多的描述了。
