protobuf 学习

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