netty 私有协议开发

最新推荐文章于 2024-09-28 16:23:38 发布
最新推荐文章于 2024-09-28 16:23:38 发布
阅读量2.9k 收藏 1
点赞数
分类专栏： nio 文章标签： netty私有协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1211529911/article/details/51899561
版权

以下代码仅仅是demo。不适用于正式环境

消息的定义

public class NettyMessage {

    private Header header;

    private String data;

    public Header getHeader() {
        return header;
    }

    public void setHeader(Header header) {
        this.header = header;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "NettyMessage{" +
                "header=" + header +
                ", data='" + data + '\'' +
                '}';
    }
}

public class Header {

    private int length;
    private int type;
    private int mainVersion;
    private int subVersion;

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public int getMainVersion() {
        return mainVersion;
    }

    public void setMainVersion(int mainVersion) {
        this.mainVersion = mainVersion;
    }

    public int getSubVersion() {
        return subVersion;
    }

    public void setSubVersion(int subVersion) {
        this.subVersion = subVersion;
    }

    @Override
    public String toString() {
        return "Header{" +
                "length=" + length +
                ", type=" + type +
                ", mainVersion=" + mainVersion +
                ", subVersion=" + subVersion +
                '}';
    }
}

public class MessageDecode extends MessageToMessageDecoder<ByteBuf> {

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
        int length = msg.readInt();
        int type = msg.readInt();
        int mainVersion = msg.readInt();
        int subVersion = msg.readInt();
        int dataLength = msg.readInt();
        byte[] data =new byte[dataLength];
        msg.readBytes(data);
        String strData = new String(data, Charset.forName("UTF-8"));
        NettyMessage nettyMessage =  new NettyMessage();
        Header header = new Header();
        nettyMessage.setHeader(header);
        nettyMessage.setData(strData);
        header.setLength(length);
        header.setMainVersion(mainVersion);
        header.setSubVersion(subVersion);
        header.setType(type);
    }
}

public class MessageEncode extends MessageToByteEncoder<NettyMessage> {

    @Override
    protected void encode(ChannelHandlerContext ctx, NettyMessage msg, ByteBuf out) throws Exception {
        ByteBuf sendBuffer = Unpooled.buffer(); //  
        final Header header = msg.getHeader();
        sendBuffer.writeInt(header.getLength());
        sendBuffer.writeInt(header.getType());
        sendBuffer.writeInt(header.getMainVersion());
        sendBuffer.writeInt(header.getSubVersion());
        sendBuffer.writeInt(msg.getData().getBytes().length);
        sendBuffer.writeBytes(msg.getData().getBytes());
        out.writeInt(sendBuffer.readableBytes()); 
        out.writeBytes(sendBuffer);
        ctx.flush();
    }


}

public class MainServer {

    static class ServerHandler extends SimpleChannelInboundHandler<NettyMessage> {
        @Override
        protected void messageReceived(ChannelHandlerContext ctx, NettyMessage msg) throws Exception {
            System.out.println(msg);
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            cause.printStackTrace();
        }
    }

    public static void main(String[] args) {
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup workers = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(boss, workers)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer<Channel>() {
                        @Override
                        protected void initChannel(Channel ch) throws Exception {
                            ChannelPipeline cpl = ch.pipeline();
                            cpl.addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4, 0, 4));
                            cpl.addLast(new MessageDecode());
                            cpl.addLast(new MessageEncode());
                            cpl.addLast(new ServerHandler());

                        }
                    });
            ChannelFuture channelFuture = serverBootstrap.bind("localhost", 9999).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            boss.shutdownGracefully();
            workers.shutdownGracefully();
        }
    }
}

public class MainClient {


    static class ClientServer extends SimpleChannelInboundHandler<ByteBuf> {

        @Override
        protected void messageReceived(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
            byte[] buffer = new byte[msg.readableBytes()];
            msg.readBytes(buffer);
            System.out.println("客户端收到消息：" + new String(buffer, Charset.forName("UTF-8")));
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            cause.printStackTrace();
        }

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            for (int i = 1; i < 100; i++) {
                NettyMessage nettyMessage = new NettyMessage();
                nettyMessage.setData("你好,现在是第：" + i + "次");
                Header header = new Header();
                header.setType(i);
                header.setLength(20);
                header.setMainVersion(1);
                header.setSubVersion(1);
                nettyMessage.setHeader(header);
                ctx.writeAndFlush(nettyMessage);
            }
        }
    }

    public static void main(String[] args) {
        EventLoopGroup workers = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        try {
            bootstrap.group(workers)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<Channel>() {
                        @Override
                        protected void initChannel(Channel ch) throws Exception {
                            ChannelPipeline channelPipeline = ch.pipeline();
                            /**
                             *
                             * 1024: 消息的最大长度
                             *  0： 长度的起始偏移量
                             *  4： 长度属性占的字节数
                             *  0： 长度调节值，在总长被定义为包含包头长度时，修正信息长度
                             *  4： 跳过的字节数，根据需要我们跳过前4个字节，以便接收端直接接受到不含“长度属性
                             *
                             */
                            channelPipeline.addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4, 0, 4));
                            channelPipeline.addLast(new MessageDecode());
                            channelPipeline.addLast(new MessageEncode());
                            channelPipeline.addLast(new ClientServer());
                        }
                    });

            ChannelFuture channelFuture = bootstrap.connect("localhost", 9999).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workers.shutdownGracefully();
        }

    }

}


服务端输出：

NettyMessage{header=Header{length=20, type=1, mainVersion=1, subVersion=1}, data='你好,现在是第：1次'}
NettyMessage{header=Header{length=20, type=2, mainVersion=1, subVersion=1}, data='你好,现在是第：2次'}
NettyMessage{header=Header{length=20, type=3, mainVersion=1, subVersion=1}, data='你好,现在是第：3次'}
NettyMessage{header=Header{length=20, type=4, mainVersion=1, subVersion=1}, data='你好,现在是第：4次'}
NettyMessage{header=Header{length=20, type=5, mainVersion=1, subVersion=1}, data='你好,现在是第：5次'}
NettyMessage{header=Header{length=20, type=6, mainVersion=1, subVersion=1}, data='你好,现在是第：6次'}
NettyMessage{header=Header{length=20, type=7, mainVersion=1, subVersion=1}, data='你好,现在是第：7次'}
NettyMessage{header=Header{length=20, type=8, mainVersion=1, subVersion=1}, data='你好,现在是第：8次'}
NettyMessage{header=Header{length=20, type=9, mainVersion=1, subVersion=1}, data='你好,现在是第：9次'}
NettyMessage{header=Header{length=20, type=10, mainVersion=1, subVersion=1}, data='你好,现在是第：10次'}
NettyMessage{header=Header{length=20, type=11, mainVersion=1, subVersion=1}, data='你好,现在是第：11次'}
NettyMessage{header=Header{length=20, type=12, mainVersion=1, subVersion=1}, data='你好,现在是第：12次'}
NettyMessage{header=Header{length=20, type=13, mainVersion=1, subVersion=1}, data='你好,现在是第：13次'}
NettyMessage{header=Header{length=20, type=14, mainVersion=1, subVersion=1}, data='你好,现在是第：14次'}
NettyMessage{header=Header{length=20, type=15, mainVersion=1, subVersion=1}, data='你好,现在是第：15次'}
NettyMessage{header=Header{length=20, type=16, mainVersion=1, subVersion=1}, data='你好,现在是第：16次'}
NettyMessage{header=Header{length=20, type=17, mainVersion=1, subVersion=1}, data='你好,现在是第：17次'}
NettyMessage{header=Header{length=20, type=18, mainVersion=1, subVersion=1}, data='你好,现在是第：18次'}
NettyMessage{header=Header{length=20, type=19, mainVersion=1, subVersion=1}, data='你好,现在是第：19次'}
NettyMessage{header=Header{length=20, type=20, mainVersion=1, subVersion=1}, data='你好,现在是第：20次'}
NettyMessage{header=Header{length=20, type=21, mainVersion=1, subVersion=1}, data='你好,现在是第：21次'}
NettyMessage{header=Header{length=20, type=22, mainVersion=1, subVersion=1}, data='你好,现在是第：22次'}
NettyMessage{header=Header{length=20, type=23, mainVersion=1, subVersion=1}, data='你好,现在是第：23次'}
NettyMessage{header=Header{length=20, type=24, mainVersion=1, subVersion=1}, data='你好,现在是第：24次'}
NettyMessage{header=Header{length=20, type=25, mainVersion=1, subVersion=1}, data='你好,现在是第：25次'}
NettyMessage{header=Header{length=20, type=26, mainVersion=1, subVersion=1}, data='你好,现在是第：26次'}
NettyMessage{header=Header{length=20, type=27, mainVersion=1, subVersion=1}, data='你好,现在是第：27次'}
NettyMessage{header=Header{length=20, type=28, mainVersion=1, subVersion=1}, data='你好,现在是第：28次'}
NettyMessage{header=Header{length=20, type=29, mainVersion=1, subVersion=1}, data='你好,现在是第：29次'}
NettyMessage{header=Header{length=20, type=30, mainVersion=1, subVersion=1}, data='你好,现在是第：30次'}
NettyMessage{header=Header{length=20, type=31, mainVersion=1, subVersion=1}, data='你好,现在是第：31次'}
NettyMessage{header=Header{length=20, type=32, mainVersion=1, subVersion=1}, data='你好,现在是第：32次'}
NettyMessage{header=Header{length=20, type=33, mainVersion=1, subVersion=1}, data='你好,现在是第：33次'}
NettyMessage{header=Header{length=20, type=34, mainVersion=1, subVersion=1}, data='你好,现在是第：34次'}
NettyMessage{header=Header{length=20, type=35, mainVersion=1, subVersion=1}, data='你好,现在是第：35次'}
NettyMessage{header=Header{length=20, type=36, mainVersion=1, subVersion=1}, data='你好,现在是第：36次'}
NettyMessage{header=Header{length=20, type=37, mainVersion=1, subVersion=1}, data='你好,现在是第：37次'}
NettyMessage{header=Header{length=20, type=38, mainVersion=1, subVersion=1}, data='你好,现在是第：38次'}
NettyMessage{header=Header{length=20, type=39, mainVersion=1, subVersion=1}, data='你好,现在是第：39次'}
NettyMessage{header=Header{length=20, type=40, mainVersion=1, subVersion=1}, data='你好,现在是第：40次'}
NettyMessage{header=Header{length=20, type=41, mainVersion=1, subVersion=1}, data='你好,现在是第：41次'}
NettyMessage{header=Header{length=20, type=42, mainVersion=1, subVersion=1}, data='你好,现在是第：42次'}
NettyMessage{header=Header{length=20, type=43, mainVersion=1, subVersion=1}, data='你好,现在是第：43次'}
NettyMessage{header=Header{length=20, type=44, mainVersion=1, subVersion=1}, data='你好,现在是第：44次'}
NettyMessage{header=Header{length=20, type=45, mainVersion=1, subVersion=1}, data='你好,现在是第：45次'}
NettyMessage{header=Header{length=20, type=46, mainVersion=1, subVersion=1}, data='你好,现在是第：46次'}
NettyMessage{header=Header{length=20, type=47, mainVersion=1, subVersion=1}, data='你好,现在是第：47次'}
NettyMessage{header=Header{length=20, type=48, mainVersion=1, subVersion=1}, data='你好,现在是第：48次'}
NettyMessage{header=Header{length=20, type=49, mainVersion=1, subVersion=1}, data='你好,现在是第：49次'}
NettyMessage{header=Header{length=20, type=50, mainVersion=1, subVersion=1}, data='你好,现在是第：50次'}
NettyMessage{header=Header{length=20, type=51, mainVersion=1, subVersion=1}, data='你好,现在是第：51次'}
NettyMessage{header=Header{length=20, type=52, mainVersion=1, subVersion=1}, data='你好,现在是第：52次'}
NettyMessage{header=Header{length=20, type=53, mainVersion=1, subVersion=1}, data='你好,现在是第：53次'}
NettyMessage{header=Header{length=20, type=54, mainVersion=1, subVersion=1}, data='你好,现在是第：54次'}
NettyMessage{header=Header{length=20, type=55, mainVersion=1, subVersion=1}, data='你好,现在是第：55次'}
NettyMessage{header=Header{length=20, type=56, mainVersion=1, subVersion=1}, data='你好,现在是第：56次'}
NettyMessage{header=Header{length=20, type=57, mainVersion=1, subVersion=1}, data='你好,现在是第：57次'}
NettyMessage{header=Header{length=20, type=58, mainVersion=1, subVersion=1}, data='你好,现在是第：58次'}
NettyMessage{header=Header{length=20, type=59, mainVersion=1, subVersion=1}, data='你好,现在是第：59次'}
NettyMessage{header=Header{length=20, type=60, mainVersion=1, subVersion=1}, data='你好,现在是第：60次'}
NettyMessage{header=Header{length=20, type=61, mainVersion=1, subVersion=1}, data='你好,现在是第：61次'}
NettyMessage{header=Header{length=20, type=62, mainVersion=1, subVersion=1}, data='你好,现在是第：62次'}
NettyMessage{header=Header{length=20, type=63, mainVersion=1, subVersion=1}, data='你好,现在是第：63次'}
NettyMessage{header=Header{length=20, type=64, mainVersion=1, subVersion=1}, data='你好,现在是第：64次'}
NettyMessage{header=Header{length=20, type=65, mainVersion=1, subVersion=1}, data='你好,现在是第：65次'}
NettyMessage{header=Header{length=20, type=66, mainVersion=1, subVersion=1}, data='你好,现在是第：66次'}
NettyMessage{header=Header{length=20, type=67, mainVersion=1, subVersion=1}, data='你好,现在是第：67次'}
NettyMessage{header=Header{length=20, type=68, mainVersion=1, subVersion=1}, data='你好,现在是第：68次'}
NettyMessage{header=Header{length=20, type=69, mainVersion=1, subVersion=1}, data='你好,现在是第：69次'}
NettyMessage{header=Header{length=20, type=70, mainVersion=1, subVersion=1}, data='你好,现在是第：70次'}
NettyMessage{header=Header{length=20, type=71, mainVersion=1, subVersion=1}, data='你好,现在是第：71次'}
NettyMessage{header=Header{length=20, type=72, mainVersion=1, subVersion=1}, data='你好,现在是第：72次'}
NettyMessage{header=Header{length=20, type=73, mainVersion=1, subVersion=1}, data='你好,现在是第：73次'}
NettyMessage{header=Header{length=20, type=74, mainVersion=1, subVersion=1}, data='你好,现在是第：74次'}
NettyMessage{header=Header{length=20, type=75, mainVersion=1, subVersion=1}, data='你好,现在是第：75次'}
NettyMessage{header=Header{length=20, type=76, mainVersion=1, subVersion=1}, data='你好,现在是第：76次'}
NettyMessage{header=Header{length=20, type=77, mainVersion=1, subVersion=1}, data='你好,现在是第：77次'}
NettyMessage{header=Header{length=20, type=78, mainVersion=1, subVersion=1}, data='你好,现在是第：78次'}
NettyMessage{header=Header{length=20, type=79, mainVersion=1, subVersion=1}, data='你好,现在是第：79次'}
NettyMessage{header=Header{length=20, type=80, mainVersion=1, subVersion=1}, data='你好,现在是第：80次'}
NettyMessage{header=Header{length=20, type=81, mainVersion=1, subVersion=1}, data='你好,现在是第：81次'}
NettyMessage{header=Header{length=20, type=82, mainVersion=1, subVersion=1}, data='你好,现在是第：82次'}
NettyMessage{header=Header{length=20, type=83, mainVersion=1, subVersion=1}, data='你好,现在是第：83次'}
NettyMessage{header=Header{length=20, type=84, mainVersion=1, subVersion=1}, data='你好,现在是第：84次'}
NettyMessage{header=Header{length=20, type=85, mainVersion=1, subVersion=1}, data='你好,现在是第：85次'}
NettyMessage{header=Header{length=20, type=86, mainVersion=1, subVersion=1}, data='你好,现在是第：86次'}
NettyMessage{header=Header{length=20, type=87, mainVersion=1, subVersion=1}, data='你好,现在是第：87次'}
NettyMessage{header=Header{length=20, type=88, mainVersion=1, subVersion=1}, data='你好,现在是第：88次'}
NettyMessage{header=Header{length=20, type=89, mainVersion=1, subVersion=1}, data='你好,现在是第：89次'}
NettyMessage{header=Header{length=20, type=90, mainVersion=1, subVersion=1}, data='你好,现在是第：90次'}
NettyMessage{header=Header{length=20, type=91, mainVersion=1, subVersion=1}, data='你好,现在是第：91次'}
NettyMessage{header=Header{length=20, type=92, mainVersion=1, subVersion=1}, data='你好,现在是第：92次'}
NettyMessage{header=Header{length=20, type=93, mainVersion=1, subVersion=1}, data='你好,现在是第：93次'}
NettyMessage{header=Header{length=20, type=94, mainVersion=1, subVersion=1}, data='你好,现在是第：94次'}
NettyMessage{header=Header{length=20, type=95, mainVersion=1, subVersion=1}, data='你好,现在是第：95次'}
NettyMessage{header=Header{length=20, type=96, mainVersion=1, subVersion=1}, data='你好,现在是第：96次'}
NettyMessage{header=Header{length=20, type=97, mainVersion=1, subVersion=1}, data='你好,现在是第：97次'}
NettyMessage{header=Header{length=20, type=98, mainVersion=1, subVersion=1}, data='你好,现在是第：98次'}
NettyMessage{header=Header{length=20, type=99, mainVersion=1, subVersion=1}, data='你好,现在是第：99次'}







ssjiyi
关注
专栏目录
Netty从入门到精通五——私有协议栈开发
qq_44244993的博客
10-23 302
在链路中断INTERVAL时间后，由客户端发起重连操作，若失败则在INTERVAL时间后再次发起重连，因为需要保证服务端在这段时间内充分释放句柄资源，等待下次重连。Ping-Pong是双向机制，可以保证双方无论谁出现故障都可被及时检测，当消息读写发生IO异常后，就代表链路中断，需要关闭链路释放资源，重连或等待重连。，链路建立成功后客户端会主动发送握手消息，服务端收到握手消息后若通过IP校验，会返回应答消息给客户端。：链路空闲时，客户端主动发Ping消息给服务端，服务端接收到消息后回复Pong消息给客户端；
netty权威指南中的私有协议栈开发demo
10-25
理解如何分配、读写、复制和释放 ByteBuf 是私有协议开发的基础。 3. **ChannelHandler**：Netty 的 ChannelHandler 是处理 I/O 事件的核心组件，你可以定义多个 ChannelHandler 来分别处理读取、写入、连接、断开...
《netty权威指南》私有协议栈开发完整实例源码
03-15
《netty权威指南》中私有协议栈开发章节对netty理解和入门很有帮助，但书中代码有各种无法编译的问题，自己各种查漏补缺后完善了书中的实例，完全可以运行调试了，有兴趣可以下载看看试试,下载后可直接导入myeclipse 我的调试环境（可供参考）：MyEclipse6.5.0，jdk1.7.0_8
私有协议栈开发
weixin_33755649的博客
12-16 805
通信协议从广义上区分，可以分为公有协议和私有协议。由于私有协议的灵活性，它往往会在某个公司或者组织内部使用，按需定制，也因为如此，升级起来会非常方便，灵活性好。绝大多数的私有协议传输层都基于TCP/IP，所以利用Netty的NIO TCP协议栈可以非常方便地进行私有协议的定制和开发。 私有协议介绍 私有协议本质上是厂商内部发展和采用的标准，除非授权，其他...
Netty入门
最新发布
我的博客
09-28 1203
【零拷贝】的体现之一，对原始 ByteBuf 进行切片成多个 ByteBuf，切片后的 ByteBuf 并没有发生内存复制，还是使用原始 ByteBuf 的内存，切片后的 ByteBuf 维护独立的 read，write 指针。netty 中的 Future 与 jdk 中的 Future 同名，但是是两个接口，netty 的 Future 继承自 jdk 的 Future，而 Promise 又对 netty Future 进行了扩展。connect 方法是异步的，意味着不等连接建立，方法执行就返回了。
Netty 私有协议栈
woaiwojialanxi的专栏
03-26 1197
私有协议介绍 由于现代软件的复杂性，一个大型软件系统往往会被人为地拆分称为多个模块，另外随着移动互联网的兴起，网站的规模越来越大，业务功能越来越多，往往需要集群和分布式部署。模块之间的通信就需要进行跨节点通信。传统的Java应用中节点通信的常用方式： rmi远程服务调用 Java Socket + Java序列化 RPC框架 Thrift、Apache的Avro等 利用标准的公有协议进行跨节点调用，例如HTTP+XML，Restful+JSON或WebService 下面使用Netty设计私有..
netty4&5私有协议开发
JFree_Wolf的博客
10-21 1014
私有协议在实际项目中是很长见的（至少作者的公司就是自己开发的，而不是用protobuf等第三方的）。 闲话不多说，你要自己开发私有协议，首先你的确定一下你和客户端交互的数据是以哪种数据结构定义的吧。例如我们把这个数据结构定义成 ...
Netty编程之基于Netty的私有协议设计与开发
LMR的博客
05-24 8713
通信协议从广义上来区分，可以分为公有协议和私有协议。由于私有协议的灵活性，它往往会在某个公司或者组织内部使用，按需定制，因因如此，升级起来会非常方便，灵活性较好。本博客基于《Netty 权威指南》，设计并实现私有协议。
netty-protocol:基于netty的一个私有协议栈
05-25
在本文中，我们将深入探讨如何基于 Netty 构建一个私有协议栈，以及在这个过程中可能涉及的关键知识点。 首先，理解 Netty 的核心概念至关重要。Netty 的设计围绕着 Channel、EventLoop 和 ByteBuf 这三大组件。...
Netty权威指南--私有协议栈功能实现
10-30
在本文中，我们将深入探讨如何利用 Netty 实现私有协议栈功能，包括编解码、登录权限验证以及心跳包的处理。 首先，让我们谈谈“编解码”。在通信过程中，数据通常需要在传输前进行编码，到达目的地后进行解码。...
netty-learning:netty-in-action是《 Netty实战》笔记。netty-private-protocol是一个基于Netty私有协议协议实现的
03-24
网络学习 @author 鲁伟林 向开源致敬，向优秀前辈代码致敬。 Netty中大量使用NIO技术，满足高性能、高并发要求。进行初步研究，特作此项目。...2私有协议开发（netty-private-protocol） netty-private-prot
netty自定义协议
07-15
netty实现自定义协议通信，形如： /** * socketHeader定义 40 + 4+ 100 +4 * 序列号 40bytes 不足前面补0 * 来源 4bytes * 指令 8bytes 不足前面补0 形如0001， 0000:心跳 * 长度 4bytes */ 心跳连接 运行 服务端：Bootstrap.java 客户端：SocketClient.java
Netty实现私有协议，模仿dubbo单一长连接RPC服务调用，心跳检测机制源码
03-09
1、客户端与服务端基于单一长连接进行通信，客户端一条连接被多个线程使用。 2、实现私有协议 请求协议 协议头：4字节的请求序列号 2字节的请求类型 2字节数据包长度 数据部分： 服务调用：2字节请求服务名长度 若干字节请求服务名 2字节请求参数长度 若干字节参数 心跳包：数据部分无 响应信息 协议头：4字节的请求序列号 2字节的执行状态码 2字节数据长度 数据部分： 多字节的响应数据信息(data) 3、代码基于Netty5
Netty协议
m0_64393446的博客
05-26 195
Netty 提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络 IO 程序,是目前最流行的 NIO 框架，Netty 在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的 Elasticsearch 、Dubbo 框架内部都采用了 Netty。③服务器端用一个线程通过多路复用搞定所有的 IO 操作（包括连接，读、写等），编码简单，清晰明了，但是如果客户端连接数量较多时，当对应多个读时，还是会出现阻塞现象，当这种情况发生时将无法支撑高并发的场景。
Netty私有协议栈设计
Coder_py的博客
05-01 465
Netty私有协议栈设计 消息定义 消息头 消息主体 图示: Header： public class Header { private int crcCode = 0xadaf0105; // 唯一的通信标志 private int length; // 总消息的长度 header + body private long sessionID; // ...
Netty的协议设计与解析
qq_46863837的博客
05-16 463
魔数，用来在第一时间判定是否是无效数据包，版本号，可以支持协议的升级序列化算法，消息正文到底采用哪种序列化反序列化方式，可以由此扩展，例如：json、protobuf、hessian、jdk指令类型，是登录、注册、单聊、群聊… 跟业务相关请求序号，为了双工通信，提供异步能力正文长度消息正文。
Netty之私有协议栈开发(四)
May121812345的博客
12-24 1337
2021SC@SDUSC
Netty协议设计与解析
安逸
05-05 1522
简单记录一下netty协议的编写和使用过程，方便后面查看。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值