Netty -09- Netty 编解码器和 handler 的调用机制

最新推荐文章于 2023-01-17 16:12:48 发布

迷雾总会解

最新推荐文章于 2023-01-17 16:12:48 发布

阅读量247

点赞数

分类专栏：网络编程 java 文章标签： java netty 网络多线程

本文链接：https://blog.csdn.net/qq_44766883/article/details/107586865

版权

java 同时被 2 个专栏收录

56 篇文章 1 订阅

订阅专栏

网络编程

20 篇文章 0 订阅

订阅专栏

基本说明

netty 的组件设计：Netty 的主要组件有 Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipe 等
ChannelHandler 充当了处理入站和出站数据的应用程序逻辑的容器。例如，实现 ChannelInboundHandler 接口（或 ChannelInboundHandlerAdapter），你就可以接收入站事件和数据，这些数据会被业务逻辑处理。当要给客户端发送响应时，也可以从 ChannelInboundHandler 冲刷数据。业务逻辑通常写在一个或者多个 ChannelInboundHandler 中。ChannelOutboundHandler 原理一样，只不过它是用来处理出站数据的
ChannelPipeline 提供了 ChannelHandler 链的容器。以客户端应用程序为例，如果事件的运动方向是从客户端到服务端的，那么我们称这些事件为出站的，即客户端发送给服务端的数据会通过 pipeline 中的一系列 ChannelOutboundHandler，并被这些 Handler 处理，反之则称为入站的

编码解码器

当 Netty 发送或者接受一个消息的时候，就将会发生一次数据转换。入站消息会被解码：从字节转换为另一种格式（比如 java 对象）；如果是出站消息，它会被编码成字节
Netty 提供一系列实用的编解码器，他们都实现了 ChannelInboundHadnler 或者 ChannelOutboundHandler 接口。在这些类中，channelRead 方法已经被重写了。以入站为例，对于每个从入站 Channel 读取的消息，这个方法会被调用。随后，它将调用由解码器所提供的 decode()方法进行解码，并将已经解码的字节转发给 ChannelPipeline 中的下一个 ChannelInboundHandler。
不论解码器handler 还是编码器handler 即接收的消息类型必须与待处理的消息类型一致，否则该handler不会被执行
在解码器进行数据解码时，需要判断缓存区(ByteBuf)的数据是否足够，否则接收到的结果会期望结果可能不一致

解码器-ByteToMessageDecoder

关系继承图
由于不可能知道远程节点是否会一次性发送一个完整的信息，tcp 有可能出现粘包拆包的问题，这个类会对入站数据进行缓冲，直到它准备好被处理
一个关于 ByteToMessageDecoder 实例分析
```
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());
        }
    }
}
```
1. 这个例子，每次入站从ByteBuf中读取4字节，将其解码为一个int，然后将它添加到下一个List中。当没有更多元素可以被添加到该List中时，它的内容将会被发送给下一个ChannelInboundHandler。int在被添加到List中时，会被自动装箱为Integer。在调用readInt()方法前必须验证所输入的ByteBuf是否具有足够的数据
2. decode 执行分析图

Netty 的 handler 链的调用机制

使用自定义的编码器和解码器来说明 Netty 的 handler 调用机制

客户端发送 long -> 服务器
服务端发送 long -> 客户端

案例

server

public class Server {
    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)
                .childOption(ChannelOption.SO_KEEPALIVE,true)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ServerInitializer());

            ChannelFuture channelFuture = serverBootstrap.bind(new InetSocketAddress(50000)).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

serverInitializer

public class ServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();

        //入站的handler进行解码
        pipeline.addLast(new ByteToLongDecoder2());

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

        //自定义handler
        pipeline.addLast(new ServerHandler());
    }
}

serverHandler

public class ServerHandler extends SimpleChannelInboundHandler<Long> {
    /**
    * @Description 读取数据
    * @date 2020/7/24 17:56
    * @param ctx
    * @param msg
    * @return void
    */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("从客户端"+ctx.channel().remoteAddress()+"读到的Long数据："+msg);

        //给客户端发送一个long
        ctx.writeAndFlush(987654L);
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常"+cause.getMessage()+cause.getCause()+cause.getStackTrace());
        ctx.close();
    }
}

client

public class Client {
    public static void main(String[] args) {
        EventLoopGroup group=new NioEventLoopGroup();

        try {
            Bootstrap bootstrap=new Bootstrap();

            bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ClientInitializer());

            ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("127.0.0.1", 50000)).sync();

            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            group.shutdownGracefully();
        }
    }
}

ClientInitializer

public class ClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();



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

        //计入一个入站的handler，对数据进行解码
        pipeline.addLast(new ByteToLongDecoder());

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

clientHandler

public class ClientHandler extends SimpleChannelInboundHandler<Long> {


    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("发送数据...");

        //发送一个Long
        ctx.writeAndFlush(123456L);

        //        ctx.writeAndFlush(Unpooled.copiedBuffer("asdfzxcaaaaaaaaa", CharsetUtil.UTF_8));
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("收到服务器消息："+msg);
    }


}

LongToByteEncoder

public class LongToByteEncoder extends MessageToByteEncoder<Long> {

    /**
    * @Description 编码器
    * @date 2020/7/24 18:03
    * @param ctx
    * @param msg
    * @param out
    * @return void
    */
    @Override
    protected void encode(ChannelHandlerContext ctx, Long msg, ByteBuf out) throws Exception {
        System.out.println("LongToByteEncoder 的 encode 方法被调用...");
        System.out.println("msg="+msg);
        out.writeLong(msg);
    }
}

ByteToLongDecoder

public class ByteToLongDecoder extends ByteToMessageDecoder {

    /**
    * @Description TODO
    * @date 2020/7/24 17:52
    * @param ctx  上下文对象
    * @param in  入站的ByteBuf
    * @param out  List集合，讲解码后的数据传给下一个handler
    * @return void
    */
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        System.out.println("ByteToLongDecoder 的 decode 方法被调用...");
        //每次读取8个字节
        if(in.readableBytes()>=8){
            out.add(in.readLong());
        }
    }
}

运行

传输字符

使用上面的列子，客户端传输字符

@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    System.out.println("发送数据...");

    //发送一个Long
    //ctx.writeAndFlush(123456L);

    //发送16个字节
    ctx.writeAndFlush(Unpooled.copiedBuffer("asdfzxcaaaaaaaaa", CharsetUtil.UTF_8));
}

运行

当发送的是字符串的时候，客户端不会经过编码器，服务端会将二进制解码成Long。又因为我发送的字符有16个字节，所以解码的时候回进行两次解码

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

解码器-ReplayingDecoder

public abstract class ReplayingDecoder ~~extends ByteToMessageDecoder~~
ReplayingDecoder 扩展了 ByteToMessageDecoder 类，使用这个类，我们不必调用 **readableBytes()**方法。参数S 指定了用户状态管理的类型，其中 Void 代表不需要状态管理
应用实例：使用 ReplayingDecoder 编写解码器，对前面的案例进行简化

public class ByteToLongDecoder2 extends ReplayingDecoder<Void> {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        System.out.println("ByteToLongDecoder2 的 decode 方法被调用...");
        out.add(in.readLong());
    }
}

ReplayingDecoder 使用方便，但它也有一些局限性：
- 并不是所有的 ByteBuf 操作都被支持，如果调用了一个不被支持的方法，将会抛出一个 UnsupportedOperationException
- ReplayingDecoder 在某些情况下可能稍慢于 ByteToMessageDecoder，例如网络缓慢并且消息格式复杂时，消息会被拆成了多个碎片，速度变慢

其它编解码器

解码器

LineBasedFrameDecoder：这个类在 Netty 内部也有使用，它使用行尾控制字符（\n 或者\r\n）作为分隔符来解析数据
DelimiterBasedFrameDecoder：使用自定义的特殊字符作为消息的分隔符
HttpObjectDecoder：一个 HTTP 数据的解码器
LengthFieldBasedFrameDecoder：通过指定长度来标识整包消息，这样就可以自动的处理黏包和半包消息

编码器

迷雾总会解

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Netty -09- Netty 编解码器和 handler 的调用机制

基本说明netty 的组件设计：Netty 的主要组件有 Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipe 等ChannelHandler 充当了处理入站和出站数据的应用程序逻辑的容器。例如，实现 ChannelInboundHandler 接口（或 ChannelInboundHandlerAdapter），你就可以接收入站事件和数据，这些数据会被业务逻辑处理。当要给客户端发送响应时，也可以从 ChannelInb
复制链接

扫一扫