Netty核心技术八--Netty编解码器和handler的调用机制

已于 2023-07-02 10:56:30 修改
阅读量1.4k 收藏 2
点赞数
分类专栏： NIO&Netty 文章标签： windows
于 2023-07-02 10:49:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31745863/article/details/131498810
版权

1.基本说明

  1. netty的组件设计：Netty的主要组件有Channel、EventLoop、ChannelFuture、

    ChannelHandler、ChannelPipe等

  2. ChannelHandler充当了处理入站和出站数据的应用程序逻辑的容器。

    例如，实现ChannelInboundHandler接口（或ChannelInboundHandlerAdapter），你就可以接收入站事件和数据，这些数据会被业务逻辑处理。当要给客户端发送响应时，也可以从ChannelInboundHandler冲刷数据。**业务逻辑通常写在一个或者多个ChannelInboundHandler中。**ChannelOutboundHandler原理一样，只不过它是用来处理出站数据的

  3. ChannelPipeline提供了ChannelHandler链的容器。以客户端应用程序为例，如果事件的运动方向是从客户端到服务端的，那么我们称这些事件为出站的，即客户端发送给服务端的数据会通过pipeline中的一系列ChannelOutboundHandler，并被这些Handler处理，反之则称为入站的

    image-20230701143140904

2. 编码解码器

  1. 当Netty发送或者接受一个消息的时候，就将会发生一次数据转换。
    • 入站消息会被解码：从字节转换为另一种格式（比如java对象）；
    • 如果是出站消息，它会被编码成字节。
  2. **Netty提供一系列实用的编解码器，他们都实现了ChannelInboundHadnler或者ChannelOutboundHandler接口。**在这些类中，channelRead方法已经被重写了。
    • 以入站为例，对于每个从入站Channel读取的消息，这个方法会被调用。随后，它将调用由解码器所提供的decode()方法进行解码，并将已经解码的字节转发给ChannelPipeline中的下一个ChannelInboundHandler。

2.1 解码器-ByteToMessageDecoder

  1. 继承关系图

    image-20230701144226731

  2. 由于不可能知道远程节点是否会 一次性发送一个完整的信息， tcp有可能出现粘包拆包的问题， 这个类会对入站数据进行缓冲， 直到它准备好被处理.

  3. 一个关于ByteToMessageDecoder实例分析

    这个例子，**每次入站从ByteBuf中读取4字节，将其解码为一个int，然后将它添加到下一个List中。**当没有更多元素可以被添加到该List中时，它的内容将会被发送给下一个ChannelInboundHandler。int在被添加到List中时，会被自动装箱为Integer。在调用readInt()方法前必须验证所输入的ByteBuf是否具有足够的数据

    public class ToIntegerDecoder extends ByteToMessageDecoder {
 @Override
 protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
     if (in.readableBytes() >= 4) {
         out.add(in.readInt());
     }
 }
}

    案例分析:

    image-20230701144910374

    1. 已知一个int4个字节,那我们在解码的时候就需要将4个字节组成一个int然后添加到下一个handler可以读取到的list中
    2. 在执行readInt方法时,ByteBuf中的readerIndex指针会向后移动,所以我们只需要一直读取即可
    3. 同理:

2.2 Netty的handler链的调用机制-实例1

实例要求:

使用自定义的编码器和解码器来 说明Netty的handler 调用机制 客户端发送long -> 服务器 服务端发送long -> 客户端

因为数据是从客户端到服务端,我先从客户端开始写(数据流转比较清除)

2.2.1 MyClient

  • 需要一个MyClientInitializer()
package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * @author zr
 * @date 2023/7/1 16:40
 */
public class MyClient {
    public static void main(String[] args)  throws  Exception{

        EventLoopGroup group = new NioEventLoopGroup();

        try {

            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class)
                    .handler(new MyClientInitializer()); //自定义一个初始化类

            ChannelFuture channelFuture = bootstrap.connect("localhost", 8888).sync();

            channelFuture.channel().closeFuture().sync();

        }finally {
            group.shutdownGracefully();
        }
    }
}

2.2.2 MyClientInitializer

  1. 因为数据是从客户端到服务器端是出站,所以需要编码,我们需要加入自定义编码器MyLongToByteEncoder
  2. 处理后续业务需要MyClientHandler
package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

/**
 * @author zr
 * @date 2023/7/1 16:40
 */
public class MyClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {

        ChannelPipeline pipeline = ch.pipeline();

        //加入一个出站的handler 对数据进行一个编码
        pipeline.addLast(new MyLongToByteEncoder());

        //加入一个自定义的handler ， 处理业务
        pipeline.addLast(new MyClientHandler());


    }
}

2.2.3 MyLongToByteEncoder

  1. 继承MessageToByteEncoder<T>
  2. 重写encode方法来自定义编码方式,将数据编码
package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

/**
 * @author zr
 * @date 2023/7/1 16:44
 */
public class MyLongToByteEncoder extends MessageToByteEncoder<Long> {
    //编码方法
    @Override
    protected void encode(ChannelHandlerContext ctx, Long msg, ByteBuf out) throws Exception {
        System.out.println("MyLongToByteEncoder encode 被调用");
        System.out.println("msg=" + msg);
        out.writeLong(msg);
    }
}

2.2.4 MyClientHandler

这里就是将我们编码的数据在channel激活的时候发送一个long类型的数据到服务端

package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

/**
 * @author zr
 * @date 2023/7/1 16:41
 */
public class MyClientHandler extends SimpleChannelInboundHandler<Long> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {

    }

    //重写channelActive 发送数据
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("MyClientHandler 发送数据");
        //ctx.writeAndFlush(Unpooled.copiedBuffer(""))
        ctx.writeAndFlush(123456L); //发送的是一个long
    }
}

2.2.5 MyServer

将处理器封装为MyServerInitializer

package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * @author zr
 * @date 2023/7/1 15:16
 */
public class MyServer {
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup(8);
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new MyServerInitializer());

            ChannelFuture channelFuture = serverBootstrap.bind(8888).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

2.2.6 MyServerInitializer

  1. 因为数据是从客户端到服务器端是出站,所以需要解码,我们需要加入自定义解码器MyByteToLongDecoder
  2. 处理后续业务需要MyServerHandler
package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

/**
 * @author zr
 * @date 2023/7/1 15:21
 */
public class MyServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();//一会下断点

        //入站的handler进行解码 MyByteToLongDecoder
        pipeline.addLast(new MyByteToLongDecoder());
        //自定义的handler 处理业务逻辑
        pipeline.addLast(new MyServerHandler());
        System.out.println("xx");
    }
}

2.2.7 MyByteToLongDecoder

  1. 继承ByteToMessageDecoder
  2. 重写decode方法来自定义解码方式,将数据解码
  3. decode 会根据接收的数据，被调用多次, 直到确定没有新的元素被添加到list或者是ByteBuf 没有更多的可读字节为止
  4. 如果list out 不为空，就会将list的内容传递给下一个 channelinboundhandler处理, 该处理器的方法也会被调用多次
  5. 参数说明:
    • ctx:上下文对象
    • in: 入站的 ByteBuf
    • out:List 集合，将解码后的数据传给下一个handler
package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageCodec;
import io.netty.handler.codec.ByteToMessageDecoder;

import java.util.List;

/**
 * @author zr
 * @date 2023/7/1 16:36
 */
public class MyByteToLongDecoder extends ByteToMessageDecoder {
    /**
     *
     * decode 会根据接收的数据，被调用多次, 直到确定没有新的元素被添加到list
     * , 或者是ByteBuf 没有更多的可读字节为止
     * 如果list out 不为空，就会将list的内容传递给下一个 channelinboundhandler处理, 该处理器的方法也会被调用多次
     *
     * @param ctx 上下文对象
     * @param in 入站的 ByteBuf
     * @param out List 集合，将解码后的数据传给下一个handler
     * @throws Exception
     */
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        System.out.println("MyByteToLongDecoder 被调用");
        //因为 long 8个字节, 需要判断有8个字节，才能读取一个long
        if (in.readableBytes()>=8){
            out.add(in.readLong());
        }
    }
}

2.2.8 MyServerHandler

  1. MyByteToLongDecoder解码的数据会传到下一个handler,那么数据类型就确定了所以SimpleChannelInboundHandler<Long>
  2. 将数据打印到控制台
package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

/**
 * @author zr
 * @date 2023/7/1 16:34
 */
public class MyServerHandler extends SimpleChannelInboundHandler<Long> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("从客户端" + ctx.channel().remoteAddress() + " 读取到long " + msg);

    }

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

2.2.9 测试

  1. 启动服务端

    image-20230701170558556

  2. 启动客户端

    image-20230701170620726

    image-20230701170634222

编码器和解码器都被调用,服务端拿到客户端编码后的数据解码后输出成功

2.2.10 特殊情况测试-发送数据与与编解码器的类型不一致

当我们客户端发送的数据为一个16个字节的字符串的时候会发生什么情况?

package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;

/**
 * @author zr
 * @date 2023/7/1 16:41
 */
public class MyClientHandler extends SimpleChannelInboundHandler<Long> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {

    }

    //重写channelActive 发送数据
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("MyClientHandler 发送数据");
        //ctx.writeAndFlush(Unpooled.copiedBuffer(""))
//        ctx.writeAndFlush(123456L); //发送的是一个long


        //分析
        //1. "abcdabcdabcdabcd" 是 16个字节
        //2. 该处理器的前一个handler 是  MyLongToByteEncoder
        //3. MyLongToByteEncoder 父类  MessageToByteEncoder
        //4. 父类  MessageToByteEncoder
        /*

         public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        ByteBuf buf = null;
        try {
            if (acceptOutboundMessage(msg)) { //判断当前msg 是不是应该处理的类型，如果是就处理，不是就跳过encode
                @SuppressWarnings("unchecked")
                I cast = (I) msg;
                buf = allocateBuffer(ctx, cast, preferDirect);
                try {
                    encode(ctx, cast, buf);
                } finally {
                    ReferenceCountUtil.release(cast);
                }

                if (buf.isReadable()) {
                    ctx.write(buf, promise);
                } else {
                    buf.release();
                    ctx.write(Unpooled.EMPTY_BUFFER, promise);
                }
                buf = null;
            } else {
                ctx.write(msg, promise);
            }
        }
        4. 因此我们编写 Encoder 是要注意传入的数据类型和处理的数据类型一致
        */
         ctx.writeAndFlush(Unpooled.copiedBuffer("abcdabcdabcdabcd", CharsetUtil.UTF_8));
    }
}

  1. 启动服务端

    image-20230701171859900

  2. 启动客户端

    image-20230701171926115

    image-20230701171938680

  • 服务端输出了两次MyByteToLongDecoder 被调用代表MyByteToLongDecoder的decode方法被调用了两次

    1. decode 会根据接收的数据，被调用多次, 直到确定没有新的元素被添加到list或者是ByteBuf 没有更多的可读字节为止
    2. 如果list out 不为空，就会将list的内容传递给下一个 channelinboundhandler处理, 该处理器的方法也会被调用多次

  • 我们发现没有客户端没有打印MyLongToByteEncoder 被调用,代表MyLongToByteEncoder的encode方法没有被调用

    image-20230701172633093

2.3 Netty的handler链的调用机制-实例2

实例要求:

  • 使用自定义的编码器和解码器来 说明Netty的handler 调用机制 客户端发送long -> 服务器 服务端发送long -> 客户端

    image-20230701174422543

实现图

image-20230701174601262

实例1已经实现客户端向服务端发送数据,我们只需要在示例1的基础上在服务端打印客户端发送的数据的同时发送编码数据,然后客户端在解码读取数据即可

2.3.1 MyServerInitializer

加上编码器

image-20230701175712684

2.3.2 MyServerHandler

发送数据

image-20230701175759225

2.3.3 MyClientInitializer

客户端加上解码器

image-20230701175843496

2.3.4 MyClientHandler

打印数据

image-20230701175910802

2.3.5 测试

  1. 启动服务端

    image-20230701180041752

  2. 启动客户端

    image-20230701180100543

    image-20230701180113276

服务端也成功接收到了数据

  • 结论:
    • 不论解码器handler 还是 编码器handler 即接 收的消息类型必须与待处理的消息类型一致， 否则该handler不会被执行
    • 在解码器 进行数据解码时，需要判断 缓存 区(ByteBuf)的数据是否足够,否则接收到的结果会和期望结果可能不一致

2.2.6 调用链debug

  1. 为了方便查看handler,最好起一个名字

    image-20230701182649511

  2. 启动服务端和客户端,代码走到断点查看head为整个调用链的(pipeline)的头结点

    image-20230701182840166

  3. 点击next查看下一个handler,是我们的MyServerInitializer

    image-20230701182951165

  4. 点击next查看下一个handler,是我们的MyByteToLongDecoder

    image-20230701183035091

  5. 点击next查看下一个handler,是我们的MyLongToByteEncoder

    image-20230701183118118

  6. 点击next查看下一个handler,是我们的MyServerHandler

    image-20230701183149070

  7. 点击next查看下一个handler,这是netty的默认尾节点next已经为空了

    image-20230701183225481

第四步和第五步只会执行一个,因为他们继承的父类不同出入站,出站和入站只会执行对应的一个

3. 解码器-ReplayingDecoder

  1. public abstract class ReplayingDecoder extends ByteToMessageDecoder
  2. ReplayingDecoder扩展了ByteToMessageDecoder类，使用这个类，我们不必调用readableBytes()方法。参数S指定了用户状态管理的类型，其中Void代表不需要状态管理(由ByteToMessageDecoder来帮我们自动识别并管理)
  3. ReplayingDecoder使用方便，但它也有一些局限性：
    • 并不是所有的 ByteBuf 操作都被支持，如果调用了一个不被支持的方法，将会抛出一个UnsupportedOperationException。
    • ReplayingDecoder 在某些情况下可能稍慢于 ByteToMessageDecoder，例如网络缓慢并且消息格式复杂时，消息会被拆成了多个碎片，速度变慢

3.1 应用实例

3.1.1 MyByteToLongDecoder2

  • ReplayingDecoder<Void>代表没有指定类型,ReplayingDecoder来帮我们识别并管理
  • 读取数据的时候也不需要判断数据是否足够读取，内部会进行处理判断
package site.zhourui.nioAndNetty.netty.inboundhandlerandoutboundhandler;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ReplayingDecoder;

import java.util.List;

public class MyByteToLongDecoder2 extends ReplayingDecoder<Void> {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        System.out.println("MyByteToLongDecoder2 被调用");
        //在 ReplayingDecoder 不需要判断数据是否足够读取，内部会进行处理判断
        out.add(in.readLong());
    }
}

3.1.2 将实例2中的MyByteToLongDecoder替换为MyByteToLongDecoder2

MyClientInitializer

image-20230702103638354

MyServerInitializer

image-20230702103710988

3.1.3 测试

image-20230702103813374

image-20230702103830587

仍然能实现实例2的功能

4. 其它编解码器

4.1 LineBasedFrameDecoder

这个类在Netty内部也有使用，它使用行尾控制字符（\n或者\r\n）作为分隔符来解析数据。

4.2 DelimiterBasedFrameDecoder

使用自定义的特殊字符作为消息的分隔符。

4.3 HttpObjectDecoder

一个HTTP数据的解码器,之前的笔记中使用过

4.4 LengthFieldBasedFrameDecoder

通过指定长度来标识整包消息，这样就可以自动的处理黏包和半包消息。

5. Log4j 整合到Netty

  1. 在Maven 中添加对Log4j的依赖 在 pom.xml

          <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>1.2.17</version>
      </dependency>
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-api</artifactId>
          <version>1.7.25</version>
      </dependency>
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-log4j12</artifactId>
          <version>1.7.25</version>
          <scope>test</scope>
      </dependency>
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-simple</artifactId>
          <version>1.7.25</version>
          <scope>test</scope>
      </dependency>

  2. 配置 Log4j , 在 resources/log4j.properties

    log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%p] %C{1} - %m%n

  3. 随便启动一个服务

    image-20230702104506403

为了方便以后学习查看控制台清楚一点可以先关闭日志功能

把步骤2和步骤2的内容注释掉,当然你需要日志功能也可以打开

_院长大人_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
万字详细解析Netty编解码器机制
wdj_yyds的博客
06-19 497
编写网络应用程序时，因为数据在网络中传输的都是二进制字节码数据，在发送数据时就需要编码，接收数据时就需要解码。decoder(解码器)和 encoder(编码器)。encoder 负责把业务数据转换成字节码数据decoder 负责把字节码数据转换成业务数据Netty 自身提供了一些 codec(编解码器)Netty 提供的编码器StringEncoder，对字符串数据进行编码ObjectEncoder，对 Java 对象进行编码......Netty 提供的解码器。
Netty——Handler链调用机制及编解码器
weixin_43415481的博客
05-11 489
JAVA后端开发知识总结（持续更新…） Netty——Handler链调用机制及编解码器 文章目录Netty——Handler链调用机制及编解码器一、Netty的入站和出站机制1.1 概述1.2 Handler 编解码器1.2.1 ByteToMessageDecoder1.2.2 ReplayingDecoder1.2.3 HttpObjectDecoder二、Handler链调用机制2.1 服务端2.2 客户端2.3 结果 一、Netty的入站和出站机制 1.1 概述   ChannelHand.
Netty: ChannelInboundHandler和ChannelOutboundHandler的使用
amadeus_liu2的博客
05-09 1850
一、需要注意的地方： 入站的消息会流经所有的添加的ChannelInboundHandler,出站的消息不一定会流经所有的ChannelOutboundHandler,通过在某个ChannelInboundHandler的ChannelHandlerContext的writeAndFlush方法写出的数据，并不会流经其后的ChannelOuntboundHandler,但如果是通过ctx.channel().writeAndFlush方法写出数据，则会流经所有的ChannelOutboundHandler.
Netty学习——实战篇8 Handler链调用、TCP粘包和拆包 备份
最新发布
geminigoth的博客
04-24 930
/长度//内容@Slf4j@Overridelog.info("MyMessageEncoder 的 encode 方法被调用");/*自定义解码器，把二进制字节码转换成 MessageProtocol对象*/@Slf4j@Overridelog.info("MyMessageDecoder 的 decode方法被调用");//封装成MessageProtocol对象//把 MessageProtocol对象放入list中。
io.netty学习（十三）Netty 解码器
码灵的博客
06-26 1499
编码和解码：数据从一种特定协议格式到另一种格式的转换。处理编码和解码的程序通常被称为编码器和解码器。Netty 提供了一些组件，利用它们可以很容易地为各种不同协议编写编解码器。编解码其实可以分为两块，即编码和解码。要知道，在网络中数据都是以字节码的形式来传输的，而我们只能识别文本、图片这些格式，因此编写网络应用程序不可避免地需要操作字节，将我们能够识别的数据转换成网络能够识别的程序，这个过程称之为编解码。编码也称为序列化，它将对象序列化为字节数组，用于网络传输、数据持久化或者其他用途。
channel与outboundhandler下的方法
m0_48187193的博客
05-26 474
channel与outboundhandler下的方法。 文章目录channel与outboundhandler下的方法。前言1.connect方法1.1 寻找outbound connect方法执行执行HeadContext的connect方法。2.close方法2.1连接超时3.write方法3.1 headContext的write方法。3.2最后会执行AbstractChannel的方法3.3 他在写到什么时候才会将数据刷到服务端呢？4.read方法4.1调用unsafe的beginRead方法4.
Netty之Handler详解与实战
HaSaKing的博客
02-27 1740
在Netty中，Handler是实现网络应用逻辑的核心。它提供了一系列回调方法，例如处理接收到的数据、异常处理、连接活动等。Netty通过ChannelPipeline来管理Handler，可以想象为一个Handler链，数据在这个链上流动，每个Handler对数据进行处理后，可以传递给链上的下一个Handler，这种机制极大地提高了处理流程的灵活性和可定制性。
03-04-10-Netty编解码的艺术1
08-04
无论是内置的编解码器，如ByteToMessageDecoder和MessageToByteEncoder，还是用户自定义的编码器，都是Netty高效通信的关键组成部分。 通过本章的学习，读者将深入理解Netty如何处理网络通信中的数据问题，并掌握...
netty-api-4.1中文.rar
06-30
在 "netty-api-4.1中文.CHM" 文件中，你将找到关于 Channel、Pipeline、Handler、EventLoopGroup 等核心概念的详细解释，以及如何配置和使用 Netty 来创建服务器和客户端的示例。此外，文档还会涵盖错误处理、性能...
Netty源码教程-1
10-12
Netty 是一个高性能、异步事件驱动的网络应用程序框架，...本教程的“day01”部分可能涵盖了这些基础知识，通过深入学习和实践，开发者可以逐步掌握Netty的高级特性，如流式API、编解码器、以及更复杂的网络应用开发。
Netty源码教程-4
10-31
自定义的编码器和解码器可以通过继承`MessageToByteEncoder`或`MessageToMessageEncoder`，`MessageToByteDecoder`或`MessageToMessageDecoder`来实现。 Netty的管道（Pipeline）机制是其灵活性的关键。每个`...
wisdom-lis-netty:LIS系统-netty通讯服务
03-04
Netty的主要优势在于它的高度可定制性，允许开发者自定义协议编解码器、事件处理流程等，使得网络通信更加灵活且高效。 在LIS系统中，Netty的运用通常涉及到以下几个关键环节： 1. **连接管理**：Netty的Channel...
netty-api-4.1.zip
08-31
9. **高度可定制性**：Netty的灵活性允许开发者根据需要自定义编解码器和事件处理器，适应各种复杂的业务场景。 10. **易用性**：Netty的API设计简洁且直观，降低了开发复杂网络应用的学习曲线。 在“netty-api-...
Netty-user-guide:Netty用户指南中文翻译
05-09
**编码与解码**：Netty 提供了各种编解码器，用于将原始数据转换为特定协议的消息，或反之。 **线程模型**：Netty 的 EventLoopGroup 负责调度和管理事件循环线程，有效地处理并发连接。 **心跳与空闲检测**：...
netty-4.1.zip
01-06
5. **编码解码器**：Netty提供了丰富的编码解码器，如ByteToMessageDecoder和MessageToByteEncoder，用于在不同数据格式之间转换，如将TCP字节流转换为自定义消息对象。 6. **Handler的生命周期方法**：如...
netty-client:netty client学习
07-12
Netty 客户端的学习过程中，你还会接触到许多其他概念，如 ByteBuf（用于高效地处理网络数据），以及各种编解码器（如 LengthFieldBasedFrameDecoder、ProtobufVarint32FrameDecoder 等）以适应不同协议的需求。...
Netty应用(七) 之 Handler & Netty服务端编程总结
Eriksen的博客
02-11 1692
Netty应用(七) 之 Handler & Netty服务端编程总结
为什么ChannelOutboundHandler会有read方法？auto-read参数的意义？DefaultPipeline的数据流到底是怎样的？
benjam1n77的博客
08-19 846
为什么ChannelOutboundHandler会有read方法？auto-read参数的意义？DefaultPipeline的数据流到底是怎样的？
netty 总结
19li
06-16 347
数据的读取写入是通过buffer，这个和BIO本质不同，BIO中要么是输入流或者是输出流，不会是双向的，而NIO中的buffer可读可写，需要flip方法切换。BIO基于字节流和字符流进行操作，而NIO是基于Channel（通道）和Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。channel是双向的，可以返回底层操作系统的情况，如linux，底层的操作系统就是双向的。BIO以流的方式处理数据，而NIO以块的方式处理数据，块I/O的效率比流I/O高很多。
io.netty:netty-handler 的替代库
06-08
io.netty:netty-handler 是Netty框架的核心组件之一，主要用于网络通信的处理和管理。如果您想要替代 io.netty:netty-handler，您可以考虑以下几种库： 1. Apache MINA：MINA是一个高性能、可扩展的网络应用程序框架，支持多种协议，包括TCP、UDP和HTTP等。 2. Grizzly：Grizzly是一个开源的、高性能的NIO框架，支持多种协议，包括HTTP、HTTPS和WebSocket等。 3. Jetty：Jetty是一个开源的、高性能的Web服务器和Servlet容器，支持多种协议，包括HTTP、HTTPS、WebSocket和SPDY等。 这些库都是成熟的、安全的、高性能的网络通信库，可以替代 io.netty:netty-handler 的功能。当然，具体选择哪一个库，需要根据您的具体需求和场景来决定。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值