c/c++服务端,java客户端采用Protobuf通信

C++ server:linux, protoc -I=./ --cpp_out=./ Infor.proto
Java client:包含protobuf-java-2.5.0.jar包, protoc.exe --java_out=./ Infor.proto

Infor.proto文件:

 1 message my_message{
 2     required string startedTime =1;
 3     required string version=2;
 4     required double configuredCapacity=3;
 5     required double dfsUsed =4;
 6     required int32 fileNum=5;
 7     required int32 replicatedFilesNum =6;
 8     required int32 blockNum =7;
 9     required int32 livedNodeNum =8;
10     required int32 decommissioningNodeNum=9;
11 }

Server.cpp

  1 #include <netinet/in.h>    // for sockaddr_in
  2 #include <sys/types.h>    // for socket
  3 #include <sys/socket.h>    // for socket
  4 #include <unistd.h>
  5 #include <stdio.h>        // for printf
  6 #include <stdlib.h>        // for exit
  7 #include <string.h>        // for bzero
  8 #include <string>
  9 #include <google/protobuf/message_lite.h>
 10 #include <google/protobuf/io/coded_stream.h>
 11 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
 12 #include "infor.pb.h"
 13
 14 #define HELLO_WORLD_SERVER_PORT    8000
 15 #define LENGTH_OF_LISTEN_QUEUE 20
 16
 17 int main()
 18 {
 19     std::string time = "2015-06-25";
 20     std::string version = "0.0.1";
 21     double config = 2.0;
 22     double dfs = 3.0;
 23     int file = 1000;
 24     int rep = 1000;
 25     int block = 1000;
 26     int live = 1000;
 27     int de = 1000;
 28
 29     struct sockaddr_in server_addr;
 30     bzero(&server_addr,sizeof(server_addr));
 31     server_addr.sin_family = AF_INET;
 32     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
 33     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
 34
 35     int server_socket = socket(PF_INET,SOCK_STREAM,0);
 36     if( server_socket < 0)
 37     {
 38         printf("Create Socket Failed!");
 39         exit(1);
 40     }
 41     {
 42        int opt =1;
 43        setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
 44     }
 45
 46     if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr)))
 47     {
 48         printf("Server Bind Port : %d Failed!", HELLO_WORLD_SERVER_PORT);
 49         exit(1);
 50     }
 51
 52     if ( listen(server_socket, LENGTH_OF_LISTEN_QUEUE) )
 53     {
 54         printf("Server Listen Failed!");
 55         exit(1);
 56     }
 57     while (true)
 58     {
 59         struct sockaddr_in client_addr;
 60         socklen_t length = sizeof(client_addr);
 61
 62         int new_server_socket = accept(server_socket,(struct sockaddr*)&client_addr,&length);
 63         if ( new_server_socket < 0)
 64         {
 65             printf("Server Accept Failed!\n");
 66             break;
 67         }
 68
 69         my_message mm;
 70         mm.set_startedtime(time);
 71         mm.set_version(version);
 72         mm.set_configuredcapacity(config);
 73         mm.set_dfsused(dfs);
 74         mm.set_filenum(file);
 75         mm.set_replicatedfilesnum(rep);
 76         mm.set_blocknum(block);
 77         mm.set_livednodenum(live);
 78         mm.set_decommissioningnodenum(de);
 79         file += 1; rep += 1; block += 1; live += 1; de += 1;
 80
 81         int len = mm.ByteSize() + 4;
 82         char *buffer = new char[len];
 83
 84         google::protobuf::io::ArrayOutputStream arrayOut(buffer, len);
 85         google::protobuf::io::CodedOutputStream codedOut(&arrayOut);
 86
 87         codedOut.WriteVarint32(mm.ByteSize());
 88
 89         //write protobuf my_message mm to CodedOutputStream
 90         mm.SerializeToCodedStream(&codedOut);
 91
 92         if(send(new_server_socket,buffer,len,0)<0)
 93         {
 94             printf("Send Failed\n");
 95             break;
 96         }
 97
 98         close(new_server_socket);
 99         delete buffer;
100     }
101     close(server_socket);
102     return 0;
103 }

Client:

 1 import java.io.BufferedReader;
 2 import java.io.DataInputStream;
 3 import java.io.DataOutputStream;
 4 import java.io.IOException;
 5 import java.io.InputStream;
 6 import java.io.InputStreamReader;
 7 import java.net.Socket;
 8
 9 import java.io.ByteArrayInputStream;
10 import java.io.ByteArrayOutputStream;
11 import java.io.IOException;
12 import java.util.List;
13
14 import com.google.protobuf.CodedInputStream;
15
16 public class Client {
17     public static final String IP_ADDR = "127.0.0.1";    //server ip
18     public static final int PORT = 8000;    //port
19
20     public static void main(String[] args) throws InterruptedException {
21         System.out.println("client starting...");
22
23         while (true) {
24             Thread.sleep(1000);
25             Socket socket = null;
26             try {
27                 socket = new Socket(IP_ADDR, PORT);
28
29                 InputStream input = socket.getInputStream();
30                 try{
31                     // 反序列化
32                     Infor.my_message mm = Infor.my_message.parseDelimitedFrom(input);
33
34                     System.out.println();
35                     System.out.println();
36                     System.out.println();
37                     System.out.println("服务器端返回过来的是: ");
38                     System.out.println("startedTime:" + mm.getStartedTime());
39                     System.out.println("version:" + mm.getVersion());
40                     System.out.println("configuredCapacity:" + mm.getConfiguredCapacity());
41                     System.out.println("dfsUsed:" + mm.getDfsUsed());
42                     System.out.println("fileNum:" + mm.getFileNum());
43                     System.out.println("replicatedFilesNum:" + mm.getReplicatedFilesNum());
44                     System.out.println("blockNum:" + mm.getBlockNum());
45                     System.out.println("livedNodeNum:" + mm.getLivedNodeNum());
46                     System.out.println("decommissioningNodeNum:" + mm.getDecommissioningNodeNum());
47                 } catch(Exception e)
48                 {
49                     System.out.println(e.toString());
50                     System.out.println("catch e");
51                     break;
52                 }
53                 input.close();
54             } catch (Exception e) {
55                 System.out.println("客户端异常:" + e.getMessage());
56             } finally {
57                 if (socket != null) {
58                     try {
59                         socket.close();
60                     } catch (IOException e) {
61                         socket = null;
62                         System.out.println("客户端 finally 异常:" + e.getMessage());
63                     }
64                 }
65             }
66         }
67     }
68 }  

运行结果:

参考链接&可能遇到的问题:

http://blog.csdn.net/xiao__gui/article/details/36643949
http://www.javased.com/?api=com.google.protobuf.CodedInputStream
https://webcache.googleusercontent.com/search?q=cache:0T1W5ECY5vMJ:blog.ajhodges.com/2011/10/cross-platform-communication-using.html+&cd=2&hl=zh-CN&ct=clnk
http://stackoverflow.com/questions/26655733/protobuf-codedinputstream-parsing-partial-messages
http://stackoverflow.com/questions/14272852/trying-to-send-and-receive-message-using-protobuf-in-java-but-got-error-protoco
https://famellee.wordpress.com/2013/04/29/transmit-multiple-google-protocol-buffers-messages-between-java-and-c/

时间: 2024-10-11 03:31:01

c/c++服务端,java客户端采用Protobuf通信的相关文章

[C语言]一个很实用的服务端和客户端进行TCP通信的实例

本文给出一个很实用的服务端和客户端进行TCP通信的小例子.具体实现上非常简单,只是平时编写类似程序,具体步骤经常忘记,还要总是查,暂且将其记下来,方便以后参考. (1)客户端程序,编写一个文件client.c,内容如下: #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <string.h> #include <sys/types.h> #include <

java 界面编程用socket实现服务端与客户端的循环通信。

服务端: package 实验五聊天; import java.awt.BorderLayout; import java.awt.EventQueue; import java.io.BufferedReader; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.InputStreamReader; import java.io.PrintWriter; import java.ne

[C语言]一个很实用的服务端和客户端进行UDP通信的实例

前段时间发了个TCP通信的例子,现在再来一个UDP通信的例子.这些可以作为样本程序,用到开发中.“裸写”socket老是记不住步骤,经常被鄙视…… 下面的例子很简单,写一个UDP的server用于收包,写一个UDP的client用于发包并接收来自server的回复.其中UDP的client写了两个,一个是不需要connect的,另一个是带上connect的,两个client实现的功能是一样的.从效率上,带上connect的UDP肯定效率稍微高一些.不过UDP的connect和TCP里面非常不一样

DatagramSocket客户端与服务端Java实例

1 import java.io.IOException; 2 import java.net.DatagramPacket; 3 import java.net.DatagramSocket; 4 import java.net.InetAddress; 5 6 public class TimeClient_UDP{ 7 public static void main(String args[]) throws IOException{ 8 String host = "localhost&

用Java实现HTTP Multipart的服务端和客户端

今天简单介绍一下如何用Java支持HTTP Multipart的request和response. 整个项目的代码可以在https://github.com/mcai4gl2/multi下载. 在这个程序里,我们的业务场景很简单.在服务端有一个随机数生成器,可以生成随机的Integer和Guid,客户端通过服务,可以请求一个或多个随机数.同时,客户端可以向服务端发送一个或多个随机数,这些随机数会被加入到一个队列中,被其他的客户端通过请求获得.以下是我们的随机数Bean的定义: [java] vi

Java网络编程【Socket服务端和客户端】

Socket 编程大家都不陌生,Java 学习中必学的部分,也是 Java网络编程核心内容之一.Java 网络编程又包括 TCP.UDP,URL 等模块.TCP 对应 Socket模块,UDP 对应 DatagramPacket 模块.URL 对应 URL 模块.其中 TCP 和 UDP 是网络传输协议,TCP 是数据流传输协议,UDP 是数据包传输协议.两者之间的异同就不在这里说了,推荐一本入门书籍 <TCPIP入门经典>.我们开始 Socket 服务端和客户端编程吧. 一.Socket 服

java中socket创建服务端与客户端即时对聊

package tool; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; impo

grpc(3):使用 golang 开发 grpc 服务端和客户端

1,关于grpc-go golang 可以可以做grpc的服务端和客户端. 官网的文档: http://www.grpc.io/docs/quickstart/go.html https://github.com/grpc/grpc-go 和之前写的java的grpc客户端调用相同.也需要使用protobuf的配置文件. 但是golang下面的类库非常的简单,而且golang的性能也很强悍呢. 有些简单的业务逻辑真的可以使用golang进行开发. 性能强悍而且,消耗的资源也很小.java感觉上已

webService服务端和客户端开发 简单实例

这几天一直在看webService相关的知识. webService是一个跨平台访问的第三方插件,方便易用,多平台使用. 开发中我们可能自己是服务端,提供webService接口给别人访问我们的系统:也有可能我们调用别人的webService接口去访问别人的系统(比如查询天气预报). 下面是服务端和客户端的开发,实际开发中我们只是其中一方. 服务端开发: ①创建一个服务类,运行main方法发布即可,服务端就开发完成了. package com.lijianbo.service; import j