本节为您介绍Protobuf实现Android Socket通讯开发教程,因此,我们需要先了理一下protobuf 是什么?

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

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和服务端的商品一样,或者反过来也是可以的。c++版本经过测试也是可以的。简直是一个爽字。

本文Protobuf实现Android Socket通讯开发教程就为您介绍到这里了!

Protobuf实现Android Socket通讯开发教程的更多相关文章

  1. Android OpenGL ES 开发教程 从入门到精通

    感谢,摘自:http://blog.csdn.net/mapdigit/article/details/7526556 Android OpenGL ES 简明开发教程 Android OpenGL ...

  2. Android 即时通讯开发小结(二)

    <Android 即时通讯开发小结>基于IM Andriod 开发的各种常见问题,结合网易云信即时通讯技术的实践,对IM 开发做一个全面的总结. 相关推荐阅读:. Android 即时通讯 ...

  3. Android 即时通讯开发小结(一)

    <Android 即时通讯开发小结>基于IM Andriod 开发的各种常见问题,结合网易云信即时通讯技术的实践,对IM 开发做一个全面的总结. 相关推荐阅读:. Android 即时通讯 ...

  4. android 编译环境 & 开发教程 【持续更新】

    一. 优秀博文推荐 1.ubuntu 搭建 android源码编译环境 ubuntu14.04LTS android 源码编译环境的搭建 2.开源网站 2.android 开源 网站 2015最流行的 ...

  5. 天地币:所用到的 Android Socket 通讯编程技术试验

    1.为了开发"天地币"这个Android手机项目,须要用到Socket编程. 2.天地币是一种类似于比特币的虚拟货币. 3.为了赚取CSDN的C币,须要写篇博客. 4.干脆将调试S ...

  6. android socket 通讯(客户端) 发送数据

    /** ClientSocket通讯类 **/  public class ClientSocket  {     /**服务器地址*/     private String serverUrl=&q ...

  7. android蓝牙通讯开发(详细)

    新建一个工程之后,我们可以先看到界面左边的项目栏,我们可以看到,除了app目录以外,大多数的文件和目录都是自动生成的,我们也不需要对他们进行修改,而app目录之下的文件才是我们工作的重点.下面,我先对 ...

  8. Android JNI/NDK开发教程

    JNI/NDK开发指南:http://blog.csdn.net/xyang81/article/details/41759643

  9. Android四大组件简介:Android 基础知识,开发教程

    Android 四大组件: Activity.Service.Broadcast Receiver.Content Provider. http://developer.android.com/int ...

随机推荐

  1. php锁表

    用PHP实现mysql锁表 mysql锁表,是利用相关的SQL语句 //执行SQL语句 锁掉userinfo表 $sql = "LOCK TABLES userinfo WRITE" ...

  2. Android开发手记(14) 使用MediaPlayer播放mp3

    1.获取MediaPlayer实例 (1)可以直接通过new或者create方式: 调用setDataSource和create的区别是,create时已经执行了MediaPlayer.prepare ...

  3. SQL用row_number进行高速循环

    SQL用row_number进行循环查询 declare @count int=0,@R int=0select row_number()over(order by RoomID) as R,* in ...

  4. 视图必须派生自 WebViewPage 或 WebViewPage错误解决方法

    1,在每个视图上面添加 @inherits System.Web.Mvc.WebViewPage 2,将views中的web.config COPY到新的视图模版文件夹下,就可以了

  5. 编译的时候 c:\windows\assembly\ 卸载不掉

    easyhook 开始还可以调试,几次过后 其自己去找c:\windows\assembly\ 下的包,编译多少次都不行. c:\windows\assembly\  卸载不掉 cmd cd \win ...

  6. 周末献礼 MyVoix2.0.js 麦克风波形绘制(一)

    最近更新了之前发布的语音识别框架MyVoix,加入了麦克风的波形分析效果.没有看过MyVoix介绍的同学请猛戳(传送门) Github地址 在新的更新中,波形分析可以绑定麦克风源,也可以单独配合别的音 ...

  7. VS2010安装项目的系统必备中添加.NET 2.0

    把DotNetFX.rar解压后的DotNetFX文件夹,放置于安装了 VS2010 的 C:\Program Files\Microsoft SDKs\Windows\v7.0A\Bootstrap ...

  8. 转:exit()与_exit()的区别

    版权声明:本文为博主原创文章,未经博主允许不得转载. 从图中可以看出,_exit 函数的作用是:直接使进程停止运行,清除其使用的内存空间,并清除其在内核的各种数据结构:exit 函数则在这些基础上做了 ...

  9. html标签引入外部html

    <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title> ...

  10. makefile高级用法--使用函数

    makefile高级用法--使用函数 分类: C/C++ 使用函数 ———— 在Makefile中可以使用函数来处理变量,从而让我们的命令或是规则更为的灵活和具有智能.make所支持的函数也不算很多, ...