Netty -08- Google Protobuf

最新推荐文章于 2023-01-09 15:53:27 发布
最新推荐文章于 2023-01-09 15:53:27 发布
阅读量172 收藏
点赞数
分类专栏： 网络编程 java 文章标签： java netty 网络 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44766883/article/details/107586845
版权

编码和解码的基本介绍

  • 编写网络应用程序时，因为数据在网络中传输的都是二进制字节码数据，在发送数据时就需要编码，接收数据 时就需要解码
  • codec(编解码器) 的组成部分有两个：decoder(解码器)和 encoder(编码器)。encoder 负责把业务数据转换成字节 码数据，decoder 负责把字节码数据转换成业务数据


Netty 本身的编码解码的机制和问题分析

  1. Netty 自身提供了一些 codec(编解码器)

  2. Netty 提供的编码器

    • StringEncoder，对字符串数据进行编码

    • ObjectEncoder，对 Java 对象进行编码

    • …

  3. Netty 提供的解码器

    • StringDecoder, 对字符串数据进行解码
    • ObjectDecoder，对 Java 对象进行解码
    • …

  4. Netty 本身自带的 ObjectDecoder 和 ObjectEncoder 可以用来实现 POJO 对象或各种业务对象的编码和解码，尚硅谷 Netty 核心技术及源码剖析 底层使用的仍是 Java 序列化技术 , 而 Java 序列化技术本身效率就不高，存在如下问题

    • 无法跨语言
    • 序列化后的体积太大，是二进制编码的 5 倍多
    • 序列化性能太低

  5. 引出 新的解决方案 [Google 的 Protobuf]


Protobuf

  1. Protobuf 是 Google 发布的开源项目，全称 Google Protocol Buffers，是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC[远程过程调用 remote procedure call ] 数据交换格式
  2. 目前很多公司 由http+json 转为了 tcp+protobuf
  3. Protobuf 是以 message 的方式来管理数据的.
  4. 支持跨平台、跨语言，即[客户端和服务器端可以是不同的语言编写的] （支持目前绝大多数语言，例如 C++、 C#、Java、python 等）
  5. 高性能，高可靠性
  6. 使用 protobuf 编译器能自动生成代码，Protobuf 是将类的定义使用.proto 文件进行描述。说明，在 idea 中编 写 .proto 文件时，会自动提示是否下载 .ptotot 编写插件. 可以让语法高亮。
  7. 然后通过 protoc.exe 编译器根据.proto 自动生成.java 文件
  8. protobuf 使用示意图

参考文档 : https://developers.google.com/protocol-buffers/docs/proto


单个pojo

  1. 客户端可以发送一个 Student PoJo 对象到服务器 (通过 Protobuf 编码)
  2. 服务端能接收 Student PoJo 对象，并显示信息(通过 Protobuf 解码)

server
public class Server {
    public static void main(String[] args) throws IOException {
        //创建BossGroup和WorkerGroup
        //bossGroup和workerGroup含有的子线程的个数，默认为cpu核数*2
        EventLoopGroup bossGroup=new NioEventLoopGroup(5);
        EventLoopGroup workerGroup=new NioEventLoopGroup();

        //创建服务器端的启动对象，配置参数
        ServerBootstrap  bootstrap=new ServerBootstrap();

        try {
            //使用链式编程来进行设置
            bootstrap.group(bossGroup,workerGroup)  //设置两个线程
                .channel(NioServerSocketChannel.class)  //使用NioServerSocketChannel，作为服务器的通道实现
                .option(ChannelOption.SO_BACKLOG,128)  //设置线程队列里连接个数
                .childOption(ChannelOption.SO_KEEPALIVE,true)//设置保持连接状态
                .childHandler(new ChannelInitializer<SocketChannel>() {  //handler对应的是boosGruop，childHandler对应的是workerGroup
                    //给pipeline设置处理器
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();

                        //加入解码器
                        //指定对哪种对象进行解码
                        pipeline.addLast("decoder",new ProtobufDecoder(StudentPOJO.Student.getDefaultInstance()));

                        pipeline.addLast(new ServerHandler());
                    }
                });  //给我们的workerGroup的EventLoop对应的管道设置处理器
            System.out.println("服务器 is ready ...");

            //绑定一个端口并且同步，生成一个ChannelFuture对象
            ChannelFuture cf = bootstrap.bind(6668).sync();

            //给 cf 注册监听器，监控我们关心的事件
            cf.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if(future.isSuccess()){
                        System.out.println("监听端口成功");
                    }else{
                        System.out.println("监听端口失败");
                    }
                }
            });

            //对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

serverHandler
public class ServerHandler extends SimpleChannelInboundHandler<StudentPOJO.Student> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, StudentPOJO.Student msg) throws Exception {
        System.out.println("客户端发送的数据："+msg.getId()+"："+msg.getName());
    }

    /**
    * @Description 数据读取完毕
    * @date 2020/7/23 10:46
    * @param ctx  
    * @return void
    */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //将数据写入到缓冲并刷新
        //一般来讲，我们队发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer(new Date().toString()+":"+"hello,客户端",CharsetUtil.UTF_8));
    }

    /**
    * @Description 处理异常，一般是需要管理通道
    * @date 2020/7/23 11:13
    * @param ctx
    * @param cause
    * @return void
    */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.channel().close();
    }
}

client
public class Client {
    public static void main(String[] args) {
        //客户端需要一个事件循环组
        EventLoopGroup eventExecutors=new NioEventLoopGroup();

        try {
            //创建客户端启动对象
            Bootstrap bootstrap=new Bootstrap();

            //设置相关参数
            bootstrap.group(eventExecutors) //设置线程组
                .channel(NioSocketChannel.class) //设置客户端通道的实现类（反射）
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();

                        //加入编码器
                        pipeline.addLast("encoder",new ProtobufEncoder());
                        pipeline.addLast(new ClientHandler());     //加入自己的处理器
                    }
                });
            System.out.println("客户端 ok...");

            //启动客户端去连接服务器端
            //关于ChannelFuture要分析，涉及到netty的异步模型
            ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("127.0.0.1", 6668)).sync();

            //关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            eventExecutors.shutdownGracefully();
        }
    }
}

clientHandler
public class ClientHandler extends ChannelInboundHandlerAdapter {

    /**
    * @Description 当通道就绪时会触发该方法
    * @date 2020/7/23 11:27
    * @param ctx
    * @return void
    */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        StudentPOJO.Student student = StudentPOJO.Student.newBuilder().setId(4).setName("重庆刘德华,香港徐大虾").build();

        ctx.writeAndFlush(student);
    }

    /**
    * @Description 当通道有读取事件时，会触发
    * @date 2020/7/23 11:29
    * @param ctx
    * @param msg
    * @return void
    */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf=(ByteBuf)msg;
        System.out.println("服务器回复的消息："+((ByteBuf) msg).toString(CharsetUtil.UTF_8));
        System.out.println("服务器的地址："+ctx.channel().remoteAddress());
    }
}

Student.proto
syntax= "proto3";  //版本
option java_outer_classname="StudentPOJO"; //生成的外部类名
message Student{
    int32 id=1;
    string name=2;
}

操作

protoc.exe --java_out=. Student.proto


运行


多个pojo

server
public class Server {
    public static void main(String[] args) throws IOException {
        //创建BossGroup和WorkerGroup
        //bossGroup和workerGroup含有的子线程的个数，默认为cpu核数*2
        EventLoopGroup bossGroup=new NioEventLoopGroup(5);
        EventLoopGroup workerGroup=new NioEventLoopGroup();

        //创建服务器端的启动对象，配置参数
        ServerBootstrap  bootstrap=new ServerBootstrap();

        try {
            //使用链式编程来进行设置
            bootstrap.group(bossGroup,workerGroup)  //设置两个线程
                .channel(NioServerSocketChannel.class)  //使用NioServerSocketChannel，作为服务器的通道实现
                .option(ChannelOption.SO_BACKLOG,128)  //设置线程队列里连接个数
                .childOption(ChannelOption.SO_KEEPALIVE,true)//设置保持连接状态
                .childHandler(new ChannelInitializer<SocketChannel>() {  //handler对应的是boosGruop，childHandler对应的是workerGroup
                    //给pipeline设置处理器
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();

                        //加入解码器
                        //指定对哪种对象进行解码
                        pipeline.addLast("decoder",new ProtobufDecoder(MyDataInfo.MyMessage.getDefaultInstance()));


                        pipeline.addLast(new ServerHandler());
                    }
                });  //给我们的workerGroup的EventLoop对应的管道设置处理器
            System.out.println("服务器 is ready ...");

            //绑定一个端口并且同步，生成一个ChannelFuture对象
            ChannelFuture cf = bootstrap.bind(6668).sync();

            //给 cf 注册监听器，监控我们关心的事件
            cf.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if(future.isSuccess()){
                        System.out.println("监听端口成功");
                    }else{
                        System.out.println("监听端口失败");
                    }
                }
            });

            //对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

serverHandler
public class ServerHandler extends SimpleChannelInboundHandler<MyDataInfo.MyMessage> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MyDataInfo.MyMessage msg) throws Exception {
        //根据dataType，显示不同的信息
        MyDataInfo.MyMessage.DateType dateType=msg.getDateType();

        if(dateType==MyDataInfo.MyMessage.DateType.StudentType){
            MyDataInfo.Student student=msg.getStudent();
            System.out.println("学生的信息:"+student.getId()+"："+student.getName());
        }else if(dateType==MyDataInfo.MyMessage.DateType.WorkerType){
            MyDataInfo.Worker worker=msg.getWorker();
            System.out.println("工人的信息："+worker.getName()+"："+worker.getAge());
        }else{
            System.out.println("传输的类型不正确");
        }
    }

    /**
    * @Description 数据读取完毕
    * @date 2020/7/23 10:46
    * @param ctx  
    * @return void
    */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //将数据写入到缓冲并刷新
        //一般来讲，我们队发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer(new Date().toString()+":"+"hello,客户端",CharsetUtil.UTF_8));
    }

    /**
    * @Description 处理异常，一般是需要管理通道
    * @date 2020/7/23 11:13
    * @param ctx
    * @param cause
    * @return void
    */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.channel().close();
    }
}

client
public class Client {
    public static void main(String[] args) {
        //客户端需要一个事件循环组
        EventLoopGroup eventExecutors=new NioEventLoopGroup();

        try {
            //创建客户端启动对象
            Bootstrap bootstrap=new Bootstrap();

            //设置相关参数
            bootstrap.group(eventExecutors) //设置线程组
                .channel(NioSocketChannel.class) //设置客户端通道的实现类（反射）
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();

                        //加入编码器
                        pipeline.addLast("encoder",new ProtobufEncoder());
                        pipeline.addLast(new ClientHandler());     //加入自己的处理器
                    }
                });
            System.out.println("客户端 ok...");

            //启动客户端去连接服务器端
            //关于ChannelFuture要分析，涉及到netty的异步模型
            ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("127.0.0.1", 6668)).sync();

            //关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            eventExecutors.shutdownGracefully();
        }
    }
}

clientHandler
public class ClientHandler extends ChannelInboundHandlerAdapter {

    /**
    * @Description 当通道就绪时会触发该方法
    * @date 2020/7/23 11:27
    * @param ctx
    * @return void
    */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        int random = new Random().nextInt(3);
        MyDataInfo.MyMessage myMessage = null;
        System.out.println(random);
        if(random==0){
            myMessage=MyDataInfo.MyMessage.newBuilder().setDateType(MyDataInfo.MyMessage.DateType.StudentType)
                .setStudent(MyDataInfo.Student.newBuilder().setName("重庆刘德华").setId(2).build()).build();
        }else{
            myMessage=MyDataInfo.MyMessage.newBuilder().setDateType(MyDataInfo.MyMessage.DateType.WorkerType)
                .setWorker(MyDataInfo.Worker.newBuilder().setName("香港徐大虾").setAge(21).build()).build();
        }


        ctx.writeAndFlush(myMessage);
    }

    /**
    * @Description 当通道有读取事件时，会触发
    * @date 2020/7/23 11:29
    * @param ctx
    * @param msg
    * @return void
    */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf=(ByteBuf)msg;
        System.out.println("服务器回复的消息："+((ByteBuf) msg).toString(CharsetUtil.UTF_8));
        System.out.println("服务器的地址："+ctx.channel().remoteAddress());
    }
}

Message.proto
syntax = "proto3";
option optimize_for= SPEED;  //快速解析
option java_package="top.codekiller.test.nettty.codec2"; //指定生成到哪个包下
option java_outer_classname="MyDataInfo";  //外部类名称

//protobuf 可以使用message管理其它的message
message MyMessage{
    //定义一个枚举
    enum DateType{
        StudentType=0;  //在proto3 要求enum的编号从0开始
        WorkerType=1;
    }

    //用data_type 来标识传的是哪一个枚举类型
    DateType date_type=1;

    //表示每次枚举类型最多只能出现其中的一个，节省空间
    oneof dataBody{
        Student student=2;
        Worker worker=3;
    }
}

message Student{
    int32 id=1;
    string name=2;
}

message Worker{
    string name=1;
    int32 age=2;
}

操作

 👉 查看操作


运行


迷雾总会解
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Google Protobuf的Netty编解码技术
08-11
NULL 博文链接：https://hbxflihua.iteye.com/blog/2231878
netty-protobuf:使用 Netty 4.0.26 和 Google Protocol Buffer 2.6.1 发送图像的示例应用程序
06-15
netty-protobuf 使用 Netty 4.0.26 和 Google Protocol Buffer 2.6.1 发送图像的示例应用程序。 #运行应用程序的步骤 在 Eclipse 中导入项目 将 .png 图像下载到您的桌面或您希望该文件用于客户端的任何位置。 ...
一起学Netty（十）之 Netty使用Google的ProtoBuf
热门推荐
BazingaLyncc
05-11 2万+
protobuf是由Google开发的一套对数据结构进行序列化的方法，可用做通信协议，数据存储格式，等等。其特点是不限语言、不限平台、扩展性强 Netty也提供了对Protobuf的天然支持，我们今天就写一个简单的示例，简单地了解一下Netty对Google的protoBuf的支持 我们的示例场景很简单的：客户端发送一个信息，这个信息用Protobuf来做序列化，然后服务器端接
Netty集成Google ProtoBuf
人过留名 雁过留声
08-19 344
集成步骤： 1、编写 .proto 文件 编写 netty_demo.proto 文件，内容如下 syntax ="proto2"; package com.github.mgljava.protobuf.netty; option optimize_for = SPEED; option java_package = "com.github.mgljava.protobuf.netty"; ...
Netty 使用 Google 的 ProtoBuf 来传输数据
qq_39116472的博客
09-15 337
ProtoBuf 是 google 的一个文件传输的协议。
【Netty】——整合Google Protobuf
Wonder ZH
07-22 602
Google Protobuf 简介 protobuf是google提供的一个开源序列化框架，类似于XML，JSON这样的数据表示语言，其最大的特点是基于二进制，因此比传统的XML表示高效短小得多。虽然是二进制数据格式，但并没有因此变得复杂，开发人员通过按照一定的语法定义结构化的消息格式，然后送给命令行工具，工具将自动生成相关的类，可以支持php、java、c++、python等语言环境。通过将这些类包含在项目中，可以很轻松的调用相关方法来完成业务消息的序列化与反序列化工作。 protobuf...
netty基于protobuf的简单示例
10-26
写了一个简单的netty server和client，传输协议是google protobuf。上传文件主要包括源码以及转换proto文件的工具.
netty protobuf序列化 推送 android客户端
02-22
netty protobuf序列化对象 推送 android客户端，压缩包中有两个工程。服务，客户端。
protobuf-demo
03-05
protobuf-rpc-pro是一个Java类库，提供了基于 Google 的 Protocol Buffers 协议的远程方法调用的框架。基于 Netty 底层的 NIO 技术。支持 TCP 重用/ keep-alive、客户端和服务端双向调用、SSL加密、RPC 调用取消操作...
netty5 google protoc-2.5.win与protobuf-java-2.5.0.jar.rar
09-16
netty5 google protoc-2.5与protobuf-java-2.5.0.jar.rar 目前是可以用的
Google Protobuf在Netty中的使用
LANGZI7758521的专栏
07-28 288
// NetServerTest1 package ProtobufTest; import com.apanda.net.impl.NetServer; public class NetServerTest1 { public static void main(String[] args) { ServerListenerTest1 serverListenerT...
精通并发与Netty（Google Protobuf 多协议支持）
qq_27820551的博客
05-06 522
在netty的数据传输中，客户端和服务端只能同时有一种协议生效，而在proto文件中却可能会存在定义多个message，那么就需要我们通过枚举的方式去实现多协议的传递方式。 如下是proto文件的定义方式 Person.proto syntax="proto2"; //文件特性 package com.test.protobuf; option optimize_for = SPEED;...
【六】Netty Google Protobuf 编解码
echohuangshihuxue的博客
01-09 447
首先在Protobuf的入门知识中，通过简单的样例代码熟悉如何用Protobuf对POJO对象进行编码。利用protoc.exe 编译.proto文件可能对于不熟悉的同学比较难，需要多实操几次。在掌握了Protobuf的基础知识之后，讲解如何使用Netty 的Protobuf进行客户端和服务端开发，最后对Protobuf解码器需要注意点进行了说明。
10.netty客户端与服务器使用protobuf传输报文
PacosonSWJTU的博客
09-04 1623
1）ProtoBuf定义：是 Protocol Buffer 的缩写，即协议缓冲区；它是一种开源跨平台的序列化资料结构的协议。① 语言无关、平台无关。即 ProtoBuf 支持 Java、C++、Python 等多种语言，支持多个平台；② 高效。即比 XML 更小（3 ~ 10倍）、更快（20 ~ 100倍）、更为简单；③ 扩展性、兼容性好。你可以更新数据结构，而不影响和破坏原有的旧程序；说的直接点，protobuf序列化性能 优于 java序列化；
Google Protobuf
可小辉的博客
02-01 842
目录 1.编码和解码的基本介绍 2.Netty本身的编码解码的机制和问题分析 3.Protobuf 4.Protobuf快速入门实例 5.Protobuf快速入门实例2 1.编码和解码的基本介绍 编写网络应用程序时，因为数据在网络中传输的都是二进制字节码数据，在发送数据时就需要编码，接收数据时就需要解码[示意图] codec（编解码器）的组成部分有两个：decoder（解码器）和encoder（编码器）。encoder负责把业务数据转换成字节码数据，dec...
Netty 集成google ProtoBuf 开发私有协议
zhouzhiwengang的专栏
01-04 318
ProtoBuf简介 protocolbuffer(以下简称PB)是google 的一种数据交换的格式，它独立于语言，独立于平台。google 提供了多种语言的实现：java、c#、c++、go 和python，每一种实现都包含了相应语言的编译器以及库文件。由于它是一种二进制的格式，比使用 xml进行数据交换快许多。可以把它用于分布式应用之间的数据通信或者异构环境下的数据交换。作为一种效率和兼容性都很优秀的二进制数据传输格式，可以用于诸如网络传输、配置文件、数据存储等诸多领域。 官网地址:https:/
Netty系列-使用Google Protobuf编解码
长青树呀
12-12 3554
什么是编解码 通常我们也习惯将编码（Encode）称为序列化（serialization），它将对象序列化为字节数组，用于网络传输、数据持久化或者其它用途。 反之，解码（Decode）/反序列化（deserialization）把从网络、磁盘等读取的字节数组还原成原始对象（通常是原始对象的拷贝），以方便后续的业务逻辑操作。 进行远程跨进程服务调用时（例如RPC调用），需要使用特定的编
Netty5 Protobuf通信 解决半包
Flyer的后花园
07-28 2301
本文整合网上资源 给出了完整版本  对于高负载、高并发的网络应用，自己开发nio服务端，难度比较大、稳定性不能保证。于是选择nio框架netty+protobuf。netty对于消息编码和解码、半包读写问题支持很好；protobuf支持多语言，编码后消息小利于存储和传输。 版本：java7 netty5 protobuf-java-2.5.0 maven 依赖
netty protobuf
最新发布
09-07
为了解决这些问题，很多公司选择将网络传输协议从HTTP和JSON转换为TCP和Google Protocol Buffers（protobuf）协议。 Protobuf是Netty默认的序列化协议，它具有高性能和高效的编解码能力。它使用一种基于二进制的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值