网络编程-Netty-03 Netty核心功能

已于 2022-03-13 14:31:23 修改
阅读量4.2k 收藏
点赞数
分类专栏： 网络编程 文章标签： 网络 java 开发语言
于 2022-02-24 00:55:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csfun1/article/details/123102739
版权

Netty实现编解码、粘包粘包、心跳检测、断线重连

1、ByteBuf详解

在这里插入图片描述


import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;

/**
 * cse中最常见使用的双指针队列
 */
public class ByteBufDemo {
    public static void main(String[] args) {
        // 创建byteBuf对象，该对象内部包含一个字节数组byte[10]
        // 通过readerindex和writerIndex和capacity，将buffer分成三个区域
        // 已经读取的区域：[0,readerindex)  可读取的区域：[readerindex,writerIndex)  可写的区域: [writerIndex,capacity)
        ByteBuf byteBuf = Unpooled.buffer(10);
        System.out.println("byteBuf=" + byteBuf);
        for (int i = 0; i < 8; i++) {
            byteBuf.writeByte(i);
        }
        System.out.println("byteBuf=" + byteBuf);
        for (int i = 0; i < 5; i++) {
            System.out.println(byteBuf.getByte(i));
        }
        System.out.println("byteBuf=" + byteBuf);
        for (int i = 0; i < 5; i++) {
            System.out.println(byteBuf.readByte());
        }
        System.out.println("byteBuf=" + byteBuf);
        //用Unpooled工具类创建ByteBuf
        ByteBuf byteBuf2 = Unpooled.copiedBuffer("hello,zhuge!", CharsetUtil.UTF_8);
        //使用相关的方法
        if (byteBuf2.hasArray()) {
            byte[] content = byteBuf2.array();
            //将 content 转成字符串
            System.out.println(new String(content, CharsetUtil.UTF_8));
            System.out.println("byteBuf=" + byteBuf2);
            System.out.println(byteBuf2.readerIndex()); // 0
            System.out.println(byteBuf2.writerIndex()); // 12
            System.out.println(byteBuf2.capacity()); // 36
            System.out.println(byteBuf2.getByte(0)); // 获取数组0这个位置的字符h的ascii码，h=104
            int len = byteBuf2.readableBytes(); //可读的字节数 12
            System.out.println("len=" + len);
            //使用for取出各个字节
            for (int i = 0; i < len; i++) {
                System.out.println((char) byteBuf2.getByte(i));
            }//范围读取
             System.out.println(byteBuf2.getCharSequence(0, 6, CharsetUtil.UTF_8));
            System.out.println(byteBuf2.getCharSequence(6, 6, CharsetUtil.UTF_8));
        }
    }
}

2、Netty编解码

在这里插入图片描述

import com.alibaba.fastjson.JSON;

/**
 * 文件传输时使用Json序列化
 */
public class JSONSerializer{
    public static byte[] serialize(Object object) {
        return JSON.toJSONBytes(object);
    }
    public static <T> T deserialize(Class<T> clazz, byte[] bytes) {
        return JSON.parseObject(bytes, clazz);
    }
}

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 编解码器protostuff工具
 */
public class ProtoStuffUtil {
    private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<Class<?>,Schema<?>>();

    private static <T> Schema<T> getSchema(Class<T> clazz){
        @SuppressWarnings("unchecked")
        Schema<T> schema = (Schema<T>) cachedSchema.get(clazz);
        if (schema == null){
            schema = RuntimeSchema.getSchema(clazz);
        }
        if (schema != null){
            //cachedSchema.put(clazz,schema);
        }
        return schema;
    }
    /**
     * 序列化
     */
    public static <T> byte[] serializer(T obj){
        @SuppressWarnings("unchecked")
        Class<T> clazz = (Class<T>) obj.getClass();
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try{
            Schema<T> schema = getSchema(clazz);
            return ProtostuffIOUtil.toByteArray(obj,schema,buffer);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        } finally {
            buffer.clear();
        }
    }
    /**
     * 反序列化
     * @param data
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T deserializer(byte[] data, Class<T> clazz) {
        try {
            T obj = clazz.newInstance();
            Schema<T> schema = getSchema(clazz);
            ProtostuffIOUtil.mergeFrom(data, obj, schema);
            return obj;
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }
}

3、Netty粘包拆包

TPC流拆包

import com.huawei.tuling05.week04_netty._04netty.core.codec.JSONSerializer;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;

import java.util.List;

/**
 * 消息解码器 ->
 * 1、拆包将TCP协议缓冲区数据拆分
 * 2、将byte[]类型的内容转为String或其他类型
 */
public class MessageDecoderHandler extends ByteToMessageDecoder {

    int length = 0;

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        //需要将得到二进制字节码-> MyMessageProtocol 数据包(对象)
        System.out.println(in);

        if(in.readableBytes() >= 4) {
            if (length == 0){
                length = in.readInt();
            }
            if (in.readableBytes() < length) {
                System.out.println("当前可读数据不够，继续等待。。");
                return;
            }
            byte[] content = new byte[length];
            if (in.readableBytes() >= length){
                in.readBytes(content);

                //封装成MyMessageProtocol对象，传递到下一个handler业务处理
                //此处提现将具体内容反序列化的思想
                MessageContent deserialize = JSONSerializer.deserialize(MessageContent.class, content);
                System.out.println("【入口】:Step 1 接收消息:"+ deserialize);
                out.add(deserialize);
            }
            length = 0;
        }
    }
}

粘包

import com.huawei.tuling05.week04_netty._04netty.core.codec.JSONSerializer;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

/**
 * 消息编码器 ->
 * 1、将发送内容的长度和内容分别写入
 * 2、将String或Json类型的内容转为byte[]
 */
public class MessageEncoderHandler extends MessageToByteEncoder<MessageContent> {

    private Class<?> clazz;

    public MessageEncoderHandler(Class<?> clazz) {
        this.clazz = clazz;
    }
    @Override
    protected void encode(ChannelHandlerContext ctx, MessageContent msg, ByteBuf out) throws Exception {
        System.out.println("【出口】:Step last,发送消息："+msg.getContent());
        if (clazz != null && clazz.isInstance(msg)) {
            byte[] bytes = JSONSerializer.serialize(msg);
            out.writeInt(bytes.length);
            out.writeBytes(bytes);
        }
    }
}

4、Netty心跳检测机制

  //Step3 建立心跳连接 另起线程schedule检查读超时
pipeline.addLast(new IdleStateHandler(3, 0, 0, TimeUnit.SECONDS));
pipeline.addLast(new HeartBeatServerHandler());//专用与心跳连接的处理器

源码分析：

5、客户端断线自动重连

6、基于Netty实现分布式框架

基于Nettu实现分布式框架，类似RPC、Dubbo功能，实际是实现Pipeline管道中各个Handler的业务逻辑。Netty通过ctx.firexxx来实现各Handler按照顺序的调用。下面来实现上述编解码、粘包粘包、心跳连接、自动断线连接的功能。

在这里插入图片描述

将上述功能集成于下面demo：

6.1 Client端代码
public class NettyFuncClient {

    Bootstrap bootstrap = new Bootstrap();

    public NettyFuncClient(){
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup(2);
        bootstrap.group(eventLoopGroup)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        //Step2 出入站第二道工序 粘包拆包(TPC指定消息长度进行拆包) 此处合二为一
                        pipeline.addLast(new MessageEncoderHandler(MessageContent.class));
                        pipeline.addLast(new MessageDecoderHandler());//处理服务器的心跳响应
                        pipeline.addLast(new HeartBeatClientHandler(NettyFuncClient.this));
                    }
                });
    }

    public static void main(String[] args) throws InterruptedException {
        NettyFuncClient client = new NettyFuncClient();
        client.connect();
    }

    public void connect() throws InterruptedException {
        System.out.println("netty client start...");
        ChannelFuture connect = bootstrap.connect("127.0.0.1", 9090);
        connect.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    //时时保持socket心跳
                    sendHeartBeat(future.channel() ,"Heartbeat Packet");
                }else {
                    //重试动作
                    future.channel().eventLoop().schedule(() -> {
                        System.err.println("重连服务端...");
                        try {
                            connect();
                        } catch (Exception e) {
                            e.printStackTrace();}
                        }, 3000, TimeUnit.MILLISECONDS);
                }}
        });
        //对通道关闭进行监听
        connect.channel().closeFuture().sync();
    }

    /**
     * 客户端随时需要于服务端保持连接
     * socket心跳保持连接
     *
     * @param channel
     * @param msg
     * @throws InterruptedException
     */
    private static void sendHeartBeat(Channel channel ,String msg) throws InterruptedException {
        while (channel.isActive()) {
            UUID uuid = UUID.randomUUID();
            //隔段时间发送一次socket心跳
            MessageContent messageContent = new MessageContent();
            messageContent.setRequestId(uuid.toString());
            messageContent.setContent(msg);
            channel.writeAndFlush(messageContent);
            Random random = new Random();
            int num = random.nextInt(8);
            //每秒1次的socket心跳
            Thread.sleep(1000*num);
            }
    }
}

Client端handler2处理心跳的处理器

public class HeartBeatClientHandler extends ChannelInboundHandlerAdapter {

    private NettyFuncClient nettyClient;

    public HeartBeatClientHandler(NettyFuncClient nettyClient) {
        this.nettyClient = nettyClient;
    }

    // channel 处于不活动状态时调用
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.err.println("运行中断开重连。。。");
        nettyClient.connect();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
6.2 Server端代码
  • 服务端启动代码
/**
 * 集成Netty的核心功能:
 * 1、编解码
 * 2、粘包拆包
 * 3、心跳连接
 * 4、客户端断线重连
 *
 */
public class NettyFuncServer {
    public static void main(String[] args) throws InterruptedException {
        //设置2组线程，分别用于接收请求和处理业务
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();//默认逻辑核心数*2
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)//反射获取该类对象
                    .option(ChannelOption.SO_BACKLOG,1024)//阻塞队列
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {//pipeline -> handler 入站顺序、出站逆序
                            //流水线工作
                            ChannelPipeline pipeline = ch.pipeline();
                            //Step1、Step2 入站第一道工序 解码 出站最后一道工序 编码 序列化
                            pipeline.addLast(new MessageEncoderHandler(MessageContent.class));
                            pipeline.addLast(new MessageDecoderHandler());
                            //Step3 建立心跳连接
                            pipeline.addLast(new IdleStateHandler(3, 0, 0, TimeUnit.SECONDS));
                            pipeline.addLast(new HeartBeatServerHandler());//专用与心跳连接的处理器
                            // Step4 业务逻辑及断线重连
                            pipeline.addLast(new NettyFuncServerHandler());
                            //业务逻辑 channelInactive方法中实现建立断线重建机制
                        }
                    });
            System.out.println("Netty Server start...");
            //启动服务器(绑定端口号) bind是异步操作 sync是等待异步绑定结果的同步操作
            ChannelFuture cf = bootstrap.bind(9090).sync();
            //等待服务器监听端口关闭,closeFuture是异步操作
            //通过sync同步等待通道关闭处理完毕，这里会阻塞等待通道关闭完成，内部调用的是Object.wait()方法
            cf.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}
  • 心跳及重连功能
public class HeartBeatServerHandler extends SimpleChannelInboundHandler<String> {

    int readIdleTimes = 0;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String s) throws Exception {
        System.out.println(" ====== > [server] message received : " + s);
        if ("Heartbeat Packet".equals(s)) {
            ctx.channel().writeAndFlush("ok");
        } else {
            System.out.println(" 其他信息处理 ... ");
        }
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        IdleStateEvent event = (IdleStateEvent) evt;

        String eventType = null;
        switch (event.state()) {
            case READER_IDLE:
                eventType = "读空闲";
                readIdleTimes++; // 读空闲的计数加1
                break;
            case WRITER_IDLE:
                eventType = "写空闲";
                // 不处理
                break;
            case ALL_IDLE:
                eventType = "读写空闲";
                // 不处理
                break;
        }

        System.out.println(ctx.channel().remoteAddress() + "超时事件：" + eventType);
        if (readIdleTimes > 3) {
            System.out.println(" [server]读空闲超过3次，关闭连接，释放更多资源");
            ctx.channel().writeAndFlush("idle close");
            ctx.channel().close();
        }
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.err.println("=== " + ctx.channel().remoteAddress() + " is active ===");
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.err.println("=== " + ctx.channel().remoteAddress() + " is InActive ===");
    }
}
6.3 编解码及序列化代码
  • 自定义消息体
/**
 * 自定义协议包
 */
public class MessageContent {

    public MessageContent() {
    }

    public MessageContent(String requestId, String content) {
        this.requestId = requestId;
        this.content = content;
    }

    private String requestId;
    //一次发送包体内容
    // content可以是String 或者是Json(此处以String为例)
    private String content;

    public String getRequestId() {
        return requestId;
    }

    public void setRequestId(String requestId) {
        this.requestId = requestId;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "MessageProtocol{" +
                "requestId=" + requestId +
                ", content='" + content + '\'' +
                '}';
    }
}
  • 编码及序列化
/**
 * 消息编码器 ->
 * 1、将发送内容的长度和内容分别写入
 * 2、将String或Json类型的内容转为byte[]
 */
public class MessageEncoderHandler extends MessageToByteEncoder<MessageContent> {

    private Class<?> clazz;

    public MessageEncoderHandler(Class<?> clazz) {
        this.clazz = clazz;
    }
    @Override
    protected void encode(ChannelHandlerContext ctx, MessageContent msg, ByteBuf out) throws Exception {
        System.out.println("【出口】:Step last,发送消息："+msg.getContent());
        if (clazz != null && clazz.isInstance(msg)) {
            byte[] bytes = JSONSerializer.serialize(msg);
            out.writeInt(bytes.length);
            out.writeBytes(bytes);
        }
    }
}
  • 解码及反序列化
/**
 * 消息解码器 ->
 * 1、拆包将TCP协议缓冲区数据拆分
 * 2、将byte[]类型的内容转为String或其他类型
 */
public class MessageDecoderHandler extends ByteToMessageDecoder {

    int length = 0;

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        //需要将得到二进制字节码-> MyMessageProtocol 数据包(对象)
        System.out.println(in);

        if(in.readableBytes() >= 4) {
            if (length == 0){
                length = in.readInt();
            }
            if (in.readableBytes() < length) {
                System.out.println("当前可读数据不够，继续等待。。");
                return;
            }
            byte[] content = new byte[length];
            if (in.readableBytes() >= length){
                in.readBytes(content);

                //封装成MyMessageProtocol对象，传递到下一个handler业务处理
                //此处提现将具体内容反序列化的思想
                MessageContent deserialize = JSONSerializer.deserialize(MessageContent.class, content);
                System.out.println("【入口】:Step 1 接收消息:"+ deserialize);
                out.add(deserialize);
            }
            length = 0;
        }
    }
}
旧梦昂志
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Netty 支持的功能与特性
Leon_Jinhai_Sun的博客
01-11 174
按照定义来说，Netty 是一个异步、事件驱动的用来做高性能、高可靠性的网络应用框架。主要的优点有： 1. 框架设计优雅，底层模型随意切换适应不同的网络协议要求。 2. 提供很多标准的协议、安全、编码解码的支持。 3. 解决了很多NIO 不易用的问题。 4. 社区更为活跃，在很多开源框架中使用，如Dubbo、RocketMQ、Spark 等。 上图体现的主要是Netty 支持的功能或者特性： 1.底层核心有：Zero-Copy-Capable Buffer，非常易用的灵拷贝Buffer（这个
netty超时问题排查
yangjian_9276的博客
01-28 4802
问题一 客户端超时主动断开连接 nginx 499 导致客户端接受到服务超时的返回。报错预警突增 原因：客户端超时时间比代理服务(backend配置超时)超时时间小，代理的后端服务超时导致调用方大量的请求报错。 排查过程如下 1、 查看apierror.log（这里会记录验证错误的异常） 对比报错陡增前后 apierror中针对具体接口的报错量是否平稳。 本次发现报错前后apierror中......
Netty的使用：Server和Client通信
宿久
10-13 4万+
Netty 是一款基于NIO（Nonblocking I/O，非阻塞IO）开发的网络通信框架，提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。对比于BIO（Blocking I/O，阻塞IO），他的并发性能得到了很大提高。 提供了对TCP、UDP和文件传输的支持，作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Futur...
netty大白话--字符串的收发（三）
影子
05-05 564
了解了Netty的基本概念，开发起来应该会顺手很多。在“Hello World”代码中，我们只是在完成绑定的时候，在各自的本地打印了简单的信息，并没有客户端和服务端的消息传递。这个肯定是最基本的功能。在上代码之前，先补充一个Netty中重要的概念，ChannelBuffer。 ChannelBuffer Netty中的消息传递，都必须以字节的形式，以ChannelBuffer为载体传递。简单的...
Netty编解码&粘包拆包&心跳机制&断线自动重连
yemuxiaweiliang的博客
12-10 778
Netty编解码&粘包拆包&心跳机制&断线自动重连
02-VIP-Netty核心功能与线程模型精讲1
08-03
总的来说，Netty 是一个强大且灵活的网络通信框架，通过其高效的线程模型、易于使用的 API 和丰富的功能，极大地降低了开发网络应用的复杂性，提高了系统的性能和可扩展性。无论是在微服务架构、游戏后端，还是...
reactor-netty-jar.zip
最新发布
12-12
总结，Reactor Netty是Java开发高性能网络应用的利器，它结合了Netty的底层性能优势和Reactor的反应式编程模型，为开发者提供了简单易用且高效的网络编程接口。了解并熟练掌握Reactor Netty，对于提升Java网络应用的...
Android-netty和socket通信的demo
08-13
总的来说，“Android-netty和socket通信的demo”是一个很好的学习资源，它将Netty的灵活性和Socket的简单性结合在一起，帮助开发者构建高性能的网络通信功能。通过研究这个示例，可以提升在Android网络编程中的技能...
网络编程之Netty一站式精讲.rar
12-29
三、Netty核心组件 1. Channel：表示网络连接，负责数据的发送和接收。 2. EventLoop：事件循环，负责处理I/O事件和执行回调任务。 3. Pipeline：处理链，每个Channel都有一个Pipeline，用于添加和处理各种处理器...
Netty的基本知识
h295928126的博客
12-25 1582
什么是netty     netty是一个 nio 客户机服务器框架，它支持快速简单地开发网络应用程序，如协议服务器和客户机。它极大地简化了网络编程，如 TCP 和 UDP 套接字服务器。经过多年的发展它已成为构建一个java网络生态的首选架构，在一些开源的项目中可见。     netty是一个异步、事件驱动的网络框架，整个netty的api都是异步设计，对网络应用来讲，io一般是性能的瓶颈，使用异步io可以较大程度上提高程序性能。     下面是官网的netty框架的图： ​     有个有趣的一点是，
Netty框架学习之(一）：Netty框架简介
热门推荐
不积跬步，无以至千里；不积小流，无以成江海！
05-23 15万+
1. 简介 官方定义为：”Netty 是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器 和客户端”,按照惯例贴上一张High Level的架构图： 纵观Java系的多种服务器/大数据框架，都离不开Netty做出的贡献，本文对Netty做一个简单的概述 2. 主要特性 Netty有很多重要的特性，主要特性如下： - 优雅的设计 - 统一...
netty实现tcp长连接和心跳检测
海阔天空
12-14 2468
       通过netty实现服务端与客户端的长连接通讯，及心跳检测。        基本思路：netty服务端通过一个Map保存所有连接上来的客户端SocketChannel,客户端的Id作为Map的key。每次服务器端如果要向某个客户端发送消息，只需根据ClientId取出对应的SocketChannel,往里面写入message即可。心跳检测通过IdleEvent事件，定时向服务端放送...
使用netty实现并维护TCP长连接
shadowdowdow的博客
12-01 7458
使用netty实现并维护TCP长连接Netty是什么Netty的优点Netty为什么并发高创建TCP长连接实例 Netty是什么 Netty 是一个利用 Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架。 Netty 是一个广泛使用的 Java 网络编程框架（Netty 在 2011 年获得了Duke’s Choice Award，见https://www.java.net/dukeschoice/2011）。它活跃和成长于用户社区，像大型公司 Faceboo
用netty实现tcp简单通信
mistt的博客
02-16 1万+
一般我们想要使用tcp通信，最原始的方法就是使用socket套接字，但是每次都要创建新的socket对象，并且在finally中关闭，好浪费资源，很麻烦。所以就是用netty工具，可以轻松地实现tcp通信，当然也可以实现http通信，因为我们需要用tcp通信，所以这里只研究tcp。 最好先了解一下netty是干嘛的，以及NIO是什么。 netty： https://blog.csdn.net/qq_34730511/article/details/98472924?ops_request_misc=&
Netty框架实现tcp通信
小码蚁
09-25 1万+
启动服务端 * 创建两个NIO线程组，一个专门用于接收来自客户端的连接，另一个则用于处理已经被接收的连接。 * 创建一个ServerBootstrap对象，配置Netty的一系列参数，例如接受传出数据的缓存大小等。 * 创建一个用于实际处理数据的类ChannelInitializer，进行初始化的准备工作，比如设置接受传出数据的字符集、格式以及实际处理数据的接口。 * 绑定端口，执行同...
一起学Netty（七）之 TCP粘包拆包基本解决方案
BazingaLyncc
05-07 2万+
可以看到被分了20次读取，我们可以这样理解，客户端发送了2次req字节，每个req中有10个“$$__”，这样就是第11次切割的时候其实发送了粘包，第一个req中末尾部分和第二次的头部粘在了一起，作为第11部分的内容 而最后一部分的内容因为没有"$$__"切割，所以没有打印在控制台上~ 其实这类的Handler还是相对比较简单的，真实的生产环境这些decoder只是作为比较基本的切分类，但是这些decoder还是很好用的~
Netty协议之 TCP （一）
shuoshuo132的博客
06-23 2533
前言 本章将会介绍如何使用Netty搭建一个TCP服务器，本系列不会详细介绍Netty本身框架。 TCP 协议 传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。 Netty 支持 导入依赖包 // gradle compile group: 'io.netty', name: 'netty-all', version: '4.1.50.Final' // maven <dependency> &lt
Java网络编程框架Netty实战
- 第6章介绍了ChannelHandler和ChannelPipeline，它们是Netty处理网络事件的核心机制。 - 第7章讲解编码解码框架，Netty提供了一套强大的Codec来处理不同协议的数据转换。 - 第8章详细阐述了Netty提供的预定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

旧梦昂志

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值