java异步转同步

简要说明：有时候接口设计出于性能考虑，会出现你提交一个请求，但是他不会同步返回结果，他会通过另外一个渠道来告诉你这个请求的结果，这样的话就需要客户端去维护这个请求，但是程序开发的时候，是需要知道这个请求的结果才能执行下一步的，最近做了一下类似的功能，简单的写个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 CONNECT_POOL = new ConcurrentHashMap<>();

    /**
     * 缓存消息对象
     */
    private static Map 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();
    }

运行服务端，客户端后查看一下运行结果

image.png

总结：这种模式需要客户端去维护这个请求，其实就是用一种基于内存的组件去控制服务中的请求，需要服务器和客户端约定好数据格式，并且定义好消息ID，当然这种模式也不是仅仅适用于netty,任何需要异步转同步的方法都可以使用，这篇文章只是总结一下，抛砖引玉；
demo地址：demo/NettySyncDemo at master · MaHanZhen/demo (github.com)