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

时间 2019-11-10

标签一个简单自定义通讯协议 socket 栏目系统网络繁體版

原文原文链接

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

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

包类型 byte 型编程

包长度 int 型服务器

消息体 byte[]多线程

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

发包方法以下：框架

[java] view plain copysocket

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

客户端发送消息类为：测试

[java] view plain copyspa

import <a href="http://lib.csdn.net/base/javaee" class='replace_word' title="Java EE知识库" target='_blank' style='color:#df3434; font-weight:bold;'>Java</a>.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java<a href="http://lib.csdn.net/base/dotnet" class='replace_word' title=".NET知识库" target='_blank' style='color:#df3434; font-weight:bold;'>.NET</a>.Socket;
import java<a href="http://lib.csdn.net/base/dotnet" class='replace_word' title=".NET知识库" target='_blank' style='color:#df3434; font-weight:bold;'>.Net</a>.UnknownHostException;
import java.util.Scanner;
public class MsgClient {
private DataOutputStream outs;
public static void main(String[] args) {
try {
MsgClient client = new MsgClient();
client.connServer("127.0.0.1", 9292);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
private void sendTextMsg(DataOutputStream out,String msg ) throws IOException {
byte[] bytes= msg.getBytes();
int totalLen = 1 + 4 + bytes.length;
out.writeByte(1);
out.writeInt(totalLen);
out.write(bytes);
out.flush();
}
public void connServer(String ip,int port) throws UnknownHostException, IOException {
Socket client = new Socket(ip,port);
InputStream in = client.getInputStream();
OutputStream out = client.getOutputStream();
outs = new DataOutputStream(out);
while(true) {
Scanner scaner = new Scanner(System.in);
sendTextMsg(outs, "<a href="http://lib.csdn.net/base/softwaretest" class='replace_word' title="软件测试知识库" target='_blank' style='color:#df3434; font-weight:bold;'>测试</a>消");
}
}

服务端接收类为：

[java] view plain copy

import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class MsgServer {
public static void main(String[] args) {
try {
MsgServer server = new MsgServer();
server.setUpServer(9090);
} catch (IOException e) {
e.printStackTrace();
}
}
public void setUpServer(int port) throws IOException {
ServerSocket server = new ServerSocket(port);
while(true) {
Socket client = server.accept();
System.out.println("客户端IP："+client.getRemoteSocketAddress());
processMesage(client);
}
}
private void processMesage(Socket client) throws IOException {
InputStream ins = client.getInputStream();
DataInputStream dins = new DataInputStream(ins);
//服务端解包过程
while(true) {
int totalLen = dins.readInt();
byte flag = dins.readByte();
System.out.println("接收消息类型"+flag);
byte[] data = new byte[totalLen - 4 - 1];
dins.readFully(data);
String msg = new String(data);
System.out.println("发来的内容是:"+msg);
}
}
}

这样就基本完成了，但实际还有好多问题，好比说服务端用如何用多线程服务来完成客户端的请求已提升效率，若是是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。