Java与C之间的socket通信

快来打我* 2022-07-28 01:12 194阅读 0赞

原文地址：[http://blog.csdn.net/yutianzuijin/article/details/24807417][http_blog.csdn.net_yutianzuijin_article_details_24807417]

最近正在开发一个基于指纹的音乐检索应用，算法部分已经完成，所以尝试做一个Android App。Android与服务器通信通常采用HTTP通信方式和Socket通信方式。由于对web服务器编程了解较少，而且后台服务器已经采用原始socket实现与c客户端通信，这就要求Android客户端也采用socket实现。所以在开发Android app时采用了原始socket进行编程。

由于算法是用C语言实现的，而Android应用一般是Java开发，这就不可避免得涉及Java和C语言之间的通信问题。一种方案是在客户端采用JNI方式，上层UI用Java开发，但是底层通信还是用C的socket完成。这种方案需要掌握JNI编程，对不少Java开发者是个障碍。为了减小开发难度，最好的方案是直接用Java socket与C socket进行通信。但是这种方案也有问题，最大的问题在于API和数据格式的不统一。本人在本科曾尝试利用Java和c的socket进行通信，发现根本无法传递数据，一度认为这两种socket之间无法通信。今天重拾旧问题，必须一次性地完美地解决Java和C之间的socket通信问题。在此可以先将实现总结为1句话：通信全部用字节实现。

在介绍Java和c之间的socket通信之前，首先将音乐检索大概介绍一下，更详细的内容可参考[基于指纹的音乐检索][Link 1]。基于指纹的音乐检索就是让用户录制一段正在播放的音乐上传服务器，服务器通过提取指纹进行检索获得相应的歌名返回给用户，就这么简单。简单的工作原理如图一。所以在该应用中，socket通信主要涉及两个方面：客户端向服务器发送文件和服务器向客户端发送结果两部分。下面先介绍服务器部分。

![20140430180021859][]

图1 音乐检索的简单工作原理示意图

### 1 服务器设计 ###

服务器端采用C socket进行通信，同时为了能响应多用户请求，服务器端需要采用多线程编程。为了专注于socket通信，已经将无关代码去掉，首先看main方法。

**\[cpp\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  typedef struct  
2.  \{  
3.  int client\_sockfd;  
4.  ……  
5.  \}client\_arg;  
6.    
7.  void get\_ip\_address(unsigned long address,char\* ip)  
8.  \{  
9.    sprintf(ip,"%d.%d.%d.%d",address>>24,(address&0xFF0000)>>24,(address&0xFF00)>>24,address&0xFF);  
10. \}  
11.   
12. int main()  
13. \{  
14.     int server\_sockfd;  
15.     int server\_len;  
16.     struct sockaddr\_in server\_address;  
17.     int result;  
18.       
19.     server\_sockfd=socket(AF\_INET,SOCK\_STREAM,0);  
20.   
21.     server\_address.sin\_family=AF\_INET;  
22.     server\_address.sin\_addr.s\_addr=htonl(INADDR\_ANY);  
23.     server\_address.sin\_port=htons(9527);  
24.     server\_len=sizeof(server\_address);  
25.   
26.     bind(server\_sockfd,(struct sockaddr\*)&server\_address,server\_len);  
27.   
28.     listen(server\_sockfd,MAX\_THREAD);  
29.   
30.     while(true)  
31.     \{  
32.         int client\_sockfd;  
33.         struct sockaddr\_in client\_address;  
34.         int client\_len;  
35.         char ip\_address\[16\];  
36.         client\_arg\* args;  
37.         client\_len=sizeof(client\_address);  
38.   
39.         client\_sockfd=accept(server\_sockfd,(struct sockaddr\*)&client\_address,(socklen\_t\*)&client\_len);  
40.   
41.         args=(client\_arg\*)malloc(sizeof(client\_arg));  
42.         args->client\_sockfd=client\_sockfd;  
43.   
44.         get\_ip\_address(ntohl(client\_address.sin\_addr.s\_addr),ip\_address);  
45.         printf("get connection from %s\\n",ip\_address);  
46.   
47.         //create a thread to process the query/  
48.         pthread\_t client\_thread;  
49.         pthread\_attr\_t thread\_attr;  
50.         int res;  
51.   
52.         res=pthread\_attr\_init(&thread\_attr);  
53.         if(res !=0)  
54.         \{  
55.             perror("Attribute creation failed");  
56.             free(args);  
57.             close(client\_sockfd);  
58.             continue;  
59.         \}  
60.   
61.         res=pthread\_attr\_setdetachstate(&thread\_attr,PTHREAD\_CREATE\_DETACHED);  
62.         if(res !=0)  
63.         \{  
64.             perror("Setting detached attribute failed");  
65.             free(args);  
66.             close(client\_sockfd);  
67.             continue;  
68.         \}  
69.   
70.         res=pthread\_create(&client\_thread,&thread\_attr,one\_query,(void\*)args);  
71.         if(res !=0)  
72.         \{  
73.             perror("Thread creation failed");  
74.             free(args);  
75.             close(client\_sockfd);  
76.             continue;  
77.         \}  
78.   
79.         pthread\_attr\_destroy(&thread\_attr);  
80.   
81.     \}  
82.     return 0;  
83. \}

服务器端采用标准的TPC（threadper connection）架构，即服务器每获得一个客户端请求，都会创建一个新的线程负责与客户端通信，具体的任务都在每一个线程中完成。这种方式有个缺点，就是存在线程的频繁创建和删除，所以还可以将accept函数放入每一个线程中进行独立监听（这种方式需要加锁）。需要注意的是我们需要设置线程属性为detached，表示主线程不等待子线程。下面介绍每个线程具体完成的任务：

1.  void get\_time(char\* times)  
2.  \{  
3.      time\_t timep;  
4.      struct tm\* p;  
5.    
6.      timep=time(NULL);  
7.      p=gmtime(&timep);  
8.    
9.      sprintf(times,"%d-%02d-%02d-%02d-%02d-%02d",p->tm\_year+1900,p->tm\_mon+1,p->tm\_mday,  
10.             p->tm\_hour+8,p->tm\_min,p->tm\_sec);  
11. \}  
12.   
13. int recv\_file(char\* path,int client\_sockfd,int file\_length)  
14. \{  
15.     FILE\* fp;  
16.     int read\_length;  
17.     char buffer\[1024\];  
18.   
19.     fp=fopen(path,"wb");  
20.     if(fp==NULL)  
21.     \{  
22.         perror("Open file failed");  
23.         return -1;  
24.     \}  
25.   
26.     while((read\_length=recv(client\_sockfd,buffer,1023,0))>0)  
27.     \{  
28.         buffer\[read\_length\]='\\0';  
29.         fwrite(buffer,1,read\_length,fp);  
30.   
31.         file\_length-=read\_length;  
32.         if(!file\_length)  
33.         \{  
34.             fclose(fp);  
35.             printf("write to file %s\\n",path);  
36.             return 0;  
37.         \}  
38.     \}  
39.   
40.     return 0;  
41. \}  
42.   
43. void\* one\_query(void\* arg)  
44. \{  
45.     char file\_name\[32\];  
46.     char path\[64\]="./recv\_data/";  
47.     char length\[10\];  
48.     int file\_length=0;  
49.   
50.     client\_arg\* args=(client\_arg\*)arg;  
51.     int sockfd=args->client\_sockfd;  
52.   
53.     get\_time(file\_name);  
54.     strcat(file\_name,".wav");  
55.     strcat(path,file\_name);  
56.   
57.     /1.receive file length//  
58.     recv(sockfd,length,10,0);  
59.     file\_length=atoi(length);  
60.     printf("file length is %d\\n",file\_length);  
61.   
62.     /2.receive file content//  
63.     if(recv\_file(path,sockfd,file\_length)==-1)  
64.     \{  
65.         perror("receive file failed");  
66.         close(sockfd);  
67.         pthread\_exit(NULL);  
68.     \}  
69.   
70.     result\* list;  
71.   
72.     //3.search the fingerprint library, and get the expected music id//  
73.     int count=match(&list);  
74.   
75.     char result\_to\_client\[2000\];  
76.   
77.     for(int i=0;i<count;i++)  
78.     \{  
79.         if(list\[i\].confidence>0.4)  
80.         \{  
81.             memset(length,0,sizeof(length));  
82.             memset(result\_to\_client,0,sizeof(result\_to\_client));  
83.   
84.             /4. retrieve the database to get detailed information //  
85.             MYSQL\_RES\* res=select\_music\_based\_on\_id(list\[i\].id);  
86.             row\_result\* row\_res=fetch\_row(res);  
87.               
88.             sprintf(result\_to\_client,"%s,%s,%s,%d,%d,%lf",row\_res->name,row\_res->artist,row\_res->album,list\[i\].score,list\[i\].start\_time,list\[i\].confidence);  
89.   
90.             /5. Send a retrieval flag(1:success,0:fail)//  
91.             sprintf(length,"%d",1);  
92.             send(sockfd,length,10,0);  
93.   
94.             /6. Send the result  
95.             send(sockfd,result\_to\_client,2000,0);  
96.   
97.             free\_result(res);  
98.             free\_row(row\_res);  
99.         \}  
100.         else  
101.         \{  
102.             memset(length,0,sizeof(length));  
103.             sprintf(length,"%d",0);  
104.             send(sockfd,length,10,0);  
105.         \}  
106.     \}  
107.   
108.     free(list);  
109.     close(sockfd);  
110.   
111.     pthread\_exit(NULL);  
112. \}

one\_query函数实现了每个线程与客户端通信的代码。代码核心的部分可以表示为六步：1. 从客户端读取录制音频的长度；2. 读取实际的音频，并保存到文件，文件以当前时间命名；3. 检索指纹服务器，获得检索的音乐id；4. 如果检索结果置信度高，则利用检索到的id访问数据库获得更加详细的音乐信息；5. 给用户发送一个成功/失败标注；6. 如果检索成功，发送具体的音乐信息。

#### 1.1 读取文件长度 ####

在第一步读取音频长度时，我们采用了原始socket中的recv函数。该函数原型为：

Int recv(intsocket, void \*buff, int length, int flags)

接收数据用void\* 获取，我们可以用char数组按照字节来读取，读取之后再解析。需要注意的一点是参数中传递的长度必须大于客户端可能传递过来的长度，在此我们用10字节来表示传递的上限（int型最大约为4\*109，需要10位，加上’\\0’需要11位，但是音频长度远小于最大的int值，所以只分配10位）。读到的char数组之后利用atoi转化为实际的int型整数。网上很多博客在介绍Java和C之间的socket通信时会涉及复杂的大小端问题，由于我们将所有的数据都转成字节数组传递，所以不存在这个问题。

#### 1.2 读取音频文件 ####

音频文件的读取在recv\_file中实现。读取的核心还是按照字节流来完成，每次读取1023字节的数据，然后写入文件。这里有两点需要注意：首先recv读取的长度和我们指定的长度可能不一致，也即返回的长度小于1023，我们需要以返回的长度为准；分配的数组长度是1024，但是我们每次读取的数据最长只能为1023，这是因为我们需要在读取数据的最后添加一个’\\0’标记，用来标记数据的末尾。读取结束的标志是达到之前传递过来的文件长度。

#### 1.3 检索指纹库 ####

该步骤在获得完整的音频文件之后，就对该文件提取指纹然后检索指纹库，原理可参考[基于指纹的音乐检索][Link 1]，在此不再赘述。检索的结果是一个音乐的top5列表。每一项结果都有检索得到的音乐id和相应的置信度。

#### 1.4 访问数据库 ####

该步骤在top 5列表中有置信度大于0.4的音乐时执行。利用检索得到的id去访问数据库，获得音乐的名字和作者等信息。

#### 1.5 发送flag标记 ####

在发送具体的信息之前先发送一个标记，表示此次检索是成功还是失败，方便客户端显示。如果成功，发送标记‘1’，失败则发送标记‘0’。发送时，并不是直接发送一个int型的整数，而是首先利用sprintf将整型变为char型字符串，交给客户端去解析。发送函数采用原始socket中的send函数，原型为:

Int send(int socket, const void \* buff, int length, int flags)

#### 1.6 发送音乐信息 ####

当检索到对应的音乐时，则把具体的音乐信息发送给客户端。这里还是利用sprintf将信息都打印到字符串中。可以看出，为了与Javasocket通信，所有的数据传递都被转换成char\*字符串。

### 2 客户端实现 ###

在介绍客户端之前，先把代码贴出来：

**\[java\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  import java.io.\*;  
2.  import java.net.\*;  
3.    
4.  public class Client  
5.  \{  
6.      void query(String file,String ip,int port)  
7.      \{  
8.          FileInputStream fileInputStream;  
9.          DataInputStream netInputStream;  
10.         DataOutputStream netOutputStream;  
11.         Socket sc;  
12.         int fileLength;  
13.         byte\[\] buffer=new byte\[1023\];  
14.         byte\[\] readLen=new byte\[10\];  
15.         byte\[\] readResult=new byte\[2000\];  
16.         int len;  
17.         int result\_count=0;  
18.   
19.         File f=new File(file);  
20.         if(f.exists())  
21.         \{  
22.             fileLength=(int)f.length();  
23.         \}  
24.         else  
25.         \{  
26.             System.out.println("No such file");  
27.             return;  
28.         \}  
29.   
30.         try  
31.         \{  
32.             fileInputStream=new FileInputStream(file);  
33.             sc=new Socket(ip,port);  
34.             netInputStream=new DataInputStream(sc.getInputStream());  
35.             netOutputStream=new DataOutputStream(sc.getOutputStream());  
36.   
37.             /1.send file length//  
38.             netOutputStream.write(Integer.toString(fileLength).getBytes());  
39.   
40.             /2. send file///  
41.             while((len=fileInputStream.read(buffer))>0)  
42.             \{  
43.                 netOutputStream.write(buffer,0,len);  
44.             \}  
45.   
46.             3. read result symbol///  
47.             netInputStream.read(readLen);  
48.   
49.             while(((char)readLen\[0\])=='1')  
50.             \{  
51.                 /4. Read result//  
52.                 netInputStream.read(readResult);  
53.                 String result=new String(readResult);  
54.                 String\[\] ss=result.split(",");  
55.   
56.                 int score=Integer.parseInt(ss\[3\]);  
57.                 int startTime=Integer.parseInt(ss\[4\]);  
58.                 double confidence=Double.parseDouble(ss\[5\]);  
59.   
60.                 System.out.println("name:"\+ss\[0\].trim());  
61.                 System.out.println("artist:"\+ss\[1\].trim());  
62.                 System.out.println("album:"\+ss\[2\].trim());  
63.                 System.out.println("score:"\+score);  
64.                 System.out.println("startTime:"\+startTime);  
65.                 System.out.println("confidence:"\+confidence);  
66.   
67.                 result\_count++;  
68.   
69.                 netInputStream.read(readLen);  
70.             \}  
71.   
72.             if(result\_count==0)  
73.             \{  
74.                 System.out.println("No match music");  
75.             \}  
76.   
77.             fileInputStream.close();  
78.             netInputStream.close();  
79.             netOutputStream.close();  
80.             sc.close();  
81.         \}  
82.         catch(Exception e)  
83.         \{  
84.             e.printStackTrace();  
85.         \}  
86.     \}  
87.   
88.     public static void main(String\[\] args)  
89.     \{  
90.         Client client=new Client();  
91.         client.query(args\[0\],args\[1\],9527);  
92.     \}  
93. \}

与服务器端相对应，客户端的流程主要分为四步：1. 发送文件长度；2. 发送文件内容；3. 读取标记；4. 读取检索结果。在此，读取文件采用FileInputStream流，网络通信采用DataInputStream和DataOutputStream。

#### 2.1 发送文件长度 ####

Java在发送int型时，也需要转换成字符串，在此我们先用Integer封装类获取int型的字符串表示，然后利用String类的getBytes函数获得其字节数组。最后利用DataOutputStream的write函数发送给服务器。

#### 2.2 发送文件 ####

发送文件的过程是：首先从文件中读取固定长度的内容，然后再利用write函数发送同等长度的字节数组。

#### 2.3 读取标记 ####

发送完文件之后，客户端就等着从服务器端获取检索结果。服务器首先返回一个0/1标记。由于该标记有效内容只有一个字节，所以我们可以通过读取第0个字节的内容来判断检索是否成功。读取是通过DataInputStream的read函数完成，读取的内容会放在原始的字节数组中。

#### 2.4 读取音乐信息 ####

如果检索成功，服务器在发送成功标记之后还会将完整的音乐信息发送过来。读取还是利用DataInputStream的read函数。读取的内容比较复杂，我们首先将字节数组转换成字符串，然后利用split函数解析出每一部分内容。之后就可以在Android UI界面中显示。

### 3 总结 ###

在亲自完成Java和c之间的socket通信之后，感觉也没有那么复杂。其实核心就一点：所有的数据类型都转换成字节数组进行传递。C端用recv和send函数就行，Java端用read和write就行，就这么简单。

[http_blog.csdn.net_yutianzuijin_article_details_24807417]: http://blog.csdn.net/yutianzuijin/article/details/24807417
[Link 1]: http://blog.csdn.net/yutianzuijin/article/details/21547573
[20140430180021859]: /images/20220727/2e520457813d4a1086837bf7df4967a9.png
[view plain]: http://blog.csdn.net/yutianzuijin/article/details/24807417#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/321192
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/321192/fork