Netty使用MessagePack自定义编解码POJO对象实例

最新推荐文章于 2022-09-05 22:32:03 发布
最新推荐文章于 2022-09-05 22:32:03 发布
阅读量996 收藏 2
点赞数 1
分类专栏： java 文章标签： java netty MessagePack
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haoyue1014/article/details/88396705
版权

一、MessagePack

本文使用的MessagePack为0.8.13，相关知识参考MessagePack-0.8.13-msgpack-core。

MessagePack，官方描述：

It's like JSON.

but fast and small.

它想JSON，但更快更小。

1、maven依赖

<dependencies>
        <!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.32.Final</version>
        </dependency>

        <dependency>
            <groupId>org.msgpack</groupId>
            <artifactId>msgpack-core</artifactId>
            <version>0.8.13</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.msgpack/jackson-dataformat-msgpack -->
        <dependency>
            <groupId>org.msgpack</groupId>
            <artifactId>jackson-dataformat-msgpack</artifactId>
            <version>0.8.13</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.35</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.7.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.7.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.7.1</version>
        </dependency>

    </dependencies>

2、MessagePack序列化和反序列化

（1）创建实体类Persion


public class Person {

    private String name;

    private int age;

    private boolean sex;

    public Person(){}

    public Person(String name, int age, boolean sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    
//getter和set方法略
 
    @Override
    public String toString() {
        return "Person[name = " + name + ",age = " + age + ",sex = " + sex + "]";
    }
}

（2）将对象序列化成byte数组以及将byte数组反序列化为对象：

Person person = new Person("jemmy",18, true);
ObjectMapper mapper = new ObjectMapper(new MessagePackFactory());

byte[] bytes = mapper.writeValueAsBytes(person);
System.out.println(bytes.length);
System.out.println(Arrays.toString(bytes));
Person p = mapper.readValue(bytes, Person.class);
System.out.println(p);

（3）List序列化成byte数组和反序列化

List<Person> list = new ArrayList<Person>();
list.add(person);
list.add(new Person("tomy", 20, false));
byte[] listBytes = mapper.writeValueAsBytes(list);
System.out.println(listBytes.length);
System.out.println(Arrays.toString(listBytes));
System.out.println("===================>");

JavaType type = mapper.getTypeFactory().constructParametricType(ArrayList.class,Person.class);
List<Person> persons = mapper.readValue(listBytes, type);
System.out.println(persons);
System.out.println("==============================================>");

抽象成MessagePackUtil工具类，代码如下：

package com.jemmy.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.msgpack.jackson.dataformat.MessagePackFactory;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * MessagePack工具类
 * 1、实现对象转byte数组
 * 2、实现byte数组转对象
 * 3、实现byte数组转List
 */
public class MessagePackUtil {

    //静态对象
    private  static ObjectMapper mapper = new ObjectMapper(new MessagePackFactory());

    /**
     * 对象转byte数组，
     * @param obj
     * @param <T>
     * @return
     */
    public static <T> byte[] toBytes(T obj){

        try {
            return mapper.writeValueAsBytes(obj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * byte数组转List
     * @param bytes
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> List<T> toList(byte[] bytes, Class<T> clazz){
        List<T> list = null;

        try {
            list = mapper.readValue(bytes, MessagePackUtil.<T>List(clazz));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * byte数组转对象
     * @param bytes
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T toObject(byte[] bytes, Class<T> clazz) {
        try {
            return mapper.readValue(bytes, clazz);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 私有静态方法，获取List的实例化类型
     * @param clazz //List元素对象类型
     * @param <T>
     * @return
     */
    private static <T> JavaType List(Class<?> clazz){
        return mapper.getTypeFactory().constructParametricType(ArrayList.class, clazz);
    }
}

二、自定义编码器和解码器

MessagePack编码器开发，代码如下，参考《Netty权威指南》（第二版，高清，有需要的，评论区留邮箱）。

继承MessageToMessageDecoder，覆写decode方法，将channel中的msg读取出来，然后加入到List<Object>中

 

public class MsgPackDecoder extends MessageToMessageDecoder<ByteBuf> {

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

        byte[] bytes = new byte[msg.readableBytes()];
        msg.readBytes(bytes);
        out.add(MessagePackUtil.toObject(bytes, Object.class));
    }
}

MessagePack解码器开发，代码如下：

将msg对象序列化成byte数组，写入channel的ByteBuf缓冲区中。

public class MsgPackEncoder extends MessageToByteEncoder<Object> {

    protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) throws Exception {

       byte[] raw =  MessagePackUtil.toBytes(msg);

        out.writeBytes(raw);

    }
}

使用EchoServer案例使用和验证自定义的编解码器。

EchoServer代码：

package com.jemmy.chapter07.messagePack;


import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

public class EchoServer {

    private int port;

    public EchoServer(int port){
        this.port = port;
    }

    public void run(){

        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();

        try{
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 100)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //首先加入LengthFieldBasedFrameDecoder解码器，解决tcp粘包和拆包的问题
                            ch.pipeline().addLast("frameDecoder",
                                    new LengthFieldBasedFrameDecoder(65535, 0,2,0,2));
                            //加入MessagePackDcoder
                            ch.pipeline().addLast("msgPack decoder", new MsgPackDecoder());
                            //加入LengthFieldPrepender编码器，解决tcp粘包和拆包的问题
                            ch.pipeline().addLast("frameEncoder", new LengthFieldPrepender(2));
                            //加入MessagePackEncoder
                            ch.pipeline().addLast("msgPack encoder", new MsgPackEncoder());
                            //业务逻辑
                            ch.pipeline().addLast(new EchoServerHandler());
                        }
                    });
            System.out.println("Echo Server start at port : " + port);
            ChannelFuture future = serverBootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) {

        int port = 8080;
        if (args != null && args.length > 1){
            try{
                port = Integer.valueOf(args[0]);
            }catch (NumberFormatException e){
                e.printStackTrace();
            }
        }
        new EchoServer(port).run();
    }
}

EchoServerHandler代码：

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class EchoServerHandler extends ChannelInboundHandlerAdapter {


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //由于MessagePack编解码器的存在，到此处的msg，已经是Person对象，可以强转成Persion对象
        System.out.println("The Server Recieve message:" + msg);
        ctx.writeAndFlush(msg); //收到消息后直接返回给Client
    }

    /**
     * 异常的时候打印栈和关闭channel上下文对象
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

EchoClient代码：（代码与服务端类似）

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;


import java.net.InetSocketAddress;

public class EchoClient {
    private int port;
    private String host;

    public EchoClient(String host, int port){
        this.port = port;
        this.host = host;
    }

    public void run(){

        EventLoopGroup group = new NioEventLoopGroup();

        try{
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .remoteAddress(new InetSocketAddress(host, port))
                    .option(ChannelOption.TCP_NODELAY, true)
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast("frameDecoder",
                                    new LengthFieldBasedFrameDecoder(65535, 0,2,0,2));
                            ch.pipeline().addLast("msgPack decoder", new MsgPackDecoder());
                            ch.pipeline().addLast("frameEncoder", new LengthFieldPrepender(2));
                            ch.pipeline().addLast("msgPack encoder", new MsgPackEncoder());
                            ch.pipeline().addLast(new EchoClientHandler(10));
                        }
                    });

            ChannelFuture future = bootstrap.connect(host, port).sync();
            future.channel().closeFuture().sync();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        new EchoClient("127.0.0.1", 8080).run();
    }
}

EchoClientHandler代码：

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class EchoClientHandler extends ChannelInboundHandlerAdapter {

    private int sendNumber;

    public EchoClientHandler(int sendNumber){
        this.sendNumber = sendNumber;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        
        //发送对象数据给服务端
        Person[] persons = persionInfo();
        for (Person p:persons) {
            ctx.write(p);
        }
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //打印服务端发送的数据
        System.out.println("Client recieve message:" + msg);

    }

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

    /**
     * 初始化发送的消息对象
     * @return
     */
    private Person [] persionInfo(){
        Person[] persons = new Person[sendNumber];
        Person person = null;

        for (int i = 0; i < sendNumber ; i++) {
            person = new Person("Jemmy===>" + i, 10 + i, true);
            persons[i] = person;
        }
        return persons;
    }
}

代码结构：

测试结果：

服务端打印：

The Server Recieve message:{name=Jemmy===>0, age=10, sex=true}
The Server Recieve message:{name=Jemmy===>1, age=11, sex=true}
The Server Recieve message:{name=Jemmy===>2, age=12, sex=true}
The Server Recieve message:{name=Jemmy===>3, age=13, sex=true}
The Server Recieve message:{name=Jemmy===>4, age=14, sex=true}
The Server Recieve message:{name=Jemmy===>5, age=15, sex=true}
The Server Recieve message:{name=Jemmy===>6, age=16, sex=true}
The Server Recieve message:{name=Jemmy===>7, age=17, sex=true}
The Server Recieve message:{name=Jemmy===>8, age=18, sex=true}
The Server Recieve message:{name=Jemmy===>9, age=19, sex=true}

客户端打印：

Client recieve message:{name=Jemmy===>0, age=10, sex=true}
Client recieve message:{name=Jemmy===>1, age=11, sex=true}
Client recieve message:{name=Jemmy===>2, age=12, sex=true}
Client recieve message:{name=Jemmy===>3, age=13, sex=true}
Client recieve message:{name=Jemmy===>4, age=14, sex=true}
Client recieve message:{name=Jemmy===>5, age=15, sex=true}
Client recieve message:{name=Jemmy===>6, age=16, sex=true}
Client recieve message:{name=Jemmy===>7, age=17, sex=true}
Client recieve message:{name=Jemmy===>8, age=18, sex=true}
Client recieve message:{name=Jemmy===>9, age=19, sex=true}

 

haoyue1014
关注
专栏目录
netty自定义编码解码器解决拆包粘包
dingruibao的博客
11-11 1262
通过发送数据时同时发送数据长度，解决拆包粘包问题 自定义编码器、解码器 消息实体类： public class MyMessage { private int len;//发送内容的长度 private byte[] content;//发送的内容 public int getLen() { return len; } public void setLen(int len) { this.len = len; }
msgpack4z-core：用于Scala的基于类型类的功能性msgpack serializerdeserializer。 支持scala.js和scala本机msgpack.org [Scala]
02-17
msgpack4z-core 例子 最新的稳定版本 libraryDependencies + = " com.github.xuwei-k " %% " msgpack4z-core " % " 0.5.1 " 依赖图
DotNetty系列四：自定义协议，序列化类库MessagePack,项目代码
02-25
https://blog.csdn.net/qq_34719168/article/details/87915825 博文项目源代码
netty使用msgpack自定义编解码器实现序列化操作
学习之余随便记记
11-01 454
导入依赖 &lt;dependency&gt; &lt;groupId&gt;org.msgpack&lt;/groupId&gt; &lt;artifactId&gt;msgpack&lt;/artifactId&gt; &lt;version&gt;0.6.12&lt;/version&gt;
dotnet 使用 MessagePack 序列化对象
极客神殿
09-05 619
如果在使用的时候发现下面代码，那么很多时候都是因为没有在类上面添加特性，需要修改类为公开的，然后在类上面添加。在序列化比较大的类如果序列化到文件，那么因为文件读写的性能，可以看到。这个库能序列的内容不多，大多数时候建议使用的序列的类都是只有基础的。的好处只是序列化出来的内容的长度小，但是从性能等方面，其实和。相比这个库提供了二进制的序列化，序列化之后的内容长度比。差别不大，在序列化简单的类的时候，可以看到。下面写一个简单的方法，将会对这个类序列化。的内容，可以使用下面方法将。序列化和反序列化，和。
Netty4编写服务器客户端，自定义编解码，发送自定义消息
02-24
根据给定的消息协议，自己定义一个消息类，编写好服务端与客户端，自定义好编解码器，在客户端发送此消息，服务端获取消息并向客户端发送同样格式的消息；导入Eclipse maven项目运行即可跑通。
Netty 整合 MessagePack 序列化框架 + LengthFieldBasedFrameDecoder 自定义解码器
蚩尤后裔-汪茂雄
11-25 1362
目录 环境准备及说明 MessagePack 编解码器 MessagePack 编码器 MessagePack 解码器 POJO User Netty 网络通信 服务端 客户端 运行测试 环境准备及说明 如果是导入二进制开发包，则如下所示： 需要开发包的可以参考《MessagePack 开发入门详解》。 如果是 Maven 项目，则添加如下依赖： &lt...
Netty+自定义Protobuf编解码器
07-13
将Netty与自定义的Protobuf编解码器结合使用，可以实现更高效、更灵活的网络通信。 首先，让我们详细了解一下Netty中的编解码器。在Netty中，编解码器是处理网络数据流的关键组件，它们负责将原始字节流转换为易于...
Netty之自定义编解码器.zip
最新发布
12-23
本压缩包文件"Netty之自定义编解码器.zip"着重讨论的是如何在Netty中自定义编解码器，这是Netty框架中的一个重要组成部分，用于将应用程序数据转换为网络传输的数据格式，以及将接收到的网络数据转换回应用程序可以...
Netty中Marshalling编解码自定义栈应用
08-12
在 Netty 中，编解码器是处理数据传输的关键组件，它们负责将原始字节流转换为有意义的对象，反之亦然。本文将深入探讨 Marshalling 编解码器在 Netty 中的应用及其自定义实现。 Marshalling 是一种序列化技术，它...
Msgpack序列化
热门推荐
深之JohnChen的专栏
12-02 1万+
netty Msgpack序列化
msgpack工具库二进制格式序列化反序列化
03-27
msgpack工具库支持二进制格式的序列化和反序列化，速度快，效率更好。
org.msgpack.core.MessagePacker
fghydx的专栏
07-17 1999
Search    Top APIs    Top 16 Utility Classes     Program Creek     Simple JavaLog in     Sign up (Free now!)     3695 users Top Related Classes java.util.Iterator
Netty进阶之路-MessagePack编解码
a294634473的博客
05-05 647
Netty进阶之路-MessagePack编解码前言MessagePack优点Netty客户端--MessagePack编解码Netty客户端--MessagePack编码Netty客户端--MessagePack解码Netty客户端--编解码使用Netty服务端--MessagePack编解码Netty服务端--MessagePack解码Netty服务端--MessagePack编码Netty服...
探险新型序列化工具MessagePack
一群专业码农的笔记本
09-02 563
MessagePack是最近一个比较热门与Json做比较的序列化工具，它的优点是相比于json，序列化速度更快和序列化之后的字节数组更小，正如它的官网https://msgpack.org/卖的广告所说 It’s like JSON. but fast and small. 下面我们以三个方面来对MessagePack做一个初步的探险 一.What is MessagePack...
java高效序列化,MessagePack for Java 是一个高效的二进制序列化格式
weixin_29428137的博客
03-16 247
MessagePack for JavaMessagePack is a binary serialization format. If you need a fast and compact alternative of JSON, MessagePack is your friend. For example, a small integer can be encoded in a singl...
MessagePack Java的使用
黑夜舞者的专栏
12-02 1万+
MessagePack是一个高效的二进制序列化格式。它让你像JSON一样可以在各种语言之间交换数据。但是它比JSON更快、更小。 使用Maven添加MessagePack的依赖： org.msgpack msgpack ${msgpack.version} 在本篇文章中使用的版本为 0.6.6 首先创建一个实体类UserInfo（注意对类加上Message注解） imp
netty自定义协议解析
爱音乐的程序猿的博客
02-19 1496
文章目录前言一、ByteToMessageDecoder二、使用步骤1.引入库2.读入数据总结 前言 Netty是由JBOSS提供的一个java开源框架，现为 Github上的独立项目。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。 也就是说，Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过
spring boot redis使用msgpack作为序列化
葡萄园下Debug的博客
05-11 2811
1、首先引入msgpack所需要的包&lt;dependency&gt; &lt;groupId&gt;org.msgpack&lt;/groupId&gt; &lt;artifactId&gt;msgpack-core&lt;/artifactId&gt; &lt;version&gt;0.8.13&lt;/version&gt; &lt;/dependency&
Netty编解码框架：Java序列化与Protobuf对比
Netty框架内部使用了可配置的编解码器，允许开发者自定义处理不同类型的请求和响应。例如，可以使用ProtoBuf编解码器处理Protobuf消息，或者创建自定义编解码器来适应特殊的业务需求。此外，Netty还支持基于内存的编...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值