Java TCP Socket 数据收发
1. 前言
TCP 是面向字节流的传输协议。所谓字节流是指 TCP 并不理解它所传输的数据的含义，在它眼里一切都是字节，1 字节是 8 比特。比如，TCP 客户端向服务器发送“Hello Server，I’m client。How are you？”，TCP 客户端发送的是具有一定含义的数据，但是对于 TCP 协议栈来说，传输的是一串字节流，具体如何解释这段数据需要 TCP 服务器的应用程序来完成，这就涉及到“应用层协议设计”的问题。
在 TCP/IP 协议栈的四层协议模型中，操作系统内核协议栈实现了链路层、网络层、传输层，将应用层留给了应用程序来实现。在编程实践中，通常有文本协议和二进制协议两种类型，前者通常通过一个分隔符区分消息语义，而后者通常是需要通过一个 length 字段指定消息体的大小。比如著名的 HTTP 协议就是文本协议，通过 “\r\n” 来区分 HTTP Header 的每一行。而 RTMP 协议是一个二进制协议，通过 length 字段来指定消息体的大小。
解析 TCP 字节流的语义通常叫做消息解析，如果按照传统 C 语言函数的方式来实现，还是比较麻烦的，有很多细节需要处理。好在 Java 为我们提供了很多工具类，给我们的工作带来了极大地便利。
2. Java 字节流结构
Java 的 java.io.* 包中包含了 InputStream 和 OutputStream 两个类，是 Java 字节流 I/O 的基础类，其他具体的 Java I/O 字节流功能类都派生自这两个类。
图中只列出了我们 Socket 编程中常用的 I/O 字节流类。java.net.SocketInputStream 类是 Socket 的输入流实现类，它继承了 java.io.FileInputStream 类。java.net.SocketOutputStream 类是 Socket 的输出流实现类，它继承了 java.io.FileOutputStream 类，下来我们逐一介绍这些类的基本功能。
2.1 Java InputStream & OutputStream
java.io.InputStream 类是一个抽象超类，它提供最小的编程接口和输入流的部分实现。java.io.InputStream 类定义的几类方法：
- 读取字节或字节数组，一组 read 方法。
- 标记流中的位置，mark 方法。
- 跳过输入字节，skip 方法。
- 找出可读取的字节数，available 方法。
- 重置流中的当前位置，reset 方法。
- 关闭流，close 方法。
InputStream 流在创建实例时会自动打开，你可以调用 close 方法显式关闭流，也可以选择在垃圾回收 InputStream 时，隐式关闭流。需要注意的是垃圾回收机制关闭流，并不能立刻生效，可能会造成流对象泄漏，所以一般需要主动关闭。
java.io.OutputStream 类同样是一个抽象超类，它提供最小的编程接口和输出流的部分实现。java.io.OutputStream 定义的几类方法：
- 写入字节或字节数组，一组 write 方法。
- 刷新流，flush 方法。
- 关闭流，close 方法。
OutputStream 流在创建时会自动打开，你可以调用 close 方法显式关闭流，也可以选择在垃圾回收 OutputStream 时，隐式关闭流。
2.2 FileInputStream & FileOutputStream
java.io.FileInputStream 和 java.io.FileOutputStream 是文件输入和输出流类，用于从本机文件系统上的文件读取数据或向其写入数据。你可以通过文件名、java.io.File 对象、java.io.FileDescriptor 对象创建一个 FileInputStream 或 FileOutputStream 流对象。
2.3 SocketOutputStream & SocketInputStream
java.net.SocketInputStream 和 java.net.SocketOutputStream 代表了 Socket 流的读写，他们分别继承自 java.io.FileInputStream 和 java.io.FileOutputStream 类，这说明 Socket 读写包含了文件读写的特性。另外，这两个类是定义在 java.net.* 包中，并没有对外公开。
2.4 FilterInputStream & FilterOutputStream
java.io.FilterInputStream 和 java.io.FilterOutputStream 分别是 java.io.InputStream 和 java.io.OutputStream 的子类，并且它们本身都是抽象类，为被过滤的流定义接口。java.io.FilterInputStream 和 java.io.FilterOutputStream 的主要作用是为基础流提供一些额外的功能，这些不同的功能都是单独的类，继承了他们的接口。例如，过滤后的流 BufferedInputStream 和BufferedOutputStream 在读写时会缓冲数据，以加快数据传输速度。
2.5 BufferedInputStream & BufferedOutputStream
java.io.BufferedInputStream 类继承自 java.io.FilterInputStream 类，它的作用是为 java.io.FileInputStream、java.net.SocketInputStream 等输入流提供缓冲功能。一般通过 java.io.BufferedInputStream 的构造方法传入具体的输入流，同时可以指定缓冲区的大小。java.io.BufferedInputStream 会从底层 Socket 读取一批数据保存到内部缓冲区中，后续通过 java.io.BufferedInputStream 的 read 方法读取数据，实际上都从缓冲区中读取，等读完缓冲中的这部分数据之后，再从底层 Socket 中读取下一部分的数据。
- 注意：
- 当你调用 java.io.BufferedInputStream 的 read 方法读取一个数组时，只有当读取的数据达到数组长度时才会返回，否则线程会被阻塞。
java.io.BufferedOutputStream 类继承自 java.io.FilterOutputStream 类，它的作用是为 java.io.FileOutputStream、java.net.SocketOutputStream 等输出流提供缓冲功能。一般通过 java.io.BufferedOutputStream 的构造方法传入底层输出流，同时可以指定缓冲区的大小。每次调用 java.io.BufferedOutputStream 的 write 方法写数据时，实际上是写入它的内部缓冲区中，当内部缓冲区写满或者调用了 flush 方法，才会将数据写入底层 Socket 的缓冲区。
BufferedInputStream 和 BufferedOutputStream 在读取或写入时缓冲数据，从而减少了对原始数据源所需的访问次数。缓冲流通常比类似的非缓冲流效率更高。
2.6 DataInputStream & DataOutputStream
java.io.DataInputStream 和 java.io.DataOutputStream 类继承自 java.io.FilterInputStream 和 java.io.FilterOutputStream 类，同时实现了 java.io.DataInput 和 java.io.DataOutput 接口，功能是以机器无关的格式读取或写入原始 Java 数据类型。
3. 数据读写的案例程序
我们设计一个简单的协议，每个消息的开头 4 字节表示消息体的长度，格式如下：
+-----------------+
| 4 字节消息长度 |
+-----------------+
| |
| 消息体 |
| |
+-----------------+
我们通过这个简单的协议演示 java.io.DataInputStream 、java.io.DataOutputStream 和 java.io.BufferedInputStream、java.io.BufferedOutputStream 类的具体用法。TCP 客户端和服务器的编写可以参考上一节内容，本节仅展示数据读写的代码片段。
客户端数据读写代码：
import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
public class TCPClientIO {
// 服务器监听的端口号
private static final int PORT = 56002;
private static final int TIMEOUT = 15000;
public static void main(String[] args) {
Socket client = null;
try {
// 调用无参构造方法
client = new Socket();
// 构造服务器地址结构
SocketAddress serverAddr = new InetSocketAddress("127.0.0.1", PORT);
// 连接服务器，超时时间是 15 毫秒
client.connect(serverAddr, TIMEOUT);
System.out.println("Client start:" + client.getLocalSocketAddress().toString());
// 向服务器发送数据
DataOutputStream out = new DataOutputStream(
new BufferedOutputStream(client.getOutputStream()));
String req = "Hello Server!\n";
out.writeInt(req.getBytes().length);
out.write(req.getBytes());
// 不能忘记 flush 方法的调用
out.flush();
System.out.println("Send to server:" + req + " length:" +req.getBytes().length);
// 接收服务器的数据
DataInputStream in = new DataInputStream(
new BufferedInputStream(client.getInputStream()));
int msgLen = in.readInt();
byte[] inMessage = new byte[msgLen];
in.read(inMessage);
System.out.println("Recv from server:" + new String(inMessage) + " length:" + msgLen);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (client != null){
try {
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
服务端数据读写代码：
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
public class TCPServerIO {
private static final int PORT =56002;
public static void main(String[] args) {
ServerSocket ss = null;
try {
// 创建一个服务器 Socket
ss = new ServerSocket(PORT);
// 监听新的连接请求
Socket conn = ss.accept();
System.out.println("Accept a new connection:" + conn.getRemoteSocketAddress().toString());
// 读取客户端数据
DataInputStream in = new DataInputStream(
new BufferedInputStream(conn.getInputStream()));
int msgLen = in.readInt();
byte[] inMessage = new byte[msgLen];
in.read(inMessage);
System.out.println("Recv from client:" + new String(inMessage) + "length:" + msgLen);
// 向客户端发送数据
String rsp = "Hello Client!\n";
DataOutputStream out = new DataOutputStream(
new BufferedOutputStream(conn.getOutputStream()));
out.writeInt(rsp.getBytes().length);
out.write(rsp.getBytes());
out.flush();
System.out.println("Send to client:" + rsp + " length:" + rsp.getBytes().length);
conn.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ss != null){
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
System.out.println("Server exit!");
}
}
注意读写消息长度需要用 readInt 和 writeInt 方法。
4. 总结
通过本节学习，你需要树立一个观念：TCP 是面向字节流的协议，TCP 传输数据的时候并不保证消息边界，消息边界需要程序员设计应用层协议来保证。将字节流解析成自定义的协议格式，需要借助 java.io.* 中提供的工具类，一般情况下，java.io.DataInputStream 、java.io.DataOutputStream 和 java.io.BufferedInputStream、java.io.BufferedOutputStream 四个类就足以满足你的需求了。DataInputStream 和 DataOutputStream 类主要是用以读写 java 相关的数据类型，BufferedInputStream 和 BufferedOutputStream 解决缓冲读写的问题，目的是提高读写效率。
本节简要介绍了 Socket 编程中常用的 I/O 流类，关于 java.io.* 包中的各种 I/O 流类不是本节的重点，需要你自己参考相关 Java 书籍。