Netty私有協議棧開發

幾個基本功能描述
消息協議定義，消息編解碼，連接認證，鏈路有效性校驗機制，鏈路的斷開重連機制。
主要設計
消息協議設計：消息頭+消息體。消息頭定義了基本協議字段定義，添加attachment方便擴展。Object編解碼使用Marshaller。
鏈路交互設計：鏈路什麼時候建立，什麼時候關閉，握手請求與相應。
可靠性設計：心跳檢查機制，重連機制，重複登錄保護，消息緩存重發。
安全性設計：本章使用基於ip地址的白名單安全認證機制。
可擴展性設計：添加attachment方便擴展。
順便給大家推薦一個Java技術交流羣：473984645裏面會分享一些資深架構師錄製的視頻資料：有Spring，MyBatis，Netty源碼分析，高併發、高性能、分佈式、微服務架構的原理，JVM性能優化、分佈式架構等這些成爲架構師必備的知識體系。還能領取免費的學習資源，目前受益良多！
具體實現
編解碼
編碼
編碼類繼承MessageToByteEncoder，然後編碼類重寫了encode方法，把具體的消息存放到ByteBuf中就可以了。
解碼
解碼類繼承LengthFieldBasedFrameDecoder：可以根據消息的長度進行拆包，自動的TCP粘包、半包處理。然後解碼類重寫decode方法進行解析即可。
如上編解碼中使用Marshaller對Object對象編解碼。
握手與安全認證
TCP建立連接之後，客戶端發起握手，服務端進行驗證，
客戶端LoginAuthReqHandler
重寫了channelActive方法，發送登錄請求。

  @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
    ctx.writeAndFlush(buildLoginReq());
    }
    private NettyMessage buildLoginReq() {
    NettyMessage message = new NettyMessage();
    Header header = new Header();
    header.setType(MessageType.LOGIN_REQ.value());
    message.setHeader(header);
    return message;
    }

重寫了channelRead方法

@Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
        throws Exception {
    NettyMessage message = (NettyMessage) msg;
    // 如果是握手應答消息，需要判斷是否認證成功
    if (message.getHeader() != null
        && message.getHeader().getType() == MessageType.LOGIN_RESP
            .value()) {
        byte loginResult = (byte) message.getBody();
        if (loginResult != (byte) 0) {
        // 握手失敗，關閉連接
        ctx.close();
        } else {
        System.out.println("Login is ok : " + message);
        ctx.fireChannelRead(msg);
        }
    } else
        ctx.fireChannelRead(msg);
    }

服務端LoginAuthRespHandler

@Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
        throws Exception {
    NettyMessage message = (NettyMessage) msg;
    // 如果是握手請求消息，處理，其它消息透傳
    if (message.getHeader() != null
        && message.getHeader().getType() == MessageType.LOGIN_REQ
            .value()) {
        String nodeIndex = ctx.channel().remoteAddress().toString();
        NettyMessage loginResp = null;
        // 重複登陸，拒絕
        if (nodeCheck.containsKey(nodeIndex)) {
        loginResp = buildResponse((byte) -1);
        } else {
        InetSocketAddress address = (InetSocketAddress) ctx.channel()
            .remoteAddress();
        String ip = address.getAddress().getHostAddress();
        boolean isOK = false;
        for (String WIP : whitekList) {
            if (WIP.equals(ip)) {
            isOK = true;
            break;
            }
        }
        loginResp = isOK ? buildResponse((byte) 0)
            : buildResponse((byte) -1);
        if (isOK)
            nodeCheck.put(nodeIndex, true);
        }
        System.out.println("The login response is : " + loginResp
            + " body [" + loginResp.getBody() + "]");
        ctx.writeAndFlush(loginResp);
    } else {
        ctx.fireChannelRead(msg);
    }
    }
    private NettyMessage buildResponse(byte result) {
    NettyMessage message = new NettyMessage();
    Header header = new Header();
    header.setType(MessageType.LOGIN_RESP.value());
    message.setHeader(header);
    message.setBody(result);
    return message;
    }

心跳檢查機制
客戶端發起心跳，服務端檢查心跳
客戶端檢查到握手應答消息，啓動心跳檢查task，每5秒發送一個heartbeat請求。
客戶端HeartBeatReqHandler

@Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
        throws Exception {
    NettyMessage message = (NettyMessage) msg;
    // 握手成功，主動發送心跳消息
    if (message.getHeader() != null
        && message.getHeader().getType() == MessageType.LOGIN_RESP
            .value()) {
        heartBeat = ctx.executor().scheduleAtFixedRate(
            new HeartBeatTask(ctx), 0, 5000,
            TimeUnit.MILLISECONDS);
    } else if (message.getHeader() != null
        && message.getHeader().getType() == MessageType.HEARTBEAT_RESP
            .value()) {
        System.out
            .println("Client receive server heart beat message : ---> "
                + message);
    } else
        ctx.fireChannelRead(msg);
    }
private class HeartBeatTask implements Runnable {
   private final ChannelHandlerContext ctx;
    public HeartBeatTask(final ChannelHandlerContext ctx) {
        this.ctx = ctx;
    }
    @Override
    public void run() {
        NettyMessage heatBeat = buildHeatBeat();
        System.out
            .println("Client send heart beat messsage to server : ---> "
                + heatBeat);
        ctx.writeAndFlush(heatBeat);
}
}

服務端：HeartBeatRespHandler

@Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
        throws Exception {
    NettyMessage message = (NettyMessage) msg;
    // 返回心跳應答消息
    if (message.getHeader() != null
        && message.getHeader().getType() == MessageType.HEARTBEAT_REQ
            .value()) {
        System.out.println("Receive client heart beat message : ---> "
            + message);
        NettyMessage heartBeat = buildHeatBeat();
        System.out
            .println("Send heart beat response message to client : ---> "
                + heartBeat);
        ctx.writeAndFlush(heartBeat);
    } else
        ctx.fireChannelRead(msg);
    }
    private NettyMessage buildHeatBeat() {
    NettyMessage message = new NettyMessage();
    Header header = new Header();
    header.setType(MessageType.HEARTBEAT_RESP.value());
    message.setHeader(header);
    return message;
    }

斷開重連
客戶端斷開之後，重寫啓動連接。

public void connect(int port, String host) throws Exception {
    // 配置客戶端NIO線程組
    try {
        Bootstrap b = new Bootstrap();
        b.group(group).channel(NioSocketChannel.class)
            .option(ChannelOption.TCP_NODELAY, true)
            .handler(new ChannelInitializer<SocketChannel>() {
            @Override
            public void initChannel(SocketChannel ch)
                throws Exception {
                ch.pipeline().addLast(
                    new NettyMessageDecoder(1024 * 1024, 4, 4));
                ch.pipeline().addLast("MessageEncoder",
                    new NettyMessageEncoder());
                ch.pipeline().addLast("readTimeoutHandler",
                    new ReadTimeoutHandler(50));
                ch.pipeline().addLast("LoginAuthHandler",
                    new LoginAuthReqHandler());
                ch.pipeline().addLast("HeartBeatHandler",
                    new HeartBeatReqHandler());
            }
            });
        // 發起異步連接操作
        ChannelFuture future = b.connect(
            new InetSocketAddress(host, port),
            new InetSocketAddress(NettyConstant.LOCALIP,
                NettyConstant.LOCAL_PORT)).sync();
        future.channel().closeFuture().sync();
    } finally {
        // 所有資源釋放完成之後，清空資源，再次發起重連操作
        executor.execute(new Runnable() {
        @Override
        public void run() {
            try {
            TimeUnit.SECONDS.sleep(1);
            try {
                connect(NettyConstant.PORT, NettyConstant.REMOTEIP);// 發起重連操作
     *斜體樣式*       } catch (Exception e) {
                e.printStackTrace();
            }
            } catch (InterruptedException e) {
            e.printStackTrace();
            }
        }
        });
    }
    }

鏈路有效性檢測
實現了一個ReadTimeoutHandler，記錄每次有數據讀的時間lastReadTime，啓動一個超時task定期檢測，如果在制定時間內沒有讀事件，則連接拋出讀超時異常。
主要成員變量

   private final long timeoutMillis; //判定超時時間
    private volatile ScheduledFuture<?> timeout; //task
    private volatile long lastReadTime;//最近讀操作的時間
    private volatile int state; // 0 - none, 1 - Initialized, 2 - Destroyed; 連接狀態
    private boolean closed;//是否已關閉

在handlerAdded，channelRegistered，channelActive初始化

private void initialize(ChannelHandlerContext ctx) {
        // Avoid the case where destroy() is called before scheduling timeouts.
        // See: https://github.com/netty/netty/issues/143
        switch (state) {
        case 1:
        case 2:
            return;
        }
        state = 1;
        lastReadTime = System.currentTimeMillis();
        if (timeoutMillis > 0) {
            timeout = ctx.executor().schedule(
                    new ReadTimeoutTask(ctx),
                    timeoutMillis, TimeUnit.MILLISECONDS);
        }
    }

ReadTimeoutTask

private final class ReadTimeoutTask implements Runnable {
        private final ChannelHandlerContext ctx;
        ReadTimeoutTask(ChannelHandlerContext ctx) {
            this.ctx = ctx;
        }
        @Override
        public void run() {
            if (!ctx.channel().isOpen()) {
                return;
            }
            long currentTime = System.currentTimeMillis();
            long nextDelay = timeoutMillis - (currentTime - lastReadTime);
            if (nextDelay <= 0) {
                // Read timed out - set a new timeout and notify the callback.
                timeout = ctx.executor().schedule(this, timeoutMillis, TimeUnit.MILLISECONDS);
                try {
                    readTimedOut(ctx);
                } catch (Throwable t) {
                    ctx.fireExceptionCaught(t);
                }
            } else {
                // Read occurred before the timeout - set a new timeout with shorter delay.
                timeout = ctx.executor().schedule(this, nextDelay, TimeUnit.MILLISECONDS);
            }
        }
    }

readTimedOut

 protected void readTimedOut(ChannelHandlerContext ctx) throws Exception {
        if (!closed) {
            ctx.fireExceptionCaught(ReadTimeoutException.INSTANCE);
            ctx.close();
            closed = true;
        }
    }

感謝您的閱讀。對文章如有疑問，歡迎提出。望分享的內容對大家有所幫助。蒐集整理了一些Java資料，包括Java進階學習路線以及對應學習資料，還有一些大廠面試題，需要的朋友可以自行領取：Java高級架構學習資料分享+架構師成長之路
順便給大家推薦一個Java技術交流羣：473984645裏面會分享一些資深架構師錄製的視頻資料：有Spring，MyBatis，Netty源碼分析，高併發、高性能、分佈式、微服務架構的原理，JVM性能優化、分佈式架構等這些成爲架構師必備的知識體系。還能領取免費的學習資源，目前受益良多！