简要说明：有时候接口设计出于性能考虑，会出现你提交一个请求，但是他不会同步返回结果，他会通过另外一个渠道来告诉你这个请求的结果，这样的话就需要客户端去维护这个请求，但是程序开发的时候，是需要知道这个请求的结果才能执行下一步的，最近做了一下类似的功能，简单的写个DEMO总结一下。
netty就是一个NIO的框架，就用这个来做演示了
服务器端的代码很简单，接到请求以后 开启一个线程，过几秒以后在返回这条数据的结果
这里简单约定了一下数据的格式 “messageId|messageBody”， 其中messageId就是客户端用来维护这个请求的，
@Override
public void channelRead0(ChannelHandlerContext ctx, String request) throws Exception {
System.out.println("接受到消息:"+request);
Thread demoThread = new Thread(()->{
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// String messageId = request.split("|")[0];
// ctx.channel().writeAndFlush(messageId+"|resp\r\n");
ctx.channel().writeAndFlush(request+" 回复\r\n");
});
demoThread.start();
}
客户端东西比较多，有几个组件
ConnectPool 用来维护Netty的链接，方便程序在handel以外的地方发送信息，里面有两个变量
public class ConnectPool {
/**
* 缓存链接
*/
private static Map<String, ChannelFuture> CONNECT_POOL = new ConcurrentHashMap<>();
/**
* 缓存消息对象
*/
private static Map<String, SyncMessage> MESSAGE_CACHE = new ConcurrentHashMap<>();
public static void addConnect(String host,ChannelFuture channelFuture){
CONNECT_POOL.put(host,channelFuture);
}
public static ChannelFuture getConnect(String host){
return CONNECT_POOL.get(host);
}
public static void addMessage(SyncMessage message){
MESSAGE_CACHE.put(message.getMessageId(),message);
}
public static SyncMessage getMessage(String messageId){
return MESSAGE_CACHE.get(messageId);
}
public static SyncMessage removeMessage(String messageId){
return MESSAGE_CACHE.remove(messageId);
}
}
SyncMessage，封装的消息对象，其中CountDownLatch 用来做同步控制（也可以使用其他具有相同功能的类，这里看个人喜欢），createReqMessage封装了一下消息发送的格式（\r\n这里是nettyDecode的结束符）
public class SyncMessage {
private String messageId;
private String req;
private String resp;
private CountDownLatch countDownLatch = new CountDownLatch(1);
public String getMessageId() {
return messageId;
}
public void setMessageId(String messageId) {
this.messageId = messageId;
}
public String getReq() {
return req;
}
public void setReq(String req) {
this.req = req;
}
public String getResp() {
return resp;
}
public void setResp(String resp) {
this.resp = resp;
}
public CountDownLatch getCountDownLatch() {
return countDownLatch;
}
public String createReqMessage(){
return messageId+"|"+req+"\r\n";
}
}
SyncMessageSender，封装了发送数据的功能，即封装了发送的数据格式与消息ID，消息ID对外不可见，其他一些注意事项见注释
public class SyncMessageSender {
public static String sendMessage(String host,String message){
ChannelFuture connect = ConnectPool.getConnect(host);
if(connect == null){
throw new RuntimeException("为链接");
}
String messageId = UUID.randomUUID().toString();
SyncMessage syncMessage = new SyncMessage();
syncMessage.setMessageId(messageId);
syncMessage.setReq(message);
String messageReq = syncMessage.createReqMessage();
//添加缓存
ConnectPool.addMessage(syncMessage);
connect.channel().writeAndFlush(messageReq);
try {
//这里一定要加上超时时间，不然会发生线程无法释放的情况
syncMessage.getCountDownLatch().await(10, TimeUnit.SECONDS);
return syncMessage.getResp();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//根据情况清理加入的缓存，建议加入缓存和删除缓存在同一个方法体内
//如果不清理，会引起OOM
ConnectPool.removeMessage(messageId);
}
return null;
}
}
客户端的Handler 就是读取消息，返回结果，并且出来同步控制
@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
System.out.println(msg);
String[] split = msg.split("\\|");
SyncMessage message = ConnectPool.getMessage(split[0]);
if(message == null){
return;
}
message.setResp(split[1]);
message.getCountDownLatch().countDown();
}
运行服务端，客户端后查看一下运行结果
总结：这种模式需要客户端去维护这个请求，其实就是用一种基于内存的组件去控制服务中的请求，需要服务器和客户端约定好数据格式，并且定义好消息ID，当然这种模式也不是仅仅适用于netty,任何需要异步转同步的方法都可以使用，这篇文章只是总结一下，抛砖引玉；
demo地址：demo/NettySyncDemo at master · MaHanZhen/demo (github.com)
