[Netty学习笔记]十、编解码器的使用

最新推荐文章于 2023-08-23 10:53:23 发布
最新推荐文章于 2023-08-23 10:53:23 发布
阅读量447 收藏
点赞数
分类专栏： Netty学习笔记 文章标签： netty Encoder Decoder
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyxwvuuvwxyz/article/details/104113511
版权
本文详细介绍了Netty框架的核心组件，包括Channel、EventLoop、ChannelFuture等，以及ChannelHandler、ChannelPipeline的工作机制。深入探讨了编解码器的使用，如ByteToMessageDecoder和MessageToByteEncoder，并通过自定义编解码器的实例，展示了数据处理流程。
摘要由CSDN通过智能技术生成
基本说明

Netty的组件设计：Netty主要组件有Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipe等。

ChannelHandler充当了处理入站和出站数据的应用程序逻辑的容器。例如，实现ChannelInboundHandler接口(或ChannelInboundHandlerAdapter)，你就可以接收入站事件和数据，这些数据会被业务逻辑处理。业务逻辑通常写在一个或者多个ChannelInboundHandler中。ChannleOutboundHandler原理一样，只是它是用来处理出站数据的。

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

编解码器

当Netty发送或者接收一个消息时，就会发生一次数据转换。入站消息会被解码，从二进制字节流转为对象等格式；如果是出站消息，则业务数据则会被编码为二进制字节流。

Netty提供了一系列实用的编解码器，他们实现了ChannelInboundHandler或者ChannelOutboundHandler接口。这些编解码器的实现类中，channelRead 方法普遍被重写，以编解码。

以入站为例，channelRead方法会被先调用，随后，它将调用由解码器所提供的decode()方法进行解码，并将已经解码的字节转发给ChannelPipeline中的下一个ChannelInboundHandler。

解码器接口ByteToMessageDecoder、编码器接口MessageToByteEncoder，或者直接实现MessageToMessageCodec包含了编解码。当需要自定义编解码器时，只需要实现接口即可。

自定义解码器

例子:

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

说明：

每次入站从ByteBuf中读取4个字节(因为int是占4个字节)，将其解码为一个int，然后将它添加到下一个List中。当没有更多元素可以被添加到List中时，list的内容会被发送给下一个ChannleInboundHandler。这种情况下，判断字节数是否>=4是必要的，否则会出现粘包拆包问题

下面以一个例子来说明Netty中handler链的调用顺序

例子要求：

  • 客户端发送long给服务器端
  • 服务器端发送long给客户端

服务器端代码

package com.wojiushiwo.codec;

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

/**
 * Created by myk
 * 2020/1/29 下午7:02
 */
public class NettyCustomCodecServer {
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {

            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {

                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("encoder",new LongEncoder());
                            pipeline.addLast("decoder",new LongDecoder());
                            pipeline.addLast(new CustomCodecServerHandler());
                        }
                    });

            ChannelFuture channelFuture = serverBootstrap.bind(8091).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

//handler
package com.wojiushiwo.codec;

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

/**
 * Created by myk
 * 2020/1/29 下午7:02
 */
public class CustomCodecServerHandler extends SimpleChannelInboundHandler<Long> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("调用了CustomCodecServerHandler#channelRead0");
        System.out.println("from client:" + msg);

    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("调用了CustomCodecServerHandler#channelReadComplete");
        ctx.writeAndFlush(123456789L);
    }

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

客户端代码

package com.wojiushiwo.codec;

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

/**
 * Created by myk
 * 2020/1/29 下午7:02
 */
public class NettyCustomCodecClient {
    public static void main(String[] args) {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        try {

            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("encoder", new LongEncoder());
                            pipeline.addLast("decoder", new LongDecoder());
                            pipeline.addLast(new CustomCodecClientHandler());
                        }
                    });


            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8091).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}
//handler
package com.wojiushiwo.codec;

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

/**
 * Created by myk
 * 2020/1/29 下午7:02
 */
public class CustomCodecClientHandler extends SimpleChannelInboundHandler<Long> {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端CustomCodecClientHandler#channelActive");
        ctx.writeAndFlush(1999999L);
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("客户端CustomCodecClientHandler#channelRead0");
        System.out.println("from server:" + msg);
    }

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

自定义编解码器代码

//编码器
package com.wojiushiwo.codec;

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

/**
 * Created by myk
 * 2020/1/29 下午7:04
 */
public class LongEncoder extends MessageToByteEncoder<Long> {

    @Override
    protected void encode(ChannelHandlerContext ctx, Long msg, ByteBuf out) throws Exception {
        System.out.println("调用编码器LongEncoder#encode");
        out.writeLong(msg);
    }

}

//解码器
package com.wojiushiwo.codec;

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

import java.util.List;

/**
 * Created by myk
 * 2020/1/29 下午7:03
 */
public class LongDecoder extends ByteToMessageDecoder {

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {

        System.out.println("调用LongDecoder#decode");
        //long 8个字节
        if (in.readableBytes() >= 8) {
            out.add(in.readLong());
        }

    }
}

服务器端输出：

调用LongDecoder#decode
调用了CustomCodecServerHandler#channelRead0
from client:1999999
调用了CustomCodecServerHandler#channelReadComplete
调用编码器LongEncoder#encode

客户端输出:

客户端CustomCodecClientHandler#channelActive

调用编码器LongEncoder#encode
调用LongDecoder#decode
客户端CustomCodecClientHandler#channelRead0
from server:123456789

通过打印字符串到控制台可以发现调用顺序：

客户端ChannelActive=>客户端LongEncoder#encode=>服务器端LongDecoder#decode=>CustomCodecServerHandler#channelRead0=>CustomCodecServerHandler#channelReadComplete=>服务器端LongEncoder#encode=>客户端LongDecoder#decode=>CustomCodecClientHandler#channelRead0

总结：

  1. 不论解码器handler还是编码器handler，接收的消息类型必须与待处理的消息类型一致，否则该handler不会被执行
  2. 在解码器进行数据解码时，需要判断缓冲区的数据是否足够，否则接收到的结果可能会与期望结果不一致。
解码器-ReplayingDecoder

ReplayingDecoder继承了ByteToMessageDecoder类，使用这个类，我们不需要显式的去判断缓冲区是否足够，该类会自动去做这个事情。泛型S指定了用户状态管理的类型，其中Void表示不需要状态管理。

示例:

使用ReplayingDecoder重构LongDecoder

package com.wojiushiwo.codec;

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

import java.util.List;

/**
 * Created by myk
 * 2020/1/29 下午7:47
 */
public class LongDecoder2 extends ReplayingDecoder<Void> {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
      //不需要判断数据是否足够读取，内部会进行处理判断
        out.add(in.readLong());
    }
}

ReplayingDecoder优缺点：

优点：使用方便

缺点：

  1. 并不是所有的ByteBuf操作都被支持，如果调用了一个不被支持的方法，将会抛出UnsupportOperationException,比如ReplayingDecoderByteBuf#array()方法
  2. ReplayingDecoder在某些情况下会慢于ByteToMessageDecoder,如网络缓慢且消息格式复杂时，消息会拆成了多个碎片，速度变慢。
其他编解码器
  1. LineBasedFrameDecoder：这个类在Netty内部有使用，它使用行尾控制符(\n或者\r\n)作为分隔符来解析数据
  2. DelimiterBasedFrameDecoder：使用自定义的特殊字符作为消息的分割符
  3. HttpObjectDecoder：Http数据的解码器
  4. LengthFieldBasedFrameDecoder：通过指定长度来标识整包信息，这样就可以自动的处理粘包和半包问题
  5. ObjectEncoder：与对象有个的编码器
  6. …
Netty学习笔记
01-20
Netty解决JDK空轮询BUG 1、创建一个新的Selector ...Netty如何确定要使用那些编码器和解码器 很简单，去看API文档 Netty自带的编码器可以解决99%的业务需求 1%自己编码 Netty中大文件上传的那个handler是怎么
Netty中重写SimpleChannelInboundHandler后channelRead0方法未被调用的原因与解决
weixin_43221753的博客
01-12 1274
本文探讨了在使用Netty框架时，重写`SimpleChannelInboundHandler`的`channelRead0`方法未被调用的问题。该问题可能由类型不匹配或管道配置错误导致。为确保`channelRead0`正确调用，需确保泛型类型与实际消息类型一致、处理器已正确加入ChannelPipeline且无其他处理器拦截消息，同时对需要解码的数据添加合适的解码器。通过示例代码演示了如何创建处理字符串消息的处理器并将其成功配置到Netty的ChannelPipeline中。
netty channelRead0 永远不执行
IT837684734的专栏
11-12 8021
项目中用了netty框架，自定义了解码器，由于没有结束符，导致了channelRead0一直不会执行。既然不会被动触发，那主动触发怎么样？ 结果netty还真有，不得不说netty确实好用。不过主动触发的是 channelRead，这点需要注意，netty提供的方法就是fireChannelRead 。有两种写法： 1：ctx.fireChannelRead(msg); //通过当前节点往下传播事件 2： ctx.pipeline().fireChannelRead(msg);//通...
Netty SimpleChannelInboundHandler 自动判断是否需要调用 Handler 处理 Message 的原理
ikun 的博客
05-23 1963
场景 假设我们基于 Netty 自定义实现我们自己的 RPC 框架，那么需要先从网络 I/O 从根据原始的 byte[]字节流转为Java 对象（ByteToMessageDecoder）。由于 RPC 是请求响应模型，那么 Netty 框架对 RPC 包进行处理的流程就是 Byte -> Message -> Request/Response。 问题 也就是说，Netty 的 Message 对应到 RPC 有两条具体的实现，分别是 Request/Response。对应到我们的 RPC 协
一起学Netty（三）之 SimpleChannelInboundHandler
热门推荐
z69183787的专栏
10-31 2万+
其实Netty的知识点还是很零碎的，比如这个SimpleChannelInboundHandler这个类，在《Netty in Action》该书中的原版的Hello world的demo的客户端就是使用的SimpleChannelInboundHandler来作为处理器的，我本来也是使用这个类作为我处理类的，但是做一个新手，这个类还是让我走了一点弯路，我们可以看到SimpleChannelInb
Netty向ChannelPipeline中添加多个Decoder不生效的问题
weixin_44144211的博客
11-24 1770
ByteToMessageDecoder解码器 业务逻辑如下： 自定义Decoder拿到tcp的数据，按照支持的协议标记去匹配确定该数据采用的协议。 将协议标记绑定到channel的attr中。 向当前的ChannelPipeline中添加协议指定的Decoder。 代码大概逻辑如下： NettyServer: ....... ChannelPipeline pipeline = socketChannel.pipeline(); pipeline.addLast("protocolDecoder",
Netty学习笔记_Springboot实现自定义协议.docx
12-27
Netty学习笔记_Springboot实现自定义协议 本文主要介绍了使用Netty框架在Springboot项目中实现自定义协议的方法。自定义协议是指在网络通信中，使用特定的数据格式来传输数据，以满足特定的业务需求。在本文中，...
Netty全套学习资源（包括源码、笔记、学习文档等）
04-19
笔记可能涵盖 Netty 的安装配置、基本使用、线程模型、缓冲区操作、编解码器的实现以及异常处理等方面，帮助读者逐步建立起对 Netty 的整体认知。 三、Netty 学习文档 文档通常是对 Netty API 的详细解释，包括官方...
自动netty笔记111
最新发布
06-10
这个“自动Netty笔记111”可能是某个开发者或学习者记录的一系列关于Netty学习过程中的关键点和理解。下面将详细阐述Netty的相关知识点。 1. **异步事件驱动模型**： Netty采用了非阻塞I/O模型，基于Java NIO（Non...
Netty4.0学习笔记系列之四：混合使用coder和handler
06-10
在本篇Netty4.0学习笔记中，我们将聚焦于如何在实际应用中混合使用`coder`和`handler`，这是Netty框架中非常关键的一部分，对于构建高性能、低延迟的网络应用程序至关重要。Netty是一个用Java编写的异步事件驱动的...
Netty 执行了多次channelReadComplete()却没有执行ChannelRead()
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
07-31 851
channelReadComplete从字面看就是netty读取完数据之后要进行的操作，然而有时却并不是这样。对于channelRead方法，如果pipeline中添加了解析器，会在消息被解码后才会被调用；而channelReadComplete方法是只要底层的socket读到了bytes就会被触发一次，但是否是完整的数据它并不知道。底层的TCP不会去理解上层的业务数据，只会根据缓冲区的实际情况进行数据包的拆分或重组，所以对于一个完整的业务信息，就可能会多次调用channelReadComplete。
Netty故障排查技巧
Moli_张的博客
06-04 967
接收不到消息 如果业务的 ChannelHandler 接收不到消息，可能的原因如下： 1）业务的解码 ChannelHandler 存在 BUG，导致消息解码失败，没有投递到后端； 2）业务发送的是畸形或者错误码流（例如长度错误），导致业务解码 ChannelHandler 无法正确解码出业务消息； 3）业务 ChannelHandler 执行了一些耗时或者阻塞操作，导致 Netty 的 NioEventLoop 被挂住，无法读取消息； 4）执行业务 ChannelHandler 的线程池队.
关于Netty中连接到了客户端，只调用了channelReadComplete，没走channelRead
fghjhdrf的博客
08-23 694
Netty
Netty中channelRead收不到自定义解码器的发来的数据
乌鸦东南飞
04-11 1万+
在netty中配置Decoder一定注意相互的影响 protected void initChannel(SocketChannel socketChannel) { ChannelPipeline pipeline = socketChannel.pipeline(); ByteBuf delimiter = Unpooled.copiedBuffer("$"
Netty
weixin_44044929的博客
08-13 1173
Netty面试题
netty channelRead 未自动执行
weixin_30852419的博客
05-21 5145
1 ServerBootstrap bootstrap = new ServerBootstrap(); 2 try { 3 bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class) 4 .childHa...
Netty源码分析之一次请求是如何到达channelRead的?
时光钟摆
08-22 3481
使用java nio做网络编程大致流程如下 这个流程有哪些可以优化的空间？ Netty是对java网络框架的包装，它本身肯定也会有类似的处理流程。必定在这个方面做了自己的优化处理 获得Selector 使用Netty的时候都会用到对应的EventLoopGroup,它实际上就完成了Selector 的初始化过程。 Netty自定义了SelectionKey 的集合，做了...
Netty项目学习笔记：实战心得与技巧
这部分内容会详细介绍如何自定义编解码器，以及Netty内置的一些编解码器的使用。 4. 通道事件处理：深入理解Netty中的各种事件和事件处理器ChannelHandler的作用。掌握如何通过编写ChannelHandler来处理不同的网络...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值