Netty核心技术七--Google Protobuf

最新推荐文章于 2024-07-25 08:00:00 发布
最新推荐文章于 2024-07-25 08:00:00 发布
阅读量429 收藏 2
点赞数
分类专栏： NIO&Netty 文章标签： java 前端 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31745863/article/details/131332808
版权

1.编码和解码的基本介绍

  1. 编写网络应用程序时，因为数据在网络中传输的都是二进制字节码数据，在发送数据时就需要编码，接收数据时就需要解码

    image-20230621153118054

  2. codec(编解码器) 的组成部分有两个：decoder(解码器)和encoder(编码器)。encoder 负责把业务数据转换成字节码数据，decoder 负责把字节码数据转换成业务数据

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

  1. Netty 自身提供了一些 codec(编解码器)
  2. Netty 提供的编码器
    • StringEncoder，对字符串数据进行编码
    • ObjectEncoder，对 Java 对象进行编码
    • …
  3. Netty 提供的解码器
    • StringDecoder, 对字符串数据进行解码
    • ObjectDecoder，对 Java 对象进行解码
    • …
  4. Netty 本身自带的 ObjectDecoder 和 ObjectEncoder 可以用来实现POJO对象或各种业务对象的编码和解码，底层使用的仍是 Java 序列化技术 , 而Java 序列化技术本身效率就不高，存在如下问题
    • 无法跨语言
    • 序列化后的体积太大，是二进制编码的 5 倍多。
    • 序列化性能太低

结论:所以我们使用Protobuf

3. Protobuf

3.1 Protobuf基本介绍和使用示意图

  1. Protobuf 是 Google 发布的开源项目，全称 Google Protocol Buffers，是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC[远程过程调用 remote procedure call ] 数据交换格式。

    • 目前很多公司 http+json 向 tcp+protobuf转型

  2. Protobuf 是以 message 的方式来管理数据的.

  3. 支持跨平台、跨语言，即[客户端和服务器端可以是不同的语言编写的] （支持目前绝大多数语言，例如 C++、C#、Java、python 等）

  4. 高性能，高可靠性

    • 在序列化和反序列化数据方面，Protobuf 比JSON 快得多。由于格式是二进制的，在Protobuf 中读写结构化数据所需的时间比在JSON 中要短。

  5. 使用 protobuf 编译器能自动生成代码，Protobuf 是将类的定义使用.proto文件进行描述。说明，在idea 中编写 .proto 文件时，会自动提示是否下载.ptotot 编写插件.可以让语法高亮。

  6. 然后通过 protoc.exe 编译器根据.proto 自动生成.java 文件

  7. protobuf 使用示意图

    image-20230621154614328

    1. 客户端通过protoc.exe 编译器根据.proto 自动生成.java 文件
    2. 客户端再将生成的java文件对应的对象通过ProtobufEncoder编码为二进制字节码,通过二进制进行传输
    3. 服务端拿到二进制文件再通过ProtobufDecoder解码为业务数据对象即可使用

3.2 Protobuf快速入门实例1

需求:

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

protoc-3.6.1-win32.zip官方下载地址

  1. 将我们之前写的Netty核心技术五–Netty高性能架构设计的 Netty快速入门实例-TCP服务案例直接复用

    image-20230621161944637

  2. Protobuf的使用–Java

    1. 通过Maven的方式导入Protobuf相关依赖

      <!-- https://mvnrepository.com/artifact/com.google.protobuf/protobuf-java -->
<dependency>
    <groupId>com.google.protobuf</groupId>
    <artifactId>protobuf-java</artifactId>
    <version>3.6.1</version>
</dependency>

    2. protobuf定义属性各语言对照表官方文档https://protobuf.dev/programming-guides/proto3/#scalar

      .proto TypeC++ TypeJava/Kotlin Type[1]Python Type[3]Go TypeRuby TypeC# TypePHP TypeDart Type
      doubledoubledoublefloatfloat64Floatdoublefloatdouble
      floatfloatfloatfloatfloat32Floatfloatfloatdouble
      int32int32intintint32Fixnum or Bignum (as required)intintegerint
      int64int64longint/long[4]int64Bignumlonginteger/string[6]Int64
      uint32uint32int[2]int/long[4]uint32Fixnum or Bignum (as required)uintintegerint
      uint64uint64long[2]int/long[4]uint64Bignumulonginteger/string[6]Int64
      sint32int32intintint32Fixnum or Bignum (as required)intintegerint
      sint64int64longint/long[4]int64Bignumlonginteger/string[6]Int64
      fixed32uint32int[2]int/long[4]uint32Fixnum or Bignum (as required)uintintegerint
      fixed64uint64long[2]int/long[4]uint64Bignumulonginteger/string[6]Int64
      sfixed32int32intintint32Fixnum or Bignum (as required)intintegerint
      sfixed64int64longint/long[4]int64Bignumlonginteger/string[6]Int64
      boolboolbooleanboolboolTrueClass/FalseClassboolbooleanbool
      stringstringStringstr/unicode[5]stringString (UTF-8)stringstringString
      bytesstringByteStringstr (Python 2) bytes (Python 3)[]byteString (ASCII-8BIT)ByteStringstringList

    3. 新建一个.proto文件Student.proto

      syntax = "proto3"; //协议版本,因为我们的protobuf的版本是3.6.1
option java_outer_classname = "StudentPOJO";//生成的外部类名，同时也是文件名
//protobuf 使用message 管理数据
message Student { //会在 StudentPOJO 外部类生成一个内部类 Student， 他是真正发送的POJO对象
  int32 id = 1; // Student 类中有 一个属性 名字为 id 类型为int32(protobuf类型) 1表示属性序号，不是值
  string name = 2;
}

    4. 客户端通过protoc.exe 编译器根据.proto 自动生成.java 文件

      1. 将拷贝到 protoc.exe 同级目录或者自己配置一个环境变量

        image-20230621164132458

      2. 使用protoc.exe编译

        protoc.exe --java_out=. Student.proto

        image-20230621164408113

    5. 我们将 StudentPOJO.java拷贝回目录

      image-20230621164530819

      StudentPOJO有一个内部类Student,这个类才是我们传输的对象

      image-20230621164824868

    6. 编写服务端和客户端(因为我们是复用的代码,所以只需要修改一下)

3.2.1 客户端NettyClient

较之前的代码在initChannel的最前面加上了ProtoBufEncoderhandler

package site.zhourui.nioAndNetty.netty.codec;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.protobuf.ProtobufEncoder;

public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        //客户端需要一个事件循环组
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            //创建客户端启动对象
            //注意客户端使用的不是 ServerBootstrap 而是 Bootstrap
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            //在pipeline中加入 ProtoBufEncoder
                            socketChannel.pipeline().addLast("encoder", new ProtobufEncoder());
                            socketChannel.pipeline().addLast(new NettyClientHandler());
                        }
                    });
            System.out.println("客户端 ok..");
            //启动客户端去连接服务器端
            //关于 ChannelFuture 要分析，涉及到netty的异步模型
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 6668).sync();
            //给关闭通道进行监听
            cf.channel().closeFuture().sync();
        }finally {
            group.shutdownGracefully();
        }

    }
}

3.2.2 客户端NettyClientHandler

  • 将重写的channelActive方法修改为发送一个StudentPOJO.Student实例对象
package site.zhourui.nioAndNetty.netty.codec;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    //当通道就绪就会触发该方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //发生一个Student 对象到服务器
        StudentPOJO.Student student = StudentPOJO.Student.newBuilder().setId(4).setName("智多星 吴用").build();
        ctx.pipeline().writeAndFlush(student);
    }

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

    //当通道有异常时触发
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

3.2.3 服务端NettyServer

  • 较之前的代码在initChannel的最前面加上了ProtoBufDecoderhandler
package site.zhourui.nioAndNetty.netty.codec;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.protobuf.ProtobufDecoder;

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {

        //创建BossGroup 和 WorkerGroup
        //说明
        //1. 创建两个线程组 bossGroup 和 workerGroup
        //2. bossGroup 只是处理连接请求 , 真正的和客户端业务处理，会交给 workerGroup完成
        //3. 两个都是无限循环
        //4. bossGroup 和 workerGroup 含有的子线程(NioEventLoop)的个数
        //   默认实际 cpu核数 * 2
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup(8);

        try {
            //创建服务器端的启动对象，配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            //使用链式编程来进行设置
            bootstrap.group(bossGroup,workerGroup)//设置两个线程组
                    .channel(NioServerSocketChannel.class)//使用NioSocketChannel 作为服务器的通道实现
                    .option(ChannelOption.SO_BACKLOG,128)// 设置线程队列得到连接个数
                    .childOption(ChannelOption.SO_KEEPALIVE,true)//设置保持活动连接状态
                    .childHandler(new ChannelInitializer<SocketChannel>() {//创建一个通道初始化对象(匿名对象)
                        //给pipeline 设置处理器
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            //可以使用一个集合管理 SocketChannel， 再推送消息时，可以将业务加入到各个channel 对应的 NIOEventLoop 的 taskQueue 或者 scheduleTaskQueue
                            System.out.println("客户socketchannel hashcode=" + socketChannel.hashCode());
                            //在pipeline加入ProtoBufDecoder
                            //指定对哪种对象进行解码
                            socketChannel.pipeline().addLast("decoder", new ProtobufDecoder(StudentPOJO.Student.getDefaultInstance()));
                            socketChannel.pipeline().addLast(new NettyServerHandler());
                        }
                    });

            System.out.println(".....服务器 is ready...");
            //绑定一个端口并且同步, 生成了一个 ChannelFuture 对象
            //启动服务器(并绑定端口)
            ChannelFuture cf = bootstrap.bind(6668).sync();

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

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

3.2.4 服务端NettyServerHandler

  • 将ChannelInboundHandlerAdapter修改为SimpleChannelInboundHandler<StudentPOJO.Student>,这样就需要我们手动将Object对象转为StudentPOJO.Student
  • 重新channelRead0方法
    • 打印出接收到的消息
package site.zhourui.nioAndNetty.netty.codec;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;

import java.util.concurrent.TimeUnit;

/*
说明
1. 我们自定义一个Handler 需要继续netty 规定好的某个HandlerAdapter(规范)
2. 这时我们自定义一个Handler , 才能称为一个handler
 */
//public class NettyServerHandler extends ChannelInboundHandlerAdapter {
public class NettyServerHandler extends SimpleChannelInboundHandler<StudentPOJO.Student> {
    //读取数据实际(这里我们可以读取客户端发送的消息)
    /*
    1. ChannelHandlerContext ctx:上下文对象, 含有 管道pipeline , 通道channel, 地址
    2. Object msg: 就是客户端发送的数据 默认Object
     */

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, StudentPOJO.Student msg) throws Exception {
        //读取从客户端发送的StudentPojo.Student
        System.out.println("客户端发送的数据 id=" + msg.getId() + " 名字=" + msg.getName());
    }


    //数据读取完毕
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //writeAndFlush 是 write + flush
        //将数据写入到缓存，并刷新
        //一般讲，我们对这个发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵1", CharsetUtil.UTF_8));
    }
    //处理异常, 一般是需要关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

3.2.5 测试

  1. 启动服务端

    image-20230621173508304

  2. 启动客户端

    image-20230621173526444

    服务端接收到了客户端发送的对象

    image-20230621173541714

3.3 Protobuf快速入门实例2

需求:

  1. 客户端可以随机发送Student PoJo/ Worker PoJo 对象到服务器 (通过 Protobuf 编码)
  2. 服务端能接收Student PoJo/ Worker PoJo 对象(需要判断是哪种类型)，并显示信息(通过 Protobuf 解码)

个人理解如果是每个对象都像实例1一样都生成一个.java,那么就很麻烦,所以我们将需要发送的对象(类)封装在一个.proto文件中就只需要编译一次

3.3.1 复用案例1的代码

因为实现具体功能都差不多,我们直接复用案例1的代码

image-20230621174519862

3.3.2 修改 Student.proto

较之案例1的差异:

  1. 加快解析
  2. 指定.java生成的位置
  3. protobuf 可以使用message 管理其他的message
    1. 定义三个message:MyMessage是用于管理Student,Worker
    2. MyMessage中定义枚举:在proto3 要求enum的编号从0开始
    3. 用data_type 来标识传的是哪一个枚举类型
    4. oneof:表示每次枚举类型最多只能出现其中的一个, 节省空间
  4. 将编写的Student.proto再次编译为.java,放在codec2包下
syntax = "proto3";
option optimize_for = SPEED; // 加快解析
option java_package="site.zhourui.nioAndNetty.netty.codec2";   //指定生成到哪个包下
option java_outer_classname="MyDataInfo"; // 外部类名, 文件名

//protobuf 可以使用message 管理其他的message
message MyMessage {

  //定义一个枚举类型
  enum DataType {
    StudentType = 0; //在proto3 要求enum的编号从0开始
    WorkerType = 1;
  }

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

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

}


message Student {
  int32 id = 1;//Student类的属性
  string name = 2; //
}
message Worker {
  string name=1;
  int32 age=2;
}

3.3.3 客户端NettyClientHandler

  • 客户端端在通道连接的时候随机发送Student或Worker对象
package site.zhourui.nioAndNetty.netty.codec2;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

import java.util.Random;

public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    //当通道就绪就会触发该方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //随机的发送Student 或者 Workder 对象
        int random = new Random().nextInt(3);
        MyDataInfo.MyMessage myMessage = null;

        if(0 == random) { //发送Student 对象

            myMessage = MyDataInfo.MyMessage.newBuilder().setDataType(MyDataInfo.MyMessage.DataType.StudentType).setStudent(MyDataInfo.Student.newBuilder().setId(5).setName("玉麒麟 卢俊义").build()).build();
        } else { // 发送一个Worker 对象

            myMessage = MyDataInfo.MyMessage.newBuilder().setDataType(MyDataInfo.MyMessage.DataType.WorkerType).setWorker(MyDataInfo.Worker.newBuilder().setAge(20).setName("老李").build()).build();
        }

        ctx.writeAndFlush(myMessage);
    }

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

    //当通道有异常时触发
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

3.3.4 服务端NettyServer

  • 因为是发送消息是编码所以不需要修改

image-20230621180523837

3.3.5 服务端NettyServerHandler

  • 修改SimpleChannelInboundHandler泛型为MyDataInfo.MyMessage
  • channelRead0中根据dataType 来显示不同的信息
package site.zhourui.nioAndNetty.netty.codec2;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;

/*
说明
1. 我们自定义一个Handler 需要继续netty 规定好的某个HandlerAdapter(规范)
2. 这时我们自定义一个Handler , 才能称为一个handler
 */
//public class NettyServerHandler extends ChannelInboundHandlerAdapter {
public class NettyServerHandler extends SimpleChannelInboundHandler<MyDataInfo.MyMessage> {
    //读取数据实际(这里我们可以读取客户端发送的消息)
    /*
    1. ChannelHandlerContext ctx:上下文对象, 含有 管道pipeline , 通道channel, 地址
    2. Object msg: 就是客户端发送的数据 默认Object
     */

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

        MyDataInfo.MyMessage.DataType dataType = msg.getDataType();
        if(dataType == MyDataInfo.MyMessage.DataType.StudentType) {

            MyDataInfo.Student student = msg.getStudent();
            System.out.println("学生id=" + student.getId() + " 学生名字=" + student.getName());

        } else if(dataType == MyDataInfo.MyMessage.DataType.WorkerType) {
            MyDataInfo.Worker worker = msg.getWorker();
            System.out.println("工人的名字=" + worker.getName() + " 年龄=" + worker.getAge());
        } else {
            System.out.println("传输的类型不正确");
        }
    }



    //数据读取完毕
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //writeAndFlush 是 write + flush
        //将数据写入到缓存，并刷新
        //一般讲，我们对这个发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵1", CharsetUtil.UTF_8));
    }
    //处理异常, 一般是需要关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }


}

3.3.6 测试

开启一次服务端,多次重启服务端模拟发送不同类型的消息

image-20230621182141403

_院长大人_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
神奇的Google二进制编解码技术：Protobuf
m0_73257876的博客
09-05 866
这个问题可不像看上去的那样简单，因为client进程和server进程运行在不同的机器上，这些机器可能运行在不同的处理器平台、可能运行在不同的操作系统、可能是由不同的编程语言编写的，server要怎样才能识别出client发送的是什么数据呢？可见，同样一串二进制在不同的“上下文/协议”下有完全不一样的解读， 这也是为什么计算机明明只认知0和1但是却能处理非常复杂任务的根本原因，因为一切都可以编码为0和1，同样的我们也可以从0和1中解析出我们想要的信息，这就是所谓的编解码技术。
google protobuf
05-14
google protobuf库文件，编译方法，及使用 google protobuf学习笔记一：windows下环境配置
Google 的开源技术protobuf 简介与例子
热门推荐
内方外圆
05-17 35万+
本文来自CSDN博客：http://blog.csdn.net/program_think/archive/2009/05/31/4229773.aspx今天来介绍一下“Protocol Buffers”（以下简称protobuf）这个玩意儿。本来俺在构思“生产者/消费者模式 ”系列的下一个帖子：关于生产者和消费者之间的数据传输格式。由于
【Google ProtoBuf介绍】
最新发布
weixin_42326851的博客
07-25 2420
Google ProtoBuf介绍
Google Protocol Buffer
rongrong0206的专栏
12-06 1144
什么是 Google Protocol Buffer？ 假如您在网上搜索，应该会得到类似这样的文字介绍：Google Protocol Buffer( 简称 Protobuf) 是 Google 公司内部的混合语言数据标准，目前已经正在使用的有超过 48,162 种报文格式定义和超过 12,183 个 .proto 文件。他们用于 RPC 系统和持续数据存储系统。Protocol Buffers 是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交
通信与协议Netty+Protobuf-游戏设计与开发(1)配套代码
04-06
总结来说，"通信与协议Netty+Protobuf-游戏设计与开发(1)配套代码"是一个关于如何利用Netty进行网络通信以及如何使用Protobuf进行数据序列化的实例。通过学习这个资源，开发者可以更好地理解和掌握这两种技术在游戏...
netty-calc-server:Netty和Protobuf上的客户端-服务器系统的负载测试
05-25
而Google的Protocol Buffers（简称Protobuf）则是一种高效的数据序列化协议，它为跨平台的数据交换提供了简洁、高效的解决方案。本文将深入探讨如何利用Netty和Protobuf构建一个客户端-服务器系统，并进行负载测试。...
Netty Protobuf3 测试服务器
04-10
在这个“Netty Protobuf3 测试服务器”项目中，开发者使用Netty框架来构建一个服务器，该服务器与Unity游戏引擎中的protobuf3（Protocol Buffers版本3）进行通信。protobuf3是Google开发的一种数据序列化协议，它...
Netty4+ProtoBuf通信框架
07-27
Netty4+ProtoBuf通信框架是一种高效的网络应用框架，它结合了Netty的高性能和Google的Protocol Buffers（ProtoBuf）的数据序列化能力，用于构建可伸缩、高并发的网络应用程序。在这个项目中，客户端和服务端之间的...
netty http protobuf
08-04
Netty、HTTP与Protobuf是三个在IT领域中至关重要的技术组件，它们分别在不同的层面上为高性能网络应用提供服务。下面将详细解释这三个概念及其相互结合的应用。 **Netty** Netty是一个开源的Java NIO（非阻塞I/O）...
Google Protobuf
weixin_42574365的博客
08-22 163
1.Google Protobuf是什么？ Protobuf .是Google的语言无关，平台无关的可扩展机制，用于序列化结构化数据, 相比与 xml 等传统的序列化工具, 它更小、更快、更简单。 github地址:protobuf源码地址 优点： 在谷歌内部长期使用, 产品成熟度高 跨语言、支持多种语言, 包括 C++、Java 和 Python 编码后的消息更小, 更加有利于存储和传输 编解码的性能非常高 支持不同协议版本的前向兼容 支持定义可选和必选字段 2.ProtoBuf的使用 2.1 安装
Google protobuf
u010100466的专栏
05-23 1465
概述 Protocol Buffers是一种序列化数据结构的方法，Protocol Buffers经常被简称为protobuf。 它不依赖于语言和平台并且可扩展性极强。google protobuf是跨语言的，并且自带了一个编译器(protoc)，只需要用它进行编译，可以编译成Java、python、C++、C#、Go等代码，然后就可以直接使用，不需要再写其他代码，自带有解析的代码。更详细的介绍见:
关于google的protobuf
lq123456789000的专栏
03-14 1566
目前项目用到socket+protobuf出现的问题有： 一：protobuf的eclipse插件支持最低版本为3.7，而事实上eclipse4高版本都是吃货，吃内存、cpu的货 二：protobuf生成的java对象。动不动就几千行代码，动不动就几百K的class文件 三：protobuf的string经过测试不支持gbk编码。而不得不用bytes代替 四：protobuf生成的java
Google ProtoBuf 初试
十点半i睡觉
11-18 559
偶然在项目中接触到游戏服务器的，游戏服务器与JavaWeb后台管理系统的数据交换，用的便是Google ProtoBuf，先来说下什么是Google ProtoBuf： protoBuf 是一种平台无关、语言无关、扩展性好的用于通信协议、数据存储的结构化数据串行化方法。 是用于结构化数据串行化的灵活、高效、自动的方法，有如XML，不过它更小、更快、也更简单。你可以定义自己的数据结构，然后使用代码
Google Protobuf详解
weixin_44240370的博客
09-26 2429
首先要知道几个清楚的概念： RPC：Remote Procedure Call，远程过程调用，很多RPC框架都是跨语言的。 使用步骤： 定义一个接口说明文件：描述了对象(结构体)、对象成员、接口方法等一系列信息 通过RPC框架所提供的编译器将接口说明文件编译成具体的语言文件 在客户端与服务器端分别引入RPC编译器所生成的文件，即可像调用本地方法一样调用远程方法 RPC的效率主要在于编解码的...
Google protobuf（1）-简介
lxgwm2008的专栏
07-05 9570
一、简介。 protobuf是由Google开发的一套对数据结构进行序列化的方法，可用做通信协议，数据存储格式，等等。其特点是不限语言、不限平台、扩展性强，就像XML一样。与XML相比，protobuf有以下特点： 1、操作更简单。 例如，我们要定义一个个人信息的结构，其中包括名称和邮箱地址两个部分。 用XML定义如下：       John Doe      jdoe@exampl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值