一个简单的自定义通信协议（socket）

新博客地址

转自：http://vtrtbb.javaeye.com/blog/849336

这是转自javaeye的一篇文章，作者是vtrtbb。

按照网络通信的传统，我们都会自定义协议，这有很多好处，大家可以自己体会（嘿嘿）。

 

 

一直不知道socket通信时候自定义数据包是什么样子的，偶然做了个小例子。

 

先来说说数据包的定义，我这里是包头+内容 组成的：其中包头内容分为包类型+包长度， 那就是 消息对象=包类型+包长度+消息体

 

包类型 byte 型

包长度 int 型

消息体 byte[]

 

包总长度为 1 + 4 +  消息体.getBytes().length

 

发包方法如下：

[java] view plain copy

1. private void sendTextMsg(DataOutputStream out,String msg ) throws IOException {    
2.         byte[] bytes= msg.getBytes();    
3.         int totalLen = 1 + 4 + bytes.length;    
4.                                 out.writeByte(1);    
5.         out.writeInt(totalLen);    
6.         out.write(bytes);    
7.         out.flush();    
8.     }    

 

 

客户端发送消息类为：

[java] view plain copy

1. import <a href="http://lib.csdn.net/base/17" class='replace_word' title="Java EE知识库" target='_blank' style='color:#df3434; font-weight:bold;'>Java</a>.io.DataOutputStream;    
2. import java.io.IOException;    
3. import java.io.InputStream;    
4. import java.io.OutputStream;    
5. import java.net.Socket;    
6. import java.net.UnknownHostException;    
7. import java.util.Scanner;    
8.     
9. public class MsgClient {    
10.     
11.     private DataOutputStream outs;    
12.         
13.     public static void main(String[] args) {    
14.         try {    
15.             MsgClient client = new MsgClient();    
16.             client.connServer("127.0.0.1", 9292);               
17.         } catch (UnknownHostException e) {    
18.             e.printStackTrace();    
19.         } catch (IOException e) {    
20.             e.printStackTrace();    
21.         }    
22.     }    
23.         
24.         
25.     private void sendTextMsg(DataOutputStream out,String msg ) throws IOException {    
26.         byte[] bytes= msg.getBytes();    
27.         int totalLen = 1 + 4 + bytes.length;    
28.         out.writeByte(1);    
29.         out.writeInt(totalLen);    
30.         out.write(bytes);    
31.         out.flush();    
32.     }       
33.         
34.     public void connServer(String ip,int port) throws UnknownHostException, IOException {    
35.         Socket client = new Socket(ip,port);    
36.         InputStream in = client.getInputStream();    
37.         OutputStream out = client.getOutputStream();    
38.         outs = new DataOutputStream(out);    
39.         while(true) {    
40.             Scanner scaner = new Scanner(System.in);    
41.             sendTextMsg(outs, "测试消");    
42.         }           
43.     }    

 

 

服务端接收类为：

[java] view plain copy

1. import java.io.DataInputStream;    
2. import java.io.FileOutputStream;    
3. import java.io.IOException;    
4. import java.io.InputStream;    
5. import java.net.ServerSocket;    
6. import java.net.Socket;    
7.     
8. public class MsgServer {    
9.     public static void main(String[] args) {            
10.         try {    
11.             MsgServer server = new MsgServer();    
12.             server.setUpServer(9090);    
13.         } catch (IOException e) {    
14.             e.printStackTrace();    
15.         }    
16.     }    
17.         
18.     public void setUpServer(int port) throws IOException {    
19.         ServerSocket server = new ServerSocket(port);    
20.         while(true) {    
21.             Socket client = server.accept();    
22.             System.out.println("客户端IP："+client.getRemoteSocketAddress());    
23.             processMesage(client);    
24.         }    
25.     }    
26.         
27.     private void processMesage(Socket client) throws IOException {    
28.         InputStream ins = client.getInputStream();          
29.         DataInputStream dins = new DataInputStream(ins);    
30.         //服务端解包过程    
31.         while(true) {    
32.             int totalLen = dins.readInt();    
33.             byte flag = dins.readByte();    
34.             System.out.println("接收消息类型"+flag);    
35.                 
36.             byte[] data = new byte[totalLen - 4 - 1];    
37.             dins.readFully(data);    
38.             String msg = new String(data);    
39.             System.out.println("发来的内容是:"+msg);      
40.         }    
41.     }    
42. }    

 

 

 

这样就基本完成了，但实际还有好多问题，比如说服务端用如何用多线程服务来完成客户端的请求已提高效率，如果是NIO方式怎么来实现？多个消息类型时候怎么抽象？这些都没有考虑

 

另外有两个开源的框架不错，一个是apache  mina 还有个是netty ，有机会试试。

 

 

另一篇文章中叙述：

------------------

TCP Socket协议定义

------------------

本文从这里开始，主要介绍TCP的socket编程。

新手们（例如当初的我），第一次写socket，总是以为在发送方压入一个"Helloworld",接收方收到了这个字符串，就“精通”了Socket编程了。而实际上，这种编程根本不可能用在现实项目，因为：

 

1. socket在传输过程中，helloworld有可能被拆分了，分段到达客户端），例如 hello   +   world，一个分段就是一个包（Package），这个就是分包问题。

 

2. socket在传输过成功，不同时间发送的数据包有可能被合并，同时到达了客户端，这个就是黏包问题。例如发送方发送了hello+world,而接收方可能一次就接受了helloworld.

 

3. socket会自动在每个包后面补n个 0x0 byte，分割包。具体怎么去补，这个我就没有深入了解。

 

4. 不同的数据类型转化为byte的长度是不同的，例如int转为byte是4位（int32），这样我们在制作socket协议的时候要特别小心了。具体可以使用以下代码去测试：

        public void test()
        {
            int myInt = 1;
            byte[] bytes = new byte[1024];
            BinaryWriter writer = new BinaryWriter(new MemoryStream(bytes));
            writer.Write(myInt);
            writer.Write("j");
            writer.Close();
        }

 

 

尽管socket环境如此恶劣，但是TCP的链接也至少保证了：

• 包发送顺序在传输过程中是不会改变的，例如发送方发送 H E L L，那么接收方一定也是顺序收到H E L L，这个是TCP协议承诺的，因此这点成为我们解决分包、黏包问题的关键。
• 如果发送方发送的是helloworld, 传输过程中分割成为hello+world，那么TCP保证了在hello与world之间没有其他的byte。但是不能保证helloworld和下一个命令之间没有其他的byte。

 

因此，如果我们要使用socket编程，就一定要编写自己的协议。目前业界主要采取的协议定义方式是：包头+包体长度+包体。具体如下：

 

1. 一般包头使用一个int定义，例如int = 173173173；作用是区分每一个有效的数据包，因此我们的服务器可以通过这个int去切割、合并包，组装出完整的传输协议。有人使用回车字符去分割包体，例如常见的SMTP/POP协议，这种做法在特定的协议是没有问题的，可是如果我们传输的信息内容自带了回车字符串，那么就糟糕了。所以在设计协议的时候要特别小心。

 

2. 包体长度使用一个int定义，这个长度表示包体所占的比特流长度，用于服务器正确读取并分割出包。

 

3. 包体就是自定义的一些协议内容，例如是对像序列化的内容（现有的系统已经很常见了，使用对象序列化、反序列化能够极大简化开发流程，等版本稳定后再转入手工压入byte操作）。

 

一个实际编写的例子：比如我要传输2个整型 int = 1, int = 2，那么实际传输的数据包如下：

   173173173               8                  1         2

|------包头------|----包体长度----|--------包体--------|

这个数据包就是4个整型，总长度 = 4*4  = 16。