欢迎您的访问
专注于分享最有价值的互联网技术干货

十九、如何自定义编解码器

几个T的资料等你来白嫖
双倍快乐

如何自定义编解码器

1. 前言

上一节我们一节了解了什么是编码解码、序列化和反序列化了,并且留有一道思考题,本节内容主要是深入解析该思考题。

思考题:能否把我们的编码和解码封装成独立的 Handler 呢?那么应该如何去封装呢?

2. 为什么要封装独立 Handler?

即使我们把编码和解码封装成了方法,但是还是需要在 Handler 业务逻辑里面进行手工调用,虽然看似不怎么影响,但是业务 Handler 不够纯粹,应该让 Handler 只是专心的负责处理业务逻辑就好。

实例:

ch.pipeline().addLast(new MyEncoderHandler());//解码Handler
ch.pipeline().addLast(new MyDecoderHandler());//编码Handler
ch.pipeline().addLast(new MyBusiHandler());//业务Handler

public class MyBusiHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //1.接受参数,可以直接强转
        UserReq userReq=(UserReq)msg;

        //2.相应数据,直接写对象
        UserRes res=new UserRes();
        res.setCode(0);
        res.setMsg("接受成功");
        ctx.writeAndFlush(res);
    }
}

通过以上的代码,我们把编码和解码封装成两个独立的 Handler,并且加入到 ChannelPipeline 里面进行管理。在我们的业务 Handler 里面就可以直接操作实体数据,无需手工转换成字节数组了。

思考:那么如何进行封装 Handler 呢?

3. StringDecoder 和 StringEncoder

3.1 简单使用

StringDecoder 和 StringEncoder 是 Netty 为我们提供的专门针对普通字符串的解码和编码器,使用起来非常的简单。

客户端直接发送字符串。

实例:

ch.pipeline().addLast(new StringEncoder());
ch.pipeline().addLast(new StringDecoder());
ch.pipeline().addLast(new ClientTestHandler());

public class ClientTestHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //客户端直接写字符串,没有任何的数据加工
        ctx.channel().writeAndFlush("hello world");
    }
}

服务端直接强转字符串。

实例:

ch.pipeline().addLast(new StringEncoder());
ch.pipeline().addLast(new StringDecoder());
ch.pipeline().addLast(new ServerTestHandler());

public class ServerTestHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //直接把msg转换成String类型
        String str=msg.toString();
        System.out.println("str="+str);
    }
}

总结,这种模式开发起来实在太方便了,无需做数据的加工,我们还是按照我们熟悉的方式去写代码,非常的方便。

但是,它只是支持普通的字符串类型进行编码和解码而已,对于复杂的引用类型则无效。

3.2 大体流程

其实原理是非常的简单的,请看下图。

20210320204819574.jpg
执行流程说明:

  1. StringDecoder 必须放在业务 Handler 之前,因为都是 InboundHandler,需要按顺序执行;
  2. StringEncoder 放在业务 Handler 之前,则可以使用 ctx.writeAndFlush () 输出数据,也可以使用 ctx.channel ().writeAndFlus () 输出数据(ChannelHandler 已经讲过原理了);
  3. StringEncoder 放在业务 Handler 之后,则只能使用 ctx.channel().writeAndFlush() 输出数据。

3.3 源码阅读

思考:StringDecoder 和 StringEncoder 到底怎么实现的呢?

StringDecoder 源码:

@Sharable
public class StringDecoder extends MessageToMessageDecoder<ByteBuf> {
    protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
        //直接msg.toString()
        out.add(msg.toString(this.charset));
    }
}

发现 StringDecoder 的源码非常的简单,直接.toString() 转换即可。

StringEncoder 源码:

@Sharable
public class StringEncoder extends MessageToMessageEncoder<CharSequence> {
    protected void encode(ChannelHandlerContext ctx, CharSequence msg, List<Object> out) throws Exception {
        if (msg.length() != 0) {
            //继续跟进源码
            out.add(ByteBufUtil.encodeString(ctx.alloc(), CharBuffer.wrap(msg), this.charset));
        }
    }
}

public static ByteBuf encodeString(ByteBufAllocator alloc, CharBuffer src, Charset charset) {
    //继续跟进源码
    return encodeString0(alloc, false, src, charset, 0);
}

保留核心源码

static ByteBuf encodeString0(ByteBufAllocator alloc, boolean enforceHeap, CharBuffer src, Charset charset, int extraCapacity) {
    CharsetEncoder encoder = CharsetUtil.encoder(charset);
    int length = (int)((double)src.remaining() * (double)encoder.maxBytesPerChar()) + extraCapacity;
    boolean release = true;

    //1.创建ByteBuf分配器
    ByteBuf dst;
    if (enforceHeap) {
        dst = alloc.heapBuffer(length);
    } else {
        dst = alloc.buffer(length);
    }

    ByteBuf var12;
    try {
        //2.得到NIO的ByteBuffer【跟进Netty的ByteBuf基本上一样】
        ByteBuffer dstBuf = dst.internalNioBuffer(0, length);
        int pos = dstBuf.position();

        //3.把内容写得NIO的ByteBuffer
        CoderResult cr = encoder.encode(src, dstBuf, true);
        cr = encoder.flush(dstBuf);

        //4.更新ByteBuf的写指针writeIndex
        dst.writerIndex(dst.writerIndex() + dstBuf.position() - pos);

        //5.给var12赋值
        var12 = dst;
    } catch (CharacterCodingException var16) {
        throw new IllegalStateException(var16);
    }
    return var12;
}

大致流程就是把字符串内容转换成 NIO 的 ByteBuffer,这里大致知道整个流程即可,不用深究每行代码的意思,其实 Netty 的 ByteBuf 底层就是基于 ByteBuffer 进行封装的。

3. 自定义编解码器

通过上面 Demo 的学习,以及 StringDecoder 和 StringEncoder 两个类的学习,相信大家更加能理解编解码器了,毕竟 StringDecoder 和 StringEncoder 从字面意思也能理解它们是针对字符串格式的,如果我们想要传递一个实体那么怎么办呢?

主要解决方案有两种:

方案一: 把实体转换成 json 格式字符串,然后依然使用 StringDecoder 和 StringEncoder 编解码器,但是每次手工转换和解析,非常的麻烦;
方案二: 自定义针对实体的编解码器,并且加入到双向链表里面,这样就可以传递自定义实体了。

下面主要讲解如何实现针对实体的编解码器:

3.1 实体

实例:

@Data
public class User {
    private String name;
    private Integer age;
}

3.2 编码器

核心步骤:

  1. 继承 MessageToByteEncoder,重写 encode 方法;
  2. 把 User 对象转换成 byte [];
  3. 把 byte [] 写到 ByteBuf。

实例:

public class MyEncoder extends MessageToByteEncoder<User> {
    protected void encode(ChannelHandlerContext channelHandlerContext, 
                          User user, 
                          ByteBuf byteBuf) throws Exception {

        //1.对象流
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(user);
        byte[] bytes=os.toByteArray();

        //2.关闭流
        oos.close();
        os.close();

        //3.写到ByteBuf容器
        byteBuf.writeBytes(bytes);
    }
}

3.3 解码器

核心步骤:

  1. 继承 ByteToMessageDecoder,重写 decode 方法;
  2. 自定义一个 byte [] 数组,长度是 ByteBuf 的可读长度;
  3. 把 ByteBuf 转换成 User 实体。

实例:

public class MyDecoder extends ByteToMessageDecoder {
    protected void decode(ChannelHandlerContext channelHandlerContext, 
                          ByteBuf byteBuf, 
                          List<Object> list) throws Exception {
        //1.定义byte[],长度为ByteBuf可读长度
        byte[] bytes=new byte[byteBuf.readableBytes()];
        //2.往byte[]读取数据
        byteBuf.readBytes(bytes);
        //3.对象流
        ByteArrayInputStream is=new ByteArrayInputStream(bytes);
        ObjectInputStream iss=new ObjectInputStream(is);
        User user=(User)iss.readObject();
        //4.关闭流
        is.close();
        iss.close();
        //5.添加到集合
        list.add(user);
    }
}

3.4 添加到 Pipeline

实例:

.childHandler(new ChannelInitializer<NioSocketChannel>() {
    protected void initChannel(NioSocketChannel ch) {
        //1.解码器
        ch.pipeline().addLast(new MyDecoder());
        //2.编码器
        ch.pipeline().addLast(new MyEncoder());
        //3.业务Handler
        ch.pipeline().addLast(new ServerTestHandler());
    }
});

4. 小结

通常情况下,需要把编解码器分别独立封装成 Handler,并且加入到 ChannelPipeline 进行管理,主要目的是简化繁琐的编码和解码的步骤,让业务 Handler 更加专注去处理业务逻辑,更加的符合开发人员的习惯。

本节主要掌握以下两点内容

  1. 如果针对字符串,那么可以使用 Netty 内置的编解码器,分别是 StringEncoder 和 StringDecoder;
  2. 如果是其它引用类型,主要有两种方式,①转换成字符串格式;②自定义编解码器。
赞(1) 打赏
版权归原创作者所有,任何形式转载请联系我们:大白菜博客 » 十九、如何自定义编解码器

评论 抢沙发

8 + 6 =
  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏