在使用TCP协议进行消息发送时，对消息分帧

成帧与解析

阅读 《java TCP/IP Socket 编程》第三章笔记

成帧技术（frame）是解决如何在接收端定位消息的首尾位置的问题。在进行数据收发时，必须指定消息接收者如何确定何时消息已经接收完整。

在TCP协议中，消息是按照字节来传输的，而且TCP协议中是没有消息边界的概念的。因为当client和server双方建立TCP连接后，双方可以自由发送字节数据。

为了能够在消息传输中确定消息的边界，需要引入额外的信息来标示消息边界。常用的办法有两种：

基于定界符与基于显式消息长度。

基于定界符

我们在消息的末尾添加一个唯一标记作为消息结束符，这个唯一的标记一般是一个字节或者一组字节序列，并且在消息中不能出现这个标记。

基于定界符的方法一般用于以文本方式编码的消息中，定义一个特殊的字符作为分隔符来表示消息结束。但是这个分隔符也有可能作为普通字符可能会出现在消息中，导致消息解析出现错误。为了让消息中不出现分隔符，需要引入填充（stuff）技术，在发送端对消息进行扫描，如果碰到分隔符，就将这个分隔符用一个替换符和其他符号（比如将原始字符二进制中的第三位取反得到一个新的字节作为）替换，同样的，如果扫描中遇到替换符，将替换符也用一个替换付和其他符号替换。在消息的接收端，同样也对接收到的消息进行扫描，当碰到替换符时，说明该字符不是消息中的，要将后面一个字符进行还原得到相应的原始字符，这个才是消息中真正的字符。当遇到分隔符时，说明该消息已经结束

显式消息长度

在消息前面添加一个固定大小的字段（一个字节或者两个字节长度），用于表示消息包含的字节个数（也就是消息的长度）。在消息发送时，计算消息的长度（字节数），作为消息的前缀。如果使用一个字节保存长度，则消息长度最大为\(2^8=256\)个字节，如果是两个字节保存长度，则消息长度最大为\(2^{16}=65536\)个字节

消息成帧与解析的实现

在java中，当client和server之间建立tcp连接后，就可以通过输入输出流（I/O stream)来进行消息传输。发送消息时，将待发送的消息写入OutputStream流中，然后发送到接收端InputStream流；接收端则从InputStream流中读取出消息。如何实现将消息按帧发送与接收，就需要要利用我们上面提到的方法。

我们先定义一个Framer接口,来声明两个方法，消息成帧frameMsg()和消息抽取nextMsg()

package chapter_3.frame;

import java.io.IOException;
import java.io.OutputStream;

/**
 * @author fulv
 * Framer接口声明了两个方法，用于消息成帧和解析将待发送消息封装成帧并输出到指定流
 */
public interface Framer {

    /**
     * 将输入的消息msg封装成帧，然后输出到out流
     *
     * @param msg 输入的消息
     * @param out 消息输出流
     */
    void frameMsg(byte[] msg, OutputStream out);

    /**
     * 从指定流中读取下一个消息帧
     *
     * @return byte[]
     */
    byte[] nextMsg() throws IOException;
}

然后分别使用基于分隔符和基于显式消息长度两种方法来实现Framer接口

基于分隔符：

在这里，我们使用字符'\n'作为消息分隔符，它对应的字节为0x0A；使用的替换符为0x7D。替换的策略是：当扫描到待发送的消息byte数组中有0x0A时，将其替换为(0x7D,0x2A),如果遇到0x7D,将其替换为（0x7D,0x5D)。这里面第二个字符通过将待替换字符从左向右数第三位取反获得。

在 接收端，从输入流中读取字节流数据，遇到0x7D时，说明后面一个字节对应的是特殊字节，需要转换得到原始字节。如果遇到0x0A说明到达消息帧末尾，完成了一个消息帧的读取。

package chapter_3.frame;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

/**
 * 采用界定符的方式来实现消息的封装成帧以及消息帧的解析
 *
 * @author fulv
 */
public class DelimitFramer implements Framer {

    /**
     * 数据输入源，从中解析出消息帧
     */
    private InputStream in;

    /**
     * 消息帧的定界符
     */
    private static final byte DELIMITER = '\n';
    /**
     * 替换字符，用于将出现在消息内部的'\n'进行替换，避免出现解析错误
     */
    private static final byte REPLACE_CHAR = (byte) 0x7d;

    private static final byte MASK = (byte) 0x20;

    public DelimitFramer(InputStream in) {
        this.in = in;
    }

    @Override
    public void frameMsg(byte[] msg, OutputStream out) {
        //向判断传入的消息中是否包含界定符与替换符，如果存在，执行相关字节填充操作
        //将对应的界定符和替换符换成两个字符，其中第一个为替换符，第二个为将要替换的字符的从左到右的第二位取反形成的字符
        int count = 0;
        for (byte b : msg) {
            if (DELIMITER == b || REPLACE_CHAR == b) {
                count++;
            }
        }
        byte[] extendMsg = new byte[msg.length + count];
        for (int i = 0, j = 0; i < msg.length; i++) {
            if (DELIMITER == msg[i] || REPLACE_CHAR == msg[i]) {
                extendMsg[j++] = REPLACE_CHAR;
                extendMsg[j++] = byteStuff(msg[i]);
            } else {
                extendMsg[j++] = msg[i];
            }
        }
        try {
            out.write(extendMsg);
            out.write(DELIMITER);
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("消息写入流失败");
        }

    }

    /**
     * 从消息输入流in中，取出下一个消息帧（以分隔符划分一个消息帧）
     *
     * @return
     */
    @Override
    public byte[] nextMsg() throws IOException {
        ByteArrayOutputStream msgBuffer = new ByteArrayOutputStream();
        int nextByte;

        while ((nextByte = in.read()) != DELIMITER) {
            //已经读完了输入流，这里分两种情况
            if (-1 == nextByte) {
                //输入流中的字节已经全部读完
                if (msgBuffer.size() == 0) {
                    return null;
                } else {
                    //读取了部分字节，但却没有遇到分隔符，说明输入的消息帧是不完整或者错误的，返回异常
                    throw new EOFException("读取到了不正确的消息帧");
                }
            }

            //当前字符为替换字符，需要读取下一个字符并转换(将第三位取反)得到正确的字符
            if (REPLACE_CHAR == nextByte) {
                nextByte = in.read() & 0xFF;
                nextByte = byteStuff((byte) nextByte);
            }
            msgBuffer.write(nextByte);
        }
        return msgBuffer.toByteArray();
    }

    /**
     * 字节填充函数，将传入字节的从左到右数的第二位取反
     *
     * @param originByte
     * @return
     */
    private static byte byteStuff(byte originByte) {
        return (byte) ((originByte | MASK) & ~(originByte & MASK));
    }
}

基于显式消息长度方法：

使用两个字节无符号整型来表示待发送消息的长度，最长为65536。将消息长度按照字节大端序写入待发送的消息前，表示消息长度。

接收端，首先从输入流中读出消息长度，然后堵塞的从输入流中读取数据，直到读取出的数据量达到消息长度，整个消息帧才读取结束。

package chapter_3.frame;

import java.io.*;

/**
 * 基于显式长度的方法来将实现消息成帧
 *
 * @author fulv
 */
public class LengthFramer implements Framer {

    private static final int MESSAGEMAXLENGTH = 65536;

    private DataInputStream in;

    public LengthFramer(DataInputStream in) {
        this.in = in;
    }

    @Override
    public void frameMsg(byte[] msg, OutputStream out) throws IOException {
        if (msg.length > MESSAGEMAXLENGTH) {
            throw new IOException("传入的消息超出最大长度");
        }
        int msgLength = msg.length;
        //将消息长度按照字节大端序写入输出流中
        out.write((msgLength >> 8) & 0xFF);
        out.write(msgLength & 0xFF);
        //将消息写入输出流
        out.write(msg);
        out.flush();
    }

    @Override
    public byte[] nextMsg() throws IOException {
        int length;
        byte[] msg = null;
        try {
            //从输入流中读取两个字节，作为大端序的整型值解释，表示消息长度
            length = in.readUnsignedShort();
        } catch (EOFException e) {
            return null;
        }
        //存放从输入流中读取出的消息字节数组
        msg = new byte[length];
        //readFully多次调用read方法直到读取到指定长度的数组消息或者读取到-1返回
        in.readFully(msg);
        return msg;
    }
}

测试

对两种消息分帧方式进行测试，开启两个线程分别表示client与server，测试消息的发送与接收。

package chapter_3.frame;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class TestFramer {

    private static final String[] messages = {"Hello World!", "Hello China, 你好 中国", "世界人民大团结万岁",
            "在消息中发送分隔符\n和替换符}的情况"};

    public static void main(String[] args) throws InterruptedException {
        Thread clientThread = new Thread(() -> {
            Socket socket = null;
            try {
                socket = new Socket(InetAddress.getLocalHost(), 8888);
                InputStream in = socket.getInputStream();
                OutputStream out = socket.getOutputStream();
                //Framer framer = new DelimitFramer(in);
                DataInputStream dataInputStream = new DataInputStream(in);
                Framer framer = new LengthFramer(dataInputStream);
                for (String msg : messages) {
                    byte[] msgBytes = msg.getBytes(StandardCharsets.UTF_8);
                    framer.frameMsg(msgBytes, out);
                    System.out.println(Thread.currentThread().getName() + " 发送消息: " + msg);
                }
                socket.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        Thread serverThread = new Thread(() -> {
            Socket socket = null;
            try (ServerSocket serverSocket = new ServerSocket(8888)) {
                while (true) {
                    socket = serverSocket.accept();
                    System.out.println("获取到来自" + socket.getRemoteSocketAddress() + "的tcp连接");
                    InputStream in = socket.getInputStream();
                    OutputStream out = socket.getOutputStream();
                    //Framer framer = new DelimitFramer(in);
                    DataInputStream dataInputStream = new DataInputStream(in);
                    Framer framer = new LengthFramer(dataInputStream);
                    byte[] recvMsgBytes = null;
                    do {
                        recvMsgBytes = framer.nextMsg();
                        //System.out.println(Arrays.toString(recvMsgBytes));
                        if (recvMsgBytes != null) {
                            System.out.println(Thread.currentThread().getName() + " 接收到的消息: " + new String(recvMsgBytes, StandardCharsets.UTF_8));
                        }
                    } while (recvMsgBytes != null);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        serverThread.setName("server");
        clientThread.setName("client");
        serverThread.start();
        Thread.sleep(3000);
        clientThread.start();
    }
}

输出结果：

获取到来自/10.0.75.1:2462的tcp连接
server 接收到的消息: Hello World!
client 发送消息: Hello World!
client 发送消息: Hello China, 你好 中国
server 接收到的消息: Hello China, 你好 中国
client 发送消息: 世界人民大团结万岁
server 接收到的消息: 世界人民大团结万岁
client 发送消息: 在消息中发送分隔符
和替换符}的情况
server 接收到的消息: 在消息中发送分隔符
和替换符}的情况