Java(Android)与C++之间的Socket通信

1. 一基础知识
   1. 大小字节序
      1. 1基本概念
      2. 2 字节序范例
      3. 3 主机大小字节序的判断
   2. 网络字节序和主机字节序
      1. 1基本概念
      2. 2 常用字节序转换函数
         1. 3  Java字节序和c字节序
      3. 二java和c之间的socket通信代码实现
         1. 1  java和c数据类型对比
            1. C与Java基本类型占用内存空间差别
            2. 特殊类型结构体和枚举类型的传输和转换
         2. 2代码实现
            1. BasicDataTypeTransfer类
         3. 三总结

Java与C++之间的Socket通信，对于小的数据量和控制命令，直接可以封装成json或xml格式，进行传输。但对于文件等大数据量传输，必须要将文件封装成帧，每一帧都设定固定大小的缓冲区，逐帧传输。此时json和xml便不再适用了。

在此过程中要需解决如下问题：

1.    Java和C++数据基本类型不同，不仅所占字节数不同（如long型，java占8bytes，C++一般为4bytes）。C++缓冲区一般使用char*型，但是java中没有char*型，相互之间传输的数据，如何接收解析？

2.    C++常用的特殊类型：结构体，如何解析成Java中的类。即使是两者都具有的枚举类型，两者的机制是不一样的，如何进行对接？

3.    Java端和C++端，发送给socket的数据形式是什么？char数组型还是字节型C++端又有何种形式进行接收？接收到的数据又如何正确解析出来？

4.     字节序问题。Java为大字节序，而大部分PC主机C++都是小字节序，大小字节序和网络字节序相互之间的转化，也是需要考虑的问题。

这些问题，本文将对其逐一进行讲述和解决。话不多说，先普及熟悉一下基础知识。

本文涉及的问题较为基础，大神若有垂怜本文，可直接跳过基础部分。

一、基础知识

1.大小字节序

1.1基本概念

由于不同主处理器和操作系统，多字节数据在计算机内存中存储或者网络传输时各字节的存储顺序会有所不同，为保证不同系统之间的正确数据传输需要做相应的字节序调整，即为字节序问题。例如两个字节的short int和4个字节的float类型变量都会有字节序问题。

 

字节序通常分为大字节序（big-endian）和小字节序（little-endian）。

Ø  大字节序（big-endian）：表示变量的起始地址存放低字节，高字节依顺序存放。

Ø  小字节序（little-endian）：表示变量的起始地址存放高字节，低字节依顺序存放，这种存储方式对于人类来说是最自然的。

1.2 字节序范例

例如：在内存中双字0x01020304(DWORD)的存储方式，设定其内存地址为：4000&4001&4002&4003。

Ø  对于小字节序而言，其在内存中的存储方式为：01 02 03 04

Ø  对于大字节序而言，字节存储顺序恰好相反：04 03 02 01

 

如果用byte数组来保存数据，则具体的存储方式为：

Ø  小字节序：byteToByteValue={0x01,0x02,0x03,0x04}。

Ø  大字节序：与小字节序顺序恰好相反,byte ToByteValue = {0x04 , 0x03, 0x02 ,0x01 }。

 

1.3 主机大小字节序的判断

1.新建一个联合体union

typedef Union{

//存储双字节变量

unsigned short int value;

//与value共享一个内存地址，可以通过byte数组来访问value的高低字节

unsigned char byte[2];

}

2.通过对value赋值，如0xabcd，若byte中存储的高字节存储的是0xab，则为大字节序，否则为小字节序。

 

2.网络字节序和主机字节序

2.1基本概念

网络字节顺序是TCP/IP中规定好的一种数据表示格式，它与具体的CPU类型、操作系统等无关，从而可以保证数据在不同主机之间传输时能够被正确解释。网络字节顺序采用big endian排序方式。

如对4个字节的32 bit值以下面的次序传输：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit，这种传输次序称作大端字节序。由于TCP/IP首部中所有的二进制整数在网络中传输时都要求以这种次序，因此它又称作网络字节序。

主机字节序就是我们平常说的大端和小端模式，由主机CPU决定，不同CPU会有不同字节序。x86系列CPU都是小字节序。

2.2 常用字节序转换函数

在主机之间通过网络进行通信时，往往需要进行字节序转换，linux系统中常用字节序转换函数如下：

#include <arpa/inet.h>

uint32_t htonl(uint 32_t) 主机字节序到网络字节序的长整形转换

uint16_t htons(uint16_t)：主机字节序到网络字节序短整型转换
uint32_t ntohl(uint32_t)：网络字节序到主机字节序长整型转换
uint16_t ntohs(uint16_t)：网络字节序到主机字节序短整型转换

其中XtoX就是进行数据存储顺序的主机和网络顺序的转换，h—host—主机，n—net—网络，l—long—长整形，s—short—短整形。

2.3  Java字节序和c++字节序

对于x86系列CPU都是小字节序，因此对于c++而言，主机字节序通常为小字节序。

JAVA字节序指的是在JAVA虚拟机中多字节类型数据的存放顺序，JAVA字节序也是BIG-ENDIAN。所以Android客户端和c++服务器数据通信时要注意字节序转换问题。

二、java和c++之间的socket通信代码实现

本系统在Android客户端采用将高字节序转换为低字节序，并存储在字节数组当中，进行socket字节传输，C++服务器直接按照各数据类型所占空间大小，解析出不同数据。反之，服务器向客户端发送数据也是字节数组形式，在客户单调用BasicDataTypeTransfer中的函数，将字节数组中的数据解析出来。

2.1  java和c++数据类型对比

1.C++与Java基本类型占用内存空间差别

----------------C++-----------                              ------------Java----------

(01)bool------------------1byte                         01)boolean--1 byte

(02)char------------------1byte                         02)char------2bytes

(03)signedchar---------1byte                         03)byte------1 byte

(04)unsignedchar------1 byte

(05)wchar_t--------------2bytes

(06)short-----------------2bytes                        04)short-----2 bytes

(07)unsignedshort-----2 bytes

(08)int--------------------4bytes                        05)int---------4 bytes

(09)unsignedint--------4 bytes

(10)long------------------4bytes                       06)long-------8bytes

(11)unsignedlong-------4 bytes

(12)longlong-------------8 bytes

(13)unsignedlong long--8 bytes

(14)float-------------------4bytes                      07)float-------4 bytes

(15)double----------------8bytes                      08)double----8 bytes

(16)longdouble---------12 bytes

Java中每一种数据类型的内存大小是已经严格限定。但C++标准规定了每个算术类型的最小存储空间，它并不阻止编译器使用更大的存储空间，以上采用32位机器上的C++数据类型的典型占用字节数。

Java中没有无符号类型，对于long型Java是8个字节，C++是4个字节。进行相应数据传输的时候，要特别注意，以免造成数据丢失或错误。

2.特殊类型：结构体和枚举类型的传输和转换

结构体是C++中经常要用到的数据结构，而Java中没有结构体，以及枚举类型的传输，要实现这些特殊类型的传输，需要对其内存中存储方式有一个透彻了解，特别是要把握字节存储的概念。

2.2代码实现

Java和C++定义的数据结构

 从上文讲述的基础知识，可以得到以下处理思路，在C++端将数据封装在结构体当中，结构体中有消息类型，控制命令，文件缓冲区，文件属性相关信息等。socket发送时将其强制转换为char*类，进行发送。

Java端socket以byte数组方式接手，随后根据结构体的字节存储顺序对数据进行解析。如字节数组中，首先为int数据，就读取4个字节将其复制到Java的整形变量中，顺此思路从而完成对结构体的数据还原。

C++下定义的数据类型如下：

[cpp] view plaincopy

1. //文件数据帧数据类型  
2. enum FssFileFrameType  
3. {  
4.     FILE_NAME_TYPE = 1, //文件名称  
5.     FILE_DATA_TYPE = 2, //文件数据  
6.     FILE_END_TYPE = 3,  //文件结尾  
7.     FILE_ERROR_TYPE = 4,//文件出错  
8.     FILE_OVERWRITE_TYPE = 5,    //覆盖文件  
9.     FILE_SKIP_TYPE = 6, //跳过文件传送  
10.     DISCONNECT_TYPE = 7//断开连接  
11. };  
12.   
13. //文件数据帧  
14. typedef struct  
15. {  
16.     FssFileFrameType type;  
17.     int length;  
18.     char buffer[MAX_BUFFER_SIZE];  
19. }FileDataFrame;  
20.   
21.   
22. //状态控制帧数据类型  
23. enum TransactionStateType  
24. {  
25.     OK_TYPE = 1,        //表明服务器端正确接收到了客户端的数据  
26.     FILE_EXIST_TYPE = 2, //文件已经存在  
27.     ERROR_TYPE = 3,     //出错  
28.     FINISHED_TYPE =4,   //文件传输并保存成功  
29.     INVALID_TYPE = 5    //保留的无效位，主要用来简化程序的控制逻辑  
30.   
31. };  
32.   
33. //状态控制帧  
34. typedef struct  
35. {  
36.     TransactionStateType type;  
37.     int length;  
38.     char info[MAX_INFO_SIZE];  
39. }TransactionStateFrame;  

Java中对应的数据类型定义如下（帧类实现下面会具体说明）：

[java] view plaincopy

1.     //文件数据帧数据类型  
2.     public enum FssFileFrameType  
3.     {  
4.         FILE_INFO_TYPE(1),  //文件名称  
5.         FILE_DATA_TYPE(2),  //文件数据  
6.         FILE_END_TYPE(3),   //文件结尾  
7.         FILE_ERROR_TYPE(4),//文件出错  
8.         FILE_OVERWRITE_TYPE(5), //覆盖文件  
9.         FILE_SKIP_TYPE(6),  //跳过文件传送  
10.         DISCONNECT_TYPE(7); //断开连接  
11.           
12.         //用于对枚举成员初始化  
13.         public int value;  
14.         FssFileFrameType(int value){  
15.             this.value=value;             
16.         }  
17.     }  
18.   
19.     //状态控制帧数据类型  
20.     public enum TransactionStateType  
21.     {  
22.         OK_TYPE(1),     //表明服务器端正确接收到了客户端的数据  
23.         FILE_EXIST_TYPE(2), //文件已经存在  
24.         ERROR_TYPE(3),      //出错  
25.         FINISHED_TYPE(4),   //文件传输并保存成功  
26.         INVALID_TYPE(5);    //保留的无效位，主要用来简化程序的控制逻辑  
27.   
28.           
29.         //用于对枚举成员初始化  
30.         public int value;  
31.         TransactionStateType(int value){  
32.             this.value=value;             
33.         }  
34.     }  
35.       
36.     /** 
37.      * 文件数据帧 
38.      * @author yin 
39.      * 
40.      */  
41.     public static class FileDataFrame{  
42.         public int type;  
43.         public byte[] packetArray =new byte[FILE_DATA_PACKET_SIZE];  
44.         private byte[] dataArray =new byte[MAX_BUFFER_SIZE];//缓冲数据  
45.                   
46.         /** 
47.          * 用于下载文件，接收服务器文件帧，并解析出FileDataFrame各成员变量 
48.          * @param byteArray 
49.          */  
50.         public FileDataFrame(byte[] byteArray){  
51.         }  
52.           
53.         /** 
54.          * 用于上传文件将文件数据包封装成帧 
55.          * @param msgType 
56.          * @param packLen 
57.          * @param packetArray 
58.          */  
59.         public FileDataFrame(int msgType,int packLen,byte[] bufferArray){             
60.         }  
61.   
62.     }  
63.       
64.     /** 
65.      * 文件状态控制帧 
66.      * @author yin 
67.      * 
68.      */  
69.     public static class TransactionStateFrame{  
70.         public int type;  
71.         public int length;  
72.         public byte[] infoArray =new byte[MAX_INFO_SIZE];//具体消息内容  
73.           
74.         //发送或接收到的字节数组帧  
75.         byte[] packetArray =new byte[STATE_CONTROL_PACKET_SIZE];                  
76.           
77.         /** 
78.          * 用于接收消息，解析数据帧 
79.          * @param byteArray 
80.          */  
81.         public TransactionStateFrame(byte[] byteArray){  
82.         }  
83.           
84.         /** 
85.          * 用于发送消息，将数据包封装成帧 
86.          * @param msgType 
87.          * @param packLen 
88.          * @param packetArray 
89.          */  
90.         public TransactionStateFrame(int msgType,int packLen,byte[] bufferArray){  
91.         }  
92.     }  
93.   
94. }  

1. BasicDataTypeTransfer类

BasicDataTypeTransfer类负责各基本类型和字节数组的相互字节序转换，同时对将服务器通过socket发过来的字节数组进行解析。以下只提供几种类型的代码实现，其他类型原理类似。

[java] view plaincopy

1. package com.scut.util;  
2.   
3. import java.io.UnsupportedEncodingException;  
4. /** 
5.  * 字节序转换类 
6.  * @author yin 
7.  * 
8.  */  
9. public class BasicDataTypeTransfer {      
10.       
11.     public static BasicDataTypeTransfer basicDataTypeTransfer=null;  
12.       
13.     public static BasicDataTypeTransfer getInstance(){  
14.         if(basicDataTypeTransfer==null){  
15.             basicDataTypeTransfer=new BasicDataTypeTransfer();  
16.         }  
17.         return basicDataTypeTransfer;  
18.     }  
19.       
20.     /* 
21.      *将int转换为小字节序 
22.      **/  
23.     public byte[] IntToByteArray(int n){  
24.         byte[] b = new byte[4];  
25.         b[0] = (byte)(n & 0xff);  
26.         b[1] = (byte)(n>>8 & 0xff);  
27.         b[2] = (byte)(n>>16 &0xff);  
28.         b[3] = (byte)(n>>24 &0xff);  
29.           
30.         return b;         
31.     }  
32.   
33.       
34.     public int ByteArrayToInt(byte[] bAttr){  
35.         int n=0;  
36.         int leftmove;  
37.         for(int i=0;i<4&&(i<bAttr.length);i++){  
38.             leftmove = i*8;  
39.             n += bAttr[i]<<leftmove;  
40.         }  
41.         return n;  
42.           
43.     }  
44.       
45.     public byte[] StringToByteArray(String str){  
46.         byte[] temp=new byte[100];        
47.         try {  
48.             temp=str.getBytes("GBK");  
49.         } catch (UnsupportedEncodingException e) {  
50.             // TODO Auto-generated catch block  
51.             e.printStackTrace();  
52.         }         
53.         return temp;  
54.     }  
55.       
56.     public String ByteArrayToString(byte[] bAttr,int maxLen){  
57.         int index=0;  
58.         while(index <bAttr.length&&index<maxLen){  
59.             if(bAttr[index] == 0){  
60.                 break;  
61.             }  
62.             index++;              
63.         }         
64.         byte[] tmp = new byte[index];  
65.         System.arraycopy(bAttr, 0, tmp, 0, index);  
66.         String str=null;  
67.         try {  
68.             str = new String(tmp,"GBK");  
69.         } catch (UnsupportedEncodingException e) {  
70.             // TODO Auto-generated catch block  
71.             e.printStackTrace();  
72.         }  
73.         return str;  
74.           
75.     }  
76.   
77. }  

2. FssCommon类

调用上述BasicdataTypeTransfer，针对C++服务器结构体的具体结构，进行相应的解析，以还原成对应的java类。

[java] view plaincopy

1. package com.scut.util;  
2.   
3. /** 
4.  * 通用全局变量封装类 
5.  * @author yin 
6.  * 
7.  */  
8. public class FssCommon {      
9.       
10.     /** 
11.      * 文件数据帧 
12.      * @author yin 
13.      * 
14.      */  
15.     public static class FileDataFrame{  
16.         public int type;  
17.         public byte[] packetArray =new byte[FILE_DATA_PACKET_SIZE];  
18.         private byte[] dataArray =new byte[MAX_BUFFER_SIZE];//缓冲数据  
19.                   
20.         /** 
21.          * 用于下载文件，接收服务器文件帧，并解析出FileDataFrame各成员变量 
22.          * @param byteArray 
23.          */  
24.         public FileDataFrame(byte[] byteArray){  
25.             BasicDataTypeTransfer basicDataTypeTransfer=new BasicDataTypeTransfer();  
26.             if(byteArray!=null && byteArray.length>=sizeOfInt){    
27.                 byte[] typeArray = new byte[sizeOfInt];       
28.                 //读出存储在前面的int型数据  
29.                 System.arraycopy(byteArray, 0, typeArray, 0, sizeOfInt);  
30.                 //将其转换为整形，从而转换为枚举类型    
31.                 this.type=basicDataTypeTransfer.ByteArrayToInt(typeArray);    
32.                 //读取length  
33.                 byte[] lenByteArray = new byte[sizeOfInt];        
34.                 System.arraycopy(byteArray, sizeOfInt, lenByteArray, 0, sizeOfInt);               
35.                 //读取缓冲数据  
36.                 System.arraycopy(byteArray,2*sizeOfInt, dataArray, 0, dataArray.length);  
37.             }  
38.         }  
39.           
40.         /** 
41.          * 用于上传文件将文件数据包封装成帧 
42.          * @param msgType 
43.          * @param packLen 
44.          * @param packetArray 
45.          */  
46.         public FileDataFrame(int msgType,int packLen,byte[] bufferArray){  
47.             this.type=msgType;  
48.             System.arraycopy(bufferArray, 0, this.dataArray, 0, bufferArray.length);      
49.               
50.             BasicDataTypeTransfer basicDataTypeTransfer=new BasicDataTypeTransfer();      
51.             //cmdType  
52.             byte[] cmdTypeByte = basicDataTypeTransfer.IntToByteArray(msgType);  
53.             System.arraycopy(cmdTypeByte, 0, packetArray, 0, cmdTypeByte.length);         
54.             //packet length           
55.             byte[] packLenByte = basicDataTypeTransfer.IntToByteArray(packLen);  
56.             System.arraycopy(packLenByte, 0, packetArray, cmdTypeByte.length, packLenByte.length);  
57.             //packBuff  
58.             if(dataArray!=null){  
59.                 System.arraycopy(dataArray, 0, packetArray, cmdTypeByte.length+packLenByte.length, dataArray.length);     
60.             }  
61.               
62.             //数据包总大小，4+4+MAX_BUFFER_SIZE（8*1024）  
63.               
64.         }  
65.   
66.     }  
67.       
68.     /** 
69.      * 文件状态控制帧 
70.      * @author yin 
71.      * 
72.      */  
73.     public static class TransactionStateFrame{  
74.         public int type;  
75.         public int length;  
76.         public byte[] infoArray =new byte[MAX_INFO_SIZE];//具体消息内容  
77.           
78.         //发送或接收到的字节数组帧  
79.         byte[] packetArray =new byte[STATE_CONTROL_PACKET_SIZE];                  
80.           
81.         /** 
82.          * 用于接收消息，解析数据帧 
83.          * @param byteArray 
84.          */  
85.         public TransactionStateFrame(byte[] byteArray){  
86.             BasicDataTypeTransfer basicDataTypeTransfer=new BaisicDataTypeTransfer();  
87.             if(byteArray!=null && byteArray.length>=sizeOfInt){    
88.                 byte[] typeArray = new byte[sizeOfInt];       
89.                 //读出存储在前面的int型数据  
90.                 System.arraycopy(byteArray, 0, typeArray, 0, sizeOfInt);  
91.                 //将其转换为整形，从而转换为枚举类型    
92.                 this.type=basicDataTypeTransfer.ByteArrayToInt(typeArray);    
93.                 //读取length  
94.                 byte[] lenByteArray = new byte[sizeOfInt];        
95.                 System.arraycopy(byteArray, sizeOfInt, lenByteArray, 0, sizeOfInt);               
96.                 this.length=basicDataTypeTransfer.ByteArrayToInt(lenByteArray);       
97.                 //读取缓冲数据  
98.                 System.arraycopy(byteArray,2*sizeOfInt, infoArray, 0, infoArray.length);  
99.             }  
100.         }  
101.           
102.         /** 
103.          * 用于发送消息，将数据包封装成帧 
104.          * @param msgType 
105.          * @param packLen 
106.          * @param packetArray 
107.          */  
108.         public TransactionStateFrame(int msgType,int packLen,byte[] bufferArray){  
109.             this.type=msgType;  
110.             this.length=packLen;  
111.             System.arraycopy(bufferArray, 0, this.infoArray, 0, bufferArray.length);      
112.               
113.             BasicDataTypeTransfer basicDataTypeTransfer=new BasicDataTypeTransfer();      
114.             //cmdType  
115.             byte[] cmdTypeByte = basicDataTypeTransfer.IntToByteArray(msgType);  
116.             System.arraycopy(cmdTypeByte, 0, packetArray, 0, cmdTypeByte.length);         
117.             //packet length           
118.             byte[] packLenByte = basicDataTypeTransfer.IntToByteArray(packLen);  
119.             System.arraycopy(packLenByte, 0, packetArray, cmdTypeByte.length, packLenByte.length);  
120.             //packBuff  
121.             if(infoArray!=null){  
122.                 System.arraycopy(infoArray, 0, packetArray, cmdTypeByte.length+packLenByte.length, infoArray.length);     
123.             }             
124.             //数据包总大小，4+4+MAX_INFO_SIZE（8*1024）  
125.         }  
126.     }  
127.   
128. }  

3.C++将字节数组还原成结构体

这一步就很简单啦，强制转换一下就okay。

[cpp] view plaincopy

1. if(!newsocket.recv((char *)&fileDataFrame,sizeof(fileDataFrame)))  
2.             {  
3.                 std::cout <<"recv error:"<<errno;  
4.             }  
5.             switch(fileDataFrame.type)  
6.             {  
7.   
8.             case FILE_NAME_TYPE:  
9.             {  
10.                 std::cout <<"file information received";  
11.                 break;  
12.             }  
13.   
14.             case FILE_DATA_TYPE:  
15.             break;  
16.             case FILE_END_TYPE:  
17.                 break;  
18.             default:  
19.                 break;  

三、总结

在实际编程中，不同编程语言，如Java、c、c++、delphi所写的网络程序进行通讯时，需要进行相应的数据转换。从不同数据之间的字节存储方式来理解不同主机和语言的数据通信，将各数据转换成字节流的形式进行传输和解析，是一种非常有效的方式。