精华内容
下载资源
问答
  • protobuf学习文档

    2020-09-07 11:44:10
    谷歌protobuf学习文档:https://developers.google.cn/protocol-buffers
    展开全文
  • protobuf学习

    2016-09-02 19:04:39
    protobuf学习  1.protobuf简介 全称“Protocol Buffers ”,是Google的一个开源项目。 protobuf其实和XML类似,是一种把数据按照某种特定的格式保存起来,用于存储,传输的规则。 2.protobuf的最大特点 (1)...

    protobuf学习  

    1.protobuf简介

    全称“Protocol Buffers ”,是Google的一个开源项目。

    protobuf其实和XML类似,是一种把数据按照某种特定的格式保存起来,用于存储,传输的规则。

    2.protobuf的最大特点

    (1)性能好,效率高

    (2)代码生成机制

    示例:

    比如有个电子商务的系统(假设用C++实现),其中的模块A需要发送大量的订单信息给模块B,通讯的方式使用socket。

    假设订单包括如下属性:

    --------------------------------

      时间:time(用整数表示)

      客户id:userid(用整数表示)

      交易金额:price(用浮点数表示)

      交易的描述:desc(用字符串表示)

    --------------------------------

      如果使用protobuf实现,首先要写一个proto文件(不妨叫Order.proto),在该文件中添加一个名为"Order"的message结构,用来描述通讯协议中的结构化数据。该文件的内容大致如下:

     

    --------------------------------

    message Order

    {

      required int32 time = 1;

      required int32 userid = 2;

      required float price = 3;

      optional string desc = 4;

    }

    --------------------------------

    使用protobuf内置的编译器编译 该proto。由于本例子的模块是C++,你可以通过protobuf编译器的命令行参数(看“这里 ”),让它生成C++语言的“订单包装类”。(一般来说,一个message结构会生成一个包装类)

      然后使用类似下面的代码来序列化/解析该订单包装类:

     

    --------------------------------

    // 发送方

    Order order;

    order.set_time(XXXX);

    order.set_userid(123);

    order.set_price(100.0f);

    order.set_desc("a test order");

    string sOrder;

    order.SerailzeToString(&sOrder);

    // 然后调用某种socket的通讯库把序列化之后的字符串发送出去

    // ......

    --------------------------------

    // 接收方

    string sOrder;

    // 先通过网络通讯库接收到数据,存放到某字符串sOrder

    // ......

    Order order;

    if(order.ParseFromString(sOrder)) // 解析该字符串

    {

      cout <<"userid:" << order.userid() << endl

              <<"desc:" << order.desc() << endl;

    }

    else

    {

      cerr << "parseerror!" << endl;

    }

    --------------------------------

    (3)支持“向后兼容”和“向前兼容”

    (4)支持多种编程语言(官方:c++,Python,Java)

    3.核心概念

    (1).proto文件

    相当于确定数据协议,数据结构中存在哪些数据,数据类型是怎么样

    (2)modifiers

    required 不可以增加或删除的字段,必须初始化

    optional 可选字段,可删除,可以不初始化

    repeated 可重复字段,对应到java文件里,生成的是List

    (3)Message

    在proto文件里,数据的协议时以Message的形式表现的。

    (4)Build

    生成具体的java类时,例如Person.java,同时会存在build方法。文档的意思是对于转化后的数据,具有唯一性,build提供了便利的方法来初始化这些数据。

    展开全文
  • Protobuf学习

    2019-04-29 14:00:34
    Protobuf是什么 Protobuf是一种平台无关、语言无关、可扩展且轻便高效的序列化数据结构的协议,可以用于网络通信和数据存储。 为什么要使用Protobuf protobuf特点.png 如何使用Protobuf protoc -I=$SRC_DIR ...

    Protobuf是什么

    Protobuf是一种平台无关、语言无关、可扩展且轻便高效的序列化数据结构的协议,可以用于网络通信数据存储

    为什么要使用Protobuf

    protobuf特点.png

    如何使用Protobuf

    protoc -I=$SRC_DIR --java_out=$DST_DIR $SRC_DIR/addressbook.proto
    

    -I 编译源文件的目录

    --java_out 编译目录文件

    通过这个命令会自动编译出java代码,目前protobuf支持以下语言

    LanguageSource
    C++src
    Javajava
    Pythonpython
    Objective-Cobjectivec
    C#csharp
    JavaNanojavanano
    JavaScriptjs
    Rubyruby
    Gogolang/protobuf
    PHPphp
    Dartdart-lang/protobuf

    由于命令行的方式编译代码非常繁琐,且效率极低。谷歌提供了开源的Protobuf Gradle插件

    简单说一下配置方式

    在project.gradle中配置

    buildscript {
      repositories {
        mavenLocal()
      }
      dependencies {
        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.6-SNAPSHOT'
      }
    }
    

    在modle.gradle中配置

    apply plugin: 'com.google.protobuf'
    
    dependencies {
      // You need to depend on the lite runtime library, not protobuf-java
      compile 'com.google.protobuf:protobuf-lite:3.0.0'
    }
    
    protobuf {
      protoc {
        // You still need protoc like in the non-Android case
        artifact = 'com.google.protobuf:protoc:3.0.0'
      }
      plugins {
        javalite {
          // The codegen for lite comes as a separate artifact
          artifact = 'com.google.protobuf:protoc-gen-javalite:3.0.0'
        }
      }
      generateProtoTasks {
        all().each { task ->
          task.builtins {
            // In most cases you don't need the full Java output
            // if you use the lite output.
            remove java
          }
          task.plugins {
            javalite { }
          }
        }
      }
    }
    

    目前有Protobuf2和Protobuf3,本文以Protobuf2为例,简单介绍一下Protobuf2的语法,更多详细内容请参考官方文档(需要翻墙)

    先在Java的同级目录下新建一个名为proto的文件夹专门用于存放proto文件,编写proto文件后编译模块会根据proto文件内容生成java文件。

    image

    来看一下名为Test.proto的文件内容

    //指定protobuf语法版本
    syntax = "proto2";
    
    //包名
    option java_package = "com.lhc.protobuf";
    //源文件类名
    option java_outer_classname = "AddressBookProtos";
    
    // class Person
    message Person {
      //required 必须设置(不能为null)
      required string name = 1;
      //int32 对应java中的int
      required int32 id = 2;
      //optional 可以为空
      optional string email = 3;
    
      enum PhoneType {
        MOBILE = 0;
        HOME = 1;
        WORK = 2;
      }
    
      message PhoneNumber {
        required string number = 1;
        optional PhoneType type = 2 [default = HOME];
      }
       //repeated 重复的 (集合)
      repeated PhoneNumber phones = 4;
    }
    
    message AddressBook {
      repeated Person people = 1;
    }
    

    Protobuf应用------网络传输

    http传输

    通常在应用层我们使用的都是Http协议,Http的本质是一次socket请求的连接与断开。传输数据时将protobuf对象转换为byte[]传输即可

    自定义TCP通信协议

    当我们自定义TCP通信协议的时候,将面临粘包与分包的问题

    分包:

    • 要发送的数据大于TCP缓冲剩余空间
    • 待发送数据大于MSS(最大报文长度)

    image

    粘包:

    • 要发送的数据小于TCP缓冲区,将多次写入缓冲区的数据一起发送
    • 接收端的应用层没有及时读取缓冲区的数据

    [站外图片上传中...(image-f9d2d3-1528012964593)]

    自定义通信协议的两种方式

    • 定义数据包包头

    image

    • 在数据包之间设置边界

    image

    大家可以参考 JT808协议 ------交通部808协议(车联网),也是采用类似的方式定义通信协议


    手写简易Gradle Protobuf编译插件

    准备proto编译器工件,proto文件目录,通过参数拼接出命令行编译proto文件,将执行结果注册到编译打包列表

    定义两个DSL命名空间

    class ProtobufExt {
         /**
         * proto文件目录
         */
        def srcDirs
    
        ProtobufExt() {
            srcDirs = []
        }
    
        def srcDir(String srcDir) {
            if (!srcDirs.contians(srcDir))
                srcDirs << srcDir
        }
    
        def srcDir(String... srcDirs) {
            srcDirs.each { srcDir(it) }
        }
    }
    
    class ProtoExt {
        def path
        def artifact
    }
    

    定义一个插件实现Plugin接口

    class ProtobufPlugin implements Plugin<Project> {
    
        static final String PROTOBUF_EXTENSION_NAME = "protobuf"
        static final String PROTO_SUB_EXTENSION_NAME = "protoc"
        Project project
    
        @Override
        void apply(Project project) {
            this.project = project
            project.apply plugin: 'com.google.osdetector'
            project.extensions.create(PROTOBUF_EXTENSION_NAME, ProtobufExt)//创建命名空间
            project.protobuf.extensions.create(PROTO_SUB_EXTENSION_NAME, ProtoExt)
            //在gradle分析之后执行
            project.afterEvaluate {
                if (!project.protobuf.protoc.path) {
                    if (!project.protobuf.protoc.artifact) {
                        throw new GradleException("请配置protoc编译器")
                    }
                    //创建依赖配置
                    Configuration config = project.configurations.create("protobufConfig")
                    def (group, name, version) = project.protobuf.protoc.artifact.split(":")
                    def notation = [group: group, name: name, version: version, classifier: project.osdetector.classifier, ext: 'exe']
                    //本地存在则返回工件,否则先下载
                    Dependency dependency = project.dependencies.add(config.name, notation)
                    //获得对应dependency的所有文件
                    File file = config.fileCollection(dependency).singleFile
                    println file
                    if (!file.canExecute() && !file.setExecutable(true)) {
                        throw new GradleException("protoc编译器无法执行")
                    }
                    project.protobuf.protoc.path = file.path
                }
    
                Task task = project.tasks.create("compileProtobuf", CompileProtobufTask)
                task.inputs.files(project.protobuf.srcDirs)
                task.outputs.dir("${project.buildDir}/generated/source/proto")
    
                //将编译生成的java文件假如到工程源代码文件列表中
                linkProtoToJavaSource()
            }
        }
    
        /**
         * 判断是否为安卓工程
         * @return
         */
        boolean isAndroidProject() {
            return project.plugins.hasPlugin(AppPlugin) || project.plugins.hasPlugin(LibraryPlugin)
        }
    
        def getAndroidVariants() {
            return project.plugins.hasPlugin(AppPlugin) ?
                    project.android.applicationVariants + project.android.testVariants : project.android.libraryVariants + project.android.testVariants
        }
    
        def linkProtoToJavaSource() {
            if (isAndroidProject()) {
                androidVariants.each {
                    BaseVariant variant ->
                        //将任务加入构建过程,并将第二个参数的文件注册到编译列表当中
                        variant.registerJavaGeneratingTask(project.tasks.compileProtobuf, project.tasks.compileProtobuf.outputs.files.files)
                }
            } else {
                project.sourceSets.each {
                    SourceSet sourceSet ->
                        def compileName = sourceSet.getCompileTaskName('java')
                        JavaCompile javaCompile = project.tasks.getByName(compileName)
                        javaCompile.dependsOn project.tasks.compileProtobuf
                        sourceSet.java.srcDirs(project.tasks.compileProtobuf.outputs.files.files)
                }
            }
        }
    }
    

    实现一个DefaultTask子类,主要是通过输入参数拼接出如下的编译所需的命令行

    protoc -I=$SRC_DIR --java_out=$DST_DIR $SRC_DIR/addressbook.proto

    class CompileProtobufTask extends DefaultTask {
    
        CompileProtobufTask() {
            group = 'Protobuf'
            outputs.upToDateWhen { false } //关闭增量构建,否则输入输出不变时执行增量构建
        }
        
        @TaskAction
        def run() {
            def outDir = outputs.files.singleFile
            outDir.deleteDir()
            outDir.mkdirs()
    
            def cmd = [project.protobuf.protoc.path]
    
            cmd << "--java_out=$outDir"
            def source = []
            def inDirs = inputs.files.files
            inDirs.each {
                cmd << "-I=${it.path}"
            }
    
            getProtoFiles(inDirs, source)
    
            cmd.addAll(source)
            println "执行:$cmd"
    
            Process process = cmd.execute()
    
            def stdout = new StringBuffer()
            def stdErr = new StringBuffer()
    
            process.waitForProcessOutput(stdout, stdErr)//输出错误日志
            if (process.exitValue() == 0) {
                println "编译protobuf文件成功"
            } else {
                throw new GradleException("编译protobuf文件失败" + " $stdout" + " $stdErr")
            }
    
        }
    
        /**
         * 将目录下所有.proto文件添加到集合
         * @param dirs
         * @param source
         */
        def getProtoFiles(dirs, source) {
            dirs.each {
                File file ->
                    if (file.isDirectory()) {
                        getProtoFiles(file.listFiles(), source)
                    } else if (file.name.endsWith(".proto")) {
                        source << file
                    }
            }
        }
    }
    

    如果觉得有收获,麻烦给个赞吧


    链接:https://www.jianshu.com/p/2265f56805fa

    展开全文
  • protobuf 学习

    2014-11-19 16:28:53
    protobuf 是什么? Protocol buffers是一种编码方法构造的一种有效而可扩展的格式的数据。 谷歌使用其内部几乎RPC协议和文件格式的所有协议缓冲区。 参考文档 ...参考文档 ...proto
    protobuf 是什么? 
    

    Protocol buffers是一种编码方法构造的一种有效而可扩展的格式的数据。 谷歌使用其内部几乎RPC协议和文件格式的所有协议缓冲区。

    参考文档

    http://code.google.com/intl/zh-CN/apis/protocolbuffers/docs/overview.html

    API的 参考文档

    protobuf 适用的语言

    正宗(Google 自己内部用的)的protobuf支持三种语言:Java 、c++和Pyton,很遗憾的是并不支持.Net 或者 Lua 等语言,但社区的力量是不容忽视的,由于protobuf确实比Json、XML有速度上的优势和使用的方便,并且可以做到向前兼容、向后兼容等众多特点,所以protobuf社区又弄了个protobuf.net的组件并且还支持众多语言,详细可以看这个链接:http://code.google.com/p/protobuf/wiki/ThirdPartyAddOns,具体某种语言的使用请各自对号入座,本篇只是讲使用android 与c++服务器通讯(测试过)或者与PC 通讯,使用java与C#之间互相通讯方面的DEMO,方面读者做参考。

    使用protobuf协议

    定义protobuf协议

    定义protobuf协议必须创建一个以.proto为后缀的文件,以本篇为例,本篇创建了一个叫msg.proto的消息文件,内容如下:

    package msginfo;

    message CMsg
    {
        required
    string msghead = 1 ;
        required
    string msgbody = 2 ;
    }

    message CMsgHead
    {
        required int32 msglen
    = 1 ;
        required int32 msgtype
    = 2 ;
        required int32 msgseq
    = 3 ;
        required int32 termversion
    = 4 ;
        required int32 msgres
    = 5 ;
        required
    string termid = 6 ;
    }

    message CMsgReg
    {
        optional int32 area
    = 1 ;
        optional int32 region
    = 2 ;
        optional int32 shop
    = 3 ;
        optional int32 ret
    = 4 ;
        optional
    string termid = 5 [defalut = " 12345 " ];
    }

    message CMsgLogin
    {
        optional int32 ret
    = 1 ;
    }

    message CMsgLogout
    {
        optional int32 ret
    = 1 ;

    }

    package在Java里面代表这个文件所在的包名,在c#里面代表该文件的命名空间,message代表一个类,

    required 代表该字段必填, optional 代表该字段可选,并可以为其设置默认值,默认值格式 :[ defalut =字符串就是"123" ,整型就是 123]。

    如何编译该proto文件

    java或android 使用的编译方法

    正宗的proto可以在Linux下编译也有提供win版编译,由于Linux下编译要配置什么g++呀,之类的有点麻烦,之前做的步骤都忘得差不多,那还是回到win版编译吧,而net 版则是需要在win版下编译。

    正宗google 的protobuf 下载列表请参照:http://code.google.com/p/protobuf/downloads/list  ,选择其中的win版本下载。解压后会得到一个protoc.exe 文件,此时就可以开始编译了,先以java 为例,编译的步骤如下:

    • cmd 打开命令工具
    • 以我电脑为例,该exe 文件我放在F:\protoc 目录下,先cd 到该目录 cd F:\protoc

    • 再次进入目录后会发现该目录多了一个文件夹,即以该proto的package命名的的目录,会产生一个Msg.java的文件,这时这个文件就可以使用到我们的java或者 android 工程了。
    • 最后一步下载一个protobuf-java-2.3.0.jar的jar 包引用到你的java和android工程 里面,OK。可以使用你的protobuf了。如下图:
    c#或者以后的Windows Phone 7 使用的编译方法:

    .net 版的protobuf来源于proto社区,有两个版本。一个版本叫protobuf-net,官方站点:http://code.google.com/p/protobuf-net/  写法上比较符合c#一贯的写法。另一个版本叫protobuf-csharp-sport ,

    官方站点:http://code.google.com/p/protobuf-csharp-port/ 写法上跟java上的使用极其相似,比较遵循Google 的原生态写法,所以做跨平台还是选择第二版本吧。因为你会发现几乎和java的写法没啥两样,本篇也是使用这个版本。

    进入该站点,下载你要的win版。 编译步骤如下:

    • 将刚才你的proto文件放在你解压出来的目录与protoc.exe 、ProtoGen.exe、ProtoGen.exe.config放于一起。其他文件可以删除或者 备份。
    • 还是打开命令行,定位于对应的目录里面,你放proto文件的目录里面。
    • 输入:protoc --descriptor_set_out=msg.protobin --include_imports msg.proto        
    • msg.protobin是要生成的prtobobin文件,可以使用这个bin文件生成cs文件
    • 再输入protogen msg.protobin  使用该bin文件生成cs文件,这样你就可以得到该 msg.cs 的CSharp版文件了,同时在VS里面使用要引入Google.ProtocolBuffers.dll。为了方便你可以将其做成一个批处理文件代码如下:
      echo on
      protoc
      -- descriptor_set_out = msg.protobin -- include_imports msg.proto
      protogen msg.protobin

      将其另存为.bat文件即可

    使用protobuf编译后的文件来进行socket连接

    android 与PC

    android 做为客户端向PC的Java服务端发送数据,服务端得到数据进行解析,并打印出来 。

    客户端代码:

    package net.testSocket;

    import java.io.IOException;
    import java.io.InputStream;
    import java.net.Socket;
    import java.net.UnknownHostException;

    import socket.exception.SmsClientException;
    import socket.exception.SmsObjException;

    import msginfo.Msg.CMsg;
    import msginfo.Msg.CMsgHead;
    import msginfo.Msg.CMsgReg;
    import android.app.Activity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.TextView;

    import com.google.protobuf.InvalidProtocolBufferException;

    // 客户端的实现
    public class TestSocket extends Activity {
       
    private TextView text1;
       
    private Button but1;
        Socket socket
    = null ;

       
    public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);

           
    // Thread desktopServerThread=new Thread(new AndroidServer());
           
    // desktopServerThread.start();

            setContentView(R.layout.main);

            text1
    = (TextView) findViewById(R.id.text1);
            but1
    = (Button) findViewById(R.id.but1);

            but1.setOnClickListener(
    new Button.OnClickListener() {
                @Override
               
    public void onClick(View v) {

                   
    // edit1.setText("");
                   
    // Log.e("dddd", "sent id");
                   
    // new Thread() {
                   
    // public void run() {
                    try {
                       
    // socket=new Socket("192.168.1.102",54321);
                       
    // socket = new Socket("192.168.1.110", 10527);
                         socket = new Socket( " 192.168.1.116 " , 12345 );
                       
    // 得到发送消息的对象
                       
    // SmsObj smsobj = new SmsObj(socket);
                       
                       
    // 设置消息头和消息体并存入消息里面
                       
    // head
                        CMsgHead head = CMsgHead.newBuilder().setMsglen( 5 )
                                .setMsgtype(
    1 ).setMsgseq( 3 ).setTermversion( 41 )
                                .setMsgres(
    5 ).setTermid( " 11111111 " ).build();

                       
    // body
                        CMsgReg body = CMsgReg.newBuilder().setArea( 22 )
                                .setRegion(
    33 ).setShop( 44 ).build();

                       
    // Msg
                        CMsg msg = CMsg.newBuilder()
                                .setMsghead(head.toByteString().toStringUtf8())
                                .setMsgbody(body.toByteString().toStringUtf8())
                                .build();

                       
    // PrintWriter out = new PrintWriter(new BufferedWriter(
                       
    // new OutputStreamWriter(socket.getOutputStream())),
                       
    // true);
                       
    // out.println(m.toString());
                       
    // out.println(m.toByteString().toStringUtf8());

                       
    // 向服务器发送信息
                        msg.writeTo(socket.getOutputStream());
                       
    // byte[] b = msg.toByteArray();
                       
    // smsobj.sendMsg(b);

                       
    // System.out.println("====msg==="
                       
    // + m.toByteString().toStringUtf8());
                       
                       
    // byte[] backBytes = smsobj.recvMsg();
                       
    //
                       
    // 接受服务器的信息
                        InputStream input = socket.getInputStream();

                       
    // DataInputStream dataInput=new DataInputStream();
                       
    // byte[] by = smsobj.recvMsg(input);
                        byte [] by = recvMsg(input);
                        setText(CMsg.parseFrom(by));

                       
    // BufferedReader br = new BufferedReader(
                       
    // new InputStreamReader(socket.getInputStream()));
                       
    // String mstr = br.readLine();
                       
    // if (!str .equals("")) {
                       
    // text1.setText(str);
                       
    // } else {
                       
    // text1.setText("数据错误");
                       
    // }
                       
    // out.close();
                       
    // br.close();

                        input.close();
                       
    // smsobj.close();
                        socket.close();
                    }
    catch (UnknownHostException e) {
                        e.printStackTrace();
                    }
    catch (IOException e) {
                        e.printStackTrace();
                    }
    catch (Exception e) {
                        System.
    out .println(e.toString());
                    }
                   
    // };
                   
    // }.start();

                }
            });

        }
       
       
    /* *
         * 接收server的信息
         *
         * @return
         * @throws SmsClientException
         * @author fisher
        
    */
       
    public byte [] recvMsg(InputStream inpustream) throws SmsObjException {
           
    try {

               
    byte len[] = new byte [ 1024 ];
               
    int count = inpustream.read(len); 
           
               
    byte [] temp = new byte [count];
               
    for ( int i = 0 ; i < count; i ++ ) {  
                        temp[i]
    = len[i];                             
                }
               
    return temp;
            }
    catch (Exception localException) {
               
    throw new SmsObjException( " SmapObj.recvMsg() occur exception! "
                       
    + localException.toString());
            }
        }

       
    /* *
         * 得到返回值添加到文本里面
         *
         * @param g
         * @throws InvalidProtocolBufferException
        
    */
       
    public void setText(CMsg g) throws InvalidProtocolBufferException {
            CMsgHead h
    = CMsgHead.parseFrom(g.getMsghead().getBytes());
            StringBuffer sb
    = new StringBuffer();
           
    if (h.hasMsglen())
                sb.append(
    " ==len=== " + h.getMsglen() + " \n " );
           
    if (h.hasMsgres())
                sb.append(
    " ==res=== " + h.getMsgres() + " \n " );
           
    if (h.hasMsgseq())
                sb.append(
    " ==seq=== " + h.getMsgseq() + " \n " );
           
    if (h.hasMsgtype())
                sb.append(
    " ==type=== " + h.getMsgtype() + " \n " );
           
    if (h.hasTermid())
                sb.append(
    " ==Termid=== " + h.getTermid() + " \n " );
           
    if (h.hasTermversion())
                sb.append(
    " ==Termversion=== " + h.getTermversion() + " \n " );

            CMsgReg bo
    = CMsgReg.parseFrom(g.getMsgbody().getBytes());
           
    if (bo.hasArea())
                sb.append(
    " ==area== " + bo.getArea() + " \n " );
           
    if (bo.hasRegion())
                sb.append(
    " ==Region== " + bo.getRegion() + " \n " );
           
    if (bo.hasShop())
                sb.append(
    " ==shop== " + bo.getShop() + " \n " );
           
    if (bo.hasRet())
                sb.append(
    " ==Ret== " + bo.getRet() + " \n " );
           
    if (bo.hasTermid())
                sb.append(
    " ==Termid== " + bo.getTermid() + " \n " );

            text1.setText(sb.toString());
        }

    }

    服务端代码:

    package server;


    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;

    import msginfo.Msg.CMsg;
    import msginfo.Msg.CMsgHead;
    import msginfo.Msg.CMsgReg;

    public class AndroidServer implements Runnable {

       
    public void run() {
           
    try {
                System.
    out .println( " beign: " );
                ServerSocket serverSocket
    = new ServerSocket( 12345 );
               
    while ( true ) {
                    System.
    out .println( " 等待接收用户连接: " );
                   
    // 接受客户端请求
                    Socket client = serverSocket.accept();

                    DataOutputStream dataOutputStream;
                    DataInputStream dataInputStream;

                   
    try {
                       
    // 接受客户端信息
                       
    // BufferedReader in = new BufferedReader(
                       
    // new InputStreamReader(client.getInputStream()));
                       
    // String str = in.readLine();
                       
    // System.out.println("read length:  " + str.length());
                       
    // System.out.println("read:  " + str);

                       
    // InputStream inputstream = client.getInputStream();
                       
    // byte[] buffer = new byte[1024 * 4];
                       
    // int temp = 0;
                       
    // while ((temp = inputstream.read(buffer)) != -1) {
                       
    // str = new String(buffer, 0, temp);
                       
    // System.out.println("===str===" + str);

                       
    // File file = new File("user\\log\\login.log");
                       
    // appendLog(file, str);

                        InputStream inputstream
    = client.getInputStream();

                        dataOutputStream
    = new DataOutputStream(
                                client.getOutputStream());
                       
    // dataInputStream = new DataInputStream(inputstream);

                       
    // byte[] d = new BufferedReader(new InputStreamReader(
                       
    // dataInputStream)).readLine().getBytes();
                       
    // byte[] bufHeader = new byte[4];
                       
    // dataInputStream.readFully(bufHeader);
                       
    // int len = BytesUtil.Bytes4ToInt(bufHeader);
                       
    // System.out.println(d.length);
                       
    // System.out.println(dataInputStream.readLine().toString());
                        byte len[] = new byte [ 1024 ];
                       
    int count = inputstream.read(len); 
                   
                       
    byte [] temp = new byte [count];
                       
                       
    for ( int i = 0 ; i < count; i ++ ) {  
                           
                                temp[i]
    = len[i];                             
                        }

                       
    // 协议正文
    //                      byte[] sendByte = new byte[30];
    //                    
    //                      dataInputStream.readFully(sendByte);
    //                      for (byte b : sendByte) {
    //                      System.out.println(""+b);
    //                      }
                        CMsg msg = CMsg.parseFrom(temp);
                       
    //
                       
    //
                        CMsgHead head = CMsgHead.parseFrom(msg.getMsghead()
                                .getBytes());
                        System.
    out .println( " ==len=== " + head.getMsglen());
                        System.
    out .println( " ==res=== " + head.getMsgres());
                        System.
    out .println( " ==seq=== " + head.getMsgseq());
                        System.
    out .println( " ==type=== " + head.getMsgtype());
                        System.
    out .println( " ==Termid=== " + head.getTermid());
                        System.
    out .println( " ==Termversion=== "
                               
    + head.getTermversion());

                        CMsgReg body
    = CMsgReg.parseFrom(msg.getMsgbody()
                                .getBytes());
                        System.
    out .println( " ==area== " + body.getArea());
                        System.
    out .println( " ==Region== " + body.getRegion());
                        System.
    out .println( " ==shop== " + body.getShop());

                       
    // PrintWriter out = new PrintWriter(new BufferedWriter(
                       
    // new OutputStreamWriter(client.getOutputStream())),
                       
    // true);
                       
    // out.println("return    " +msg.toString());

                       
    // in.close();
                       
    // out.close();

                        sendProtoBufBack(dataOutputStream);

                        inputstream.close();
                       
    // dataInputStream.close();
                    } catch (Exception ex) {
                        System.
    out .println(ex.getMessage());
                        ex.printStackTrace();
                    }
    finally {
                        client.close();
                        System.
    out .println( " close " );
                    }
                }
            }
    catch (IOException e) {
                System.
    out .println(e.getMessage());
            }
        }

       
    public static void main(String[] args) {
            Thread desktopServerThread
    = new Thread( new AndroidServer());
            desktopServerThread.start();
        }

       
    private byte [] getProtoBufBack() {

           
    // head
            CMsgHead head = CMsgHead.newBuilder().setMsglen( 5 )
                    .setMsgtype(
    1 ).setMsgseq( 3 ).setTermversion( 41 )
                    .setMsgres(
    5 ).setTermid( " 11111111 " ).build();

           
    // body
            CMsgReg body = CMsgReg.newBuilder().setArea( 22 )
                    .setRegion(
    33 ).setShop( 44 ).build();

           
    // Msg
            CMsg msg = CMsg.newBuilder()
                    .setMsghead(head.toByteString().toStringUtf8())
                    .setMsgbody(body.toByteString().toStringUtf8())
                    .build();

           
    return msg.toByteArray();
        }

       
    private void sendProtoBufBack(DataOutputStream dataOutputStream) {

           
    byte [] backBytes = getProtoBufBack();
           
    // 协议头部
       
    //     Integer len2 = backBytes.length;
           
    // 前四个字节,标示协议正文长度
       
    //     byte[] cmdHead2 = BytesUtil.IntToBytes4(len2);

           
    try {
               
    // dataOutputStream.write(cmdHead2, 0, cmdHead2.length);
                dataOutputStream.write(backBytes, 0 , backBytes.length);
                dataOutputStream.flush();
            }
    catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    最后得到的效果:

    客户端:

    服务端:

    protobuf .net版的实现代码如下:

    using System;
    using System.IO;
    using System.Net;
    using System.Net.Sockets;
    using System.Threading;
    using Google.ProtocolBuffers;
    using msginfo;
    using System.Text;
    using System.Collections;
    using System.Collections.Generic;

    namespace protobuf_csharp_sport
    {
       
    class Program
        {
           
    private static ManualResetEvent allDone = new ManualResetEvent( false );

           
    static void Main( string [] args)
            {
                beginProtocbuf();
            }

           
    private static void beginProtocbuf()
            {
               
    // 启动服务端
                TcpListener server = new TcpListener(IPAddress.Parse( " 127.0.0.1 " ), 12345 );
                server.Start();
                server.BeginAcceptTcpClient(clientConnected, server);
                Console.WriteLine(
    " SERVER : 等待数据 --- " );

               
    // 启动客户端
                ThreadPool.QueueUserWorkItem(runClient);
                allDone.WaitOne();

                Console.WriteLine(
    " SERVER : 退出 --- " );
               
    // server.Stop();
            }

           
    // 服务端处理
            private static void clientConnected(IAsyncResult result)
            {
               
    try
                {
                    TcpListener server
    = (TcpListener)result.AsyncState;
                   
    using (TcpClient client = server.EndAcceptTcpClient(result))
                    {
                       
    using (NetworkStream stream = client.GetStream())
                        {
                           
    // 获取
                            Console.WriteLine( " SERVER : 客户端已连接,数据读取中 --- " );
                           
    byte [] myRequestBuffer = new byte [ 1024 ];

                           
    int myRequestLength = 0 ;
                           
    do
                            {
                                myRequestLength
    = stream.Read(myRequestBuffer, 0 , myRequestBuffer.Length);
                            }
                           
    while (stream.DataAvailable);
                            
                            CMsg msg
    = CMsg.ParseFrom(myRequestBuffer.RemoveEmptyByte(myRequestLength));

                            CMsgHead head
    = CMsgHead.ParseFrom(Encoding.ASCII.GetBytes(msg.Msghead));
                            CMsgReg body
    = CMsgReg.ParseFrom(Encoding.ASCII.GetBytes(msg.Msgbody));

                            IDictionary
    < Google.ProtocolBuffers.Descriptors.FieldDescriptor, object > d = head.AllFields;
                           
    foreach (var item in d)
                            {
                                Console.WriteLine(item.Value.ToString());
                            }

                            d
    = body.AllFields;
                            Console.WriteLine(
    " =========================================== " );
                           
    foreach (var item in d)
                            {
                                Console.WriteLine(item.Value.ToString());
                            }
                         
                            Console.WriteLine(
    " SERVER : 响应成功 --- " );

                            Console.WriteLine(
    " SERVER: 关闭连接 --- " );
                            stream.Close();
                        }
                        client.Close();
                    }
                }
               
    finally
                {
                    allDone.Set();
                }
            }

           
    // 客户端请求
            private static void runClient( object state)
            {
               
    try
                {
                    CMsgHead head
    = CMsgHead.CreateBuilder()
                        .SetMsglen(
    5 )
                        .SetMsgtype(
    1 )
                        .SetMsgseq(
    3 )
                        .SetTermversion(
    4 )
                        .SetMsgres(
    5 )
                        .SetTermid(
    " 11111111 " )
                        .Build();

                    CMsgReg body
    = CMsgReg.CreateBuilder().
                        SetArea(
    22 )
                       .SetRegion(
    33 )
                       .SetShop(
    44 )
                       .Build();

                    CMsg msg
    = CMsg.CreateBuilder()
                        .SetMsghead(head.ToByteString().ToStringUtf8())
                        .SetMsgbody(body.ToByteString().ToStringUtf8())
                        .Build();

                    Console.WriteLine(
    " CLIENT : 对象构造完毕 ... " );

                   
    using (TcpClient client = new TcpClient())
                    {
                       
    // client.Connect(new IPEndPoint(IPAddress.Parse("192.168.1.116"), 12345));
                        client.Connect( new IPEndPoint(IPAddress.Parse( " 127.0.0.1 " ), 12345 ));
                        Console.WriteLine(
    " CLIENT : socket 连接成功 ... " );

                       
    using (NetworkStream stream = client.GetStream())
                        {
                           
    // 发送
                            Console.WriteLine( " CLIENT : 发送数据 ... " );
                         
                            msg.WriteTo(stream);

                           
    // 关闭
                            stream.Close();
                        }
                        client.Close();
                        Console.WriteLine(
    " CLIENT : 关闭 ... " );
                    }
                }
               
    catch (Exception error)
                {
                    Console.WriteLine(
    " CLIENT ERROR : {0} " , error.ToString());
                }
            }

        }
    // end class


       
    public static class ExtensionClass {
           
    public static byte [] RemoveEmptyByte( this byte [] by, int length)
            {
               
    byte [] returnByte = new byte [length];

               
    for ( int i = 0 ; i < length; i ++ )
                {
                    returnByte[i]
    = by[i];
                }
               
    return returnByte;

            }
        }

    }

    运行的效果:

    这样就OK了,之后就可以把java 服务端的IP或端口改成C# IP和服务端的商品一样,或者反过来也是可以的。

     

    转载:http://blog.csdn.net/xiaojunhu/article/details/7367314

    展开全文
  • ProtoBuf 官方文档(一)- 开发者指南

    千次阅读 2019-06-25 16:34:22
    翻译查阅外网资料过程中遇到的比较优秀的文章...此文翻译自 Protocol Buffers 官方文档 Developer Guide 部分 翻译为意译,不会照本宣科的字字对照翻译 以下为原文内容翻译 开发者指南 欢迎使用 protocol buff...
  • protobuf学习总结

    2019-09-09 12:49:09
    ProtoBuf学习总结)protobuf概念定义Messageproto文件的定义Message 数字域与规则功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一...
  • protobuf学习笔记

    2021-08-10 20:31:39
    protobuf官方网址:...1. protobuf是什么 “Protocol buffers are Google’s language-neutral, platform-neutral, extensible mechanism for serializing structured data – think
  • ProtoBuf 学习

    2017-03-04 05:19:00
    我的疑惑 : 它既然类似于json通讯协议,那么是...那protobuf是怎么操作的呢?我如何解析,感觉它最多像个bean) Paste_Image.png 参考资料链接 as 中配置 http://www.cnblogs.com/angrycode/p/6238058.htm...
  • protobuf 学习笔记

    千次阅读 2016-04-28 15:28:24
    初次接触protobuf,在此整理一下自己的一些学习过程及问题,作为笔记或者分享来互相学习
  • 此文翻译自 Protocol Buffers 官方文档 Developer Guide 部分 翻译为意译,不会照本宣科的字字对照翻译 以下为原文内容翻译 开发者指南 欢迎使用 protocol buffers 的开发者文档, protocol buffers 是一种...
  • Protobuf学习 - 入门

    2018-03-30 15:32:34
    Protobuf学习 - 入门 古之立大事者,不惟有超世之才,亦必有坚忍不拔之志 -- 苏轼·《晁错论》 从公司的项目源码中看到了这个东西,觉得挺好用的,写篇博客做下小总结。下面的操作以C++为编程语言,protoc的版本...
  • Protobuf学习笔记

    千次阅读 2012-11-09 20:31:20
    Protobuf学习笔记 Posted by iamxhuon 2012/05/22 Leave a comment (0)Go to comments Protocol buffers是什么? 首先了解一下Protocol Buffers(简称ProtoBuf)是什么?官网对它的定义如下: Protocol ...
  • 翻译查阅外网资料过程中遇到的比较优秀的文章和资料,一是作为技术参考以便... 此文翻译自 Protocol Buffers 官方文档 Developer Guide 部分 翻译为意译,不会照本宣科的字字对照翻译 以下为原文内容翻译 开发...
  • protobuf学习 - 入门

    2018-02-12 17:01:18
    转自:https://www.cnblogs.com/autyinjing/p/6495103.html从公司的项目源码中看到了这个东西,觉得挺好用...一、Protobuf? 1. 是什么? Google Protocol Buffer(简称 Protobuf)是一种轻便高效的结构化数据存储格...
  • protobuf学习资料整理

    2015-04-10 10:09:00
    最近准备使用protobuf, 整理一下比较好的学习资料. 1. 官方文档:https://developers.google.com/protocol-buffers 有些内容是基于proto3的, 大部分情况下proto2也都适用 2. IBM developworks的入门文章:...
  • Protobuf 学习手册——语法篇

    千次阅读 2020-01-19 22:41:03
    Protobuf1 是一种语言中立、平台无关、可扩展的序列化数据的格式,可用于通信协议,数据存储等。 ProtoBuf 在序列化数据方面,它是灵活的、高效的。相比于 XML 来说,ProtoBuf 更加小巧、更加快速、更加简单。一旦...
  • Protobuf学习笔记(一)

    千次阅读 2016-09-15 12:30:28
    Protobuf基础概念 Protobuf是google开发的数据结构描述语言,能够将结构化数据序列化与反序列化,取代json和xml,常用于服务器通信协议、RPC系统和数据持久化存储系统中。 优点:高性能,数据协议小,平台无关,语言...
  • Protobuf学习(1)

    2015-03-27 10:43:01
    今天开始学习 Protobuf。在一篇博客里面说, Protobuf是结构化数据存储,什么是结构化数据存储呢?既然有结构化数据存储,想必也有非结构化数据存储把。 在经过一番百度后,得到如下结论)。 结构化数据存储 & 非...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,348
精华内容 2,939
关键字:

protobuf学习文档