设计并实现一个类似 TCP/IP 的通信协议

2025-12-01

先介绍一下网络通信的过程：通过 HTTP 发出请求，HTTP 的报文被打包在 TCP 的报文段中，然后又被放到 IP 层的数据报中，最后形成链路层的帧，通过网卡发出去。这个过程就是比 OSI 七层模型更符合实际情况的 TCP/IP 五层模型：应用层 <- 传输层 <- 网络层 <- 链路层 <- 物理层。分层的好处是能够隔离变化，在接口不变的情况下，某一层的变化只局限于本层次内。

1 协议设计

1.1 包头完整结构定义

索引	字段名称	长度（字节）	说明
0	Magic Number	2（uint16）	固定为 0x0870
1	协议版本	1（uint8）	标识通信双方使用的协议版本，初始版本为 1
2	数据类型	4（uint32）	消息的类型（见 1.2）
3	数据长度	4（uint32）	数据的长度
4	CRC32	4（uint32）	数据的校验和，此处只校验数据部分，不包括包头
5	Reserved	4（uint32）	保留字段
6	数据		实际数据（块大小约定为 4096 * 10 字节）
7	结束标志	2（uint16）	固定为 0x7008

校验和（Checksum）：防止消息被篡改或损坏‌，并非加密技术，一般是对指定字段进行算法处理后得到，比如 IP/TCP/UDP 生成校验和‌的规则为：基于反码求和，接收方用相同规则生成后与发送方提供的对比，若不一致，则消息可能已损坏。常见的算法比如 CRC32，可以通过 CRC（循环冗余校验）在线计算验证。

1.2 包头数据类型定义

类型	含义	说明
0x01	心跳消息	发送心跳，不需要回应
0x02	身份消息	验证身份，如发送 IP 地址
0x03	文件传输消息	重点，详情请看下文（见 1.3）
0x04	远程调用消息

1.3 文件传输消息协议

提供一个可靠、高效、支持断点续传的文件传输协议，即使网络不稳定也能使用。协议通过 ACK/NAK 机制、累积确认（支持乱序数据块接收和重组）、数据完整性校验（块级 CRC32 校验和文件级 SHA256 校验）和流量控制（滑动窗口机制控制发送速率）确保文件传输的可靠性。

1.3.1 协议头

索引	字段名称	长度（字节）	说明
0	Magic Number	4（uint32）	魔数：协议标识符，固定值 0x46545032 (“FTP2”)
1	SessionId	4（uint32）	会话 ID
2	版本号	1（uint8）	初始版本号是 0x01
3	消息类型	1（uint8）	区分不同的消息类型（见 1.3.2）
4	序列号/块号（seqNum）	4（uint32）	在 DATA 消息中表示块序号，在 ACK 中表示最后连续块号
5	文件总大小或块数量	4（uint32）	在 START 消息中表示文件大小，在 NAK/ACK 中表示块数量
6	当前块大小（chunkSize）	4（uint32）	DATA 消息中有效载荷的大小
7	CRC32 校验和	4（uint32）	DATA 消息中数据的 CRC32 校验值

文件传输所有消息的协议头之后都需要带上路径信息：

索引	字段名称	长度（字节）	说明
8	dest_path_len	4（uint32）	目标路径名的长度
9	dest_path	变长	目标路径，表示这个文件是发给谁的

1.3.2 消息类型

类型	名称	方向	说明
0x01	START	发送端 => 接收端	传输开始，包含文件元数据
0x02	START_ACK	接收端 => 发送端	确认开始，准备接收数据
0x03	DATA	发送端 => 接收端	文件数据块
0x04	ACK	接收端 => 发送端	累积确认，确认多个块
0x05	NAK	接收端 => 发送端	否定确认，请求重传
0x06	END	发送端 => 接收端	传输结束，包含文件哈希

1.3.3 START 消息

协议头	路径信息	文件名	文件哈希值	用户名	文件类型
26 字节	变长	256 字节	32 字节	32 字节	1 字节

1.3.4 START_ACK 消息

协议头	路径信息	状态（0：接受传输，1：拒绝传输）	拒绝原因（如果状态为 1）
26 字节	变长	1 字节	64 字节

1.3.5 DATA 消息

协议头	路径信息	数据信息（长度由头中的 chunkSize 决定）
26 字节	变长	变长

1.3.6 ACK 消息

协议头	路径信息	需额外确认的块列表（累积确认）
26 字节	变长	变长

协议头中的 seqNum：已确认的最后一个连续的块号。
协议头中的 totalSize：需额外确认的块数量。
需额外确认的块列表：非连续但已确认的块序号数组。

1.3.7 NAK 消息

协议头	路径信息	缺失块列表
26 字节	变长	变长

协议头中的 totalSize：缺失块数量。
缺失块列表：需要重传的块序号数组。

1.3.8 END 消息

协议头	路径信息	文件哈希值
26 字节	变长	32 字节

2 代码实现

2.1 核心打包工具类

package com.guoguocai.protocol.util;

import com.guoguocai.protocol.constant.ProtocolConstants;
import com.guoguocai.protocol.dto.AckNakMessage;
import com.guoguocai.protocol.dto.PacketHeader;
import com.guoguocai.protocol.dto.StartAckMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.zip.CRC32;

public class ProtocolUtil {

	private static final Logger logger = LoggerFactory.getLogger(ProtocolUtil.class);

	/**
	 * 构建数据包
	 * @param msgType 消息类型
	 * @param transLayerData 传输层消息数据
	 * @return 二进制数据包
	 */
	public static byte[] buildApplicationPacket(int msgType, byte[] transLayerData) {
		int dataLength = transLayerData.length;
		// 计算 CRC32 校验（只校验数据部分，不包括包头）
		CRC32 crc32 = new CRC32();
		crc32.update(transLayerData);
		long crcValue = crc32.getValue();

		// 分配缓冲区：包头 19 字节 + 数据 + 结束标志 2 字节
		ByteBuffer buffer = ByteBuffer.allocate(19 + dataLength + 2);
		buffer.order(ByteOrder.LITTLE_ENDIAN); // 采用小端序，符合嵌入式系统惯例

		// 填充应用层包头
		buffer.putShort(ProtocolConstants.APP_MAGIC_NUMBER);// 2字节 - Magic Number
		buffer.put(ProtocolConstants.APP_VERSION);// 1字节 - 协议版本
		buffer.putInt(msgType);// 4字节 - 消息类型
		buffer.putInt(dataLength);// 4字节 - 数据长度
		buffer.putInt((int) crcValue);// 4字节 - CRC32校验
		buffer.putInt(0);// 4字节 - Reserved 保留字段

		// 填充数据（传输层消息）
		buffer.put(transLayerData);
		// 填充结束标志
		buffer.putShort(ProtocolConstants.APP_END_FLAG);

		return buffer.array();
	}

	/**
	 * 构建文件传输 START 消息
	 * @param sessionId 会话ID
	 * @param destPath 目标路径
	 * @param fileName 文件名
	 * @param userName 用户名
	 * @param fileType 文件类型
	 * @param fileSize 文件总大小
	 * @param fileData 文件数据（用于计算哈希）
	 * @return START 消息二进制数据
	 */
	public static byte[] buildTransStartMessage(int sessionId, String destPath, String fileName, 
                                                String userName, byte fileType, long fileSize, 
                                                byte[] fileData) {
		try {
			// 计算文件 SHA-256 哈希（输出固定为 32 字节）
			MessageDigest digest = MessageDigest.getInstance("SHA-256");
			byte[] fileHash = digest.digest(fileData);

			// 路径信息处理
			byte[] destPathBytes = destPath.getBytes(StandardCharsets.UTF_8);
			int destLen = destPathBytes.length;

			// 文件名处理（最大 256 字节）
			byte[] filenameBytes = Arrays.copyOf(fileName.getBytes("UTF-8"), 256);
			// 用户名处理（32 字节）
			byte[] usernameBytes = Arrays.copyOf(userName.getBytes("UTF-8"), 32);

			// 计算总大小：协议头26字节 + 路径信息（4 + destLen） + START 消息结构
			int totalSize = 26 + 4 + destLen + 256 + 32 + 32 + 1;
			ByteBuffer buffer = ByteBuffer.allocate(totalSize);
			buffer.order(ByteOrder.LITTLE_ENDIAN);

			// 文件传输协议头 - START 消息
			buffer.putInt(ProtocolConstants.TRANS_MAGIC_NUMBER);// 4字节
			buffer.putInt(sessionId);// 4字节
			buffer.put(ProtocolConstants.TRANS_VERSION);// 1字节
			buffer.put(ProtocolConstants.MSG_START);// 1字节
			buffer.putInt(0);// 4字节 - seq_num (START 消息为 0)
			buffer.putInt((int) fileSize);// 4字节 - total_size (文件总大小)
			buffer.putInt(0);// 4字节 - chunk_size (START 消息为 0)
			buffer.putInt(0);// 4字节 - checksum (START 消息为 0)

			// 路径信息
			buffer.putInt(destLen);// 4字节 - 目标路径长度
			buffer.put(destPathBytes);// 可变长度 - 目标路径

			// START 消息内容
			buffer.put(filenameBytes);// 256字节 - 文件名
			buffer.put(Arrays.copyOf(fileHash, 32));// 32字节 - 文件哈希（防御算法版本升级和缓存引用的影响）
			buffer.put(usernameBytes);// 32字节 - 用户名
			buffer.put(fileType);// 1字节 - 文件类型

			return buffer.array();

		} catch (Exception e) {
			throw new RuntimeException("构建文件传输 START 消息失败", e);
		}
	}

	/**
	 * 构建文件传输 DATA 消息
     * @param sessionId 会话ID
     * @param seqNum 序列号
     * @param destPath 目标路径
     * @param chunkData 数据块
     * @return DATA 消息的二进制数据
     */
    public static byte[] buildTransDataMessage(int sessionId, int seqNum, String destPath, 
                                               byte[] chunkData) {
        try {
            byte[] destPathBytes = destPath.getBytes("UTF-8");
            int destLen = destPathBytes.length;
            int chunkSize = chunkData.length;

            // 计算 CRC32 校验（只校验数据部分，不包括头）
            CRC32 crc32 = new CRC32();
            crc32.update(chunkData);
            int checksum = (int) crc32.getValue();

            // 分配缓冲区
            int totalSize = 26 + 4 + destLen + chunkSize;
            ByteBuffer buffer = ByteBuffer.allocate(totalSize);
            buffer.order(ByteOrder.LITTLE_ENDIAN);

            // 文件传输协议头 - DATA 消息
            buffer.putInt(ProtocolConstants.TRANS_MAGIC_NUMBER);// 4字节
            buffer.putInt(sessionId);// 4字节
            buffer.put(ProtocolConstants.TRANS_VERSION);// 1字节
            buffer.put(ProtocolConstants.MSG_DATA);// 1字节
            buffer.putInt(seqNum);// 4字节 - 块序号
            buffer.putInt(0);// 4字节 - total_size (DATA 消息中未使用）
            buffer.putInt(chunkSize);// 4字节 - 当前块大小
            buffer.putInt(checksum);// 4字节 - 数据校验和

            // 路径信息
            buffer.putInt(destLen);// 4字节 - 目标路径长度
            buffer.put(destPathBytes);// 可变长度 - 目标路径
            // 文件数据内容
            buffer.put(chunkData);// 可变长度 - 数据块

            return buffer.array();

        } catch (Exception e) {
            throw new RuntimeException("构建文件传输 DATA 消息失败", e);
        }
    }

	/**
	 * 构建文件传输 END 消息
	 * @param sessionId 会话ID
	 * @param destPath 目标路径
	 * @param fileAllBytes 文件数据（用于计算哈希）
	 * @return END 消息的二进制数据
	 */
	public static byte[] buildTransEndMessage(int sessionId, String destPath, byte[] fileAllBytes) {
		try {
			// 计算文件 SHA-256 哈希
			MessageDigest digest = MessageDigest.getInstance("SHA-256");
			byte[] fileHash = digest.digest(fileAllBytes);

			// 路径信息处理
			byte[] destPathBytes = destPath.getBytes("UTF-8");
			int destLen = destPathBytes.length;

			// 计算总大小：协议头26字节 + 路径信息（4 + destLen） + END 消息结构
			int totalSize = 26 + 4 + destLen + 32;
			ByteBuffer buffer = ByteBuffer.allocate(totalSize);
			buffer.order(ByteOrder.LITTLE_ENDIAN);

			// 文件传输协议头 - END 消息
			buffer.putInt(ProtocolConstants.TRANS_MAGIC_NUMBER);// 4字节
			buffer.putInt(sessionId);// 4字节
			buffer.put(ProtocolConstants.TRANS_VERSION);// 1字节
			buffer.put(ProtocolConstants.MSG_END);// 1字节
			buffer.putInt(0);// 4字节 - seq_num (END 消息为 0)
			buffer.putInt(0);// 4字节 - total_size (END 消息为 0)
			buffer.putInt(0);// 4字节 - chunk_size (END 消息为 0)
			buffer.putInt(0);// 4字节 - checksum (END 消息为 0)

			// 路径信息
			buffer.putInt(destLen);// 4字节 - 目标路径长度
			buffer.put(destPathBytes);// 可变长度 - 目标路径
			// END 消息内容
			buffer.put(Arrays.copyOf(fileHash, 32));// 32字节 - 文件哈希

			return buffer.array();

		} catch (Exception e) {
			throw new RuntimeException("构建文件传输 END 消息失败", e);
		}
	}

	/**
     * 构建完整的文件数据包序列
     * @param filePath 要传输的文件路径
     * @param destPath 目标设备路径
     * @param sessionId 会话ID
     * @param username 用户名
     * @param fileType 文件类型
     * @return 包含所有数据包的列表
     */
    public static List<byte[]> buildCompleteFilePacket(String filePath, String destPath, int sessionId, 
                                                       String username, byte fileType) {
        List<byte[]> allPackets = new ArrayList<>();
        try {
            // 1. 读取文件数据
            byte[] fileAllBytes = Files.readAllBytes(Paths.get(filePath));
            long fileSize = fileAllBytes.length;

            // 2. 构建文件传输 START 消息
            String filename = Paths.get(filePath).getFileName().toString();
            byte[] transStartMsg = buildTransStartMessage(
                sessionId, destPath, filename, username, fileType, fileSize, fileAllBytes);

            // 3. 将 START 消息封装到包中
            byte[] startPacket = buildApplicationPacket(
					ProtocolConstants.FILE_TRANSFER_TYPE, transStartMsg);
            allPackets.add(startPacket);

            // 4. 计算需要的数据块数量
            int totalChunks = (int) Math.ceil((double) fileSize / ProtocolConstants.CHUNK_SIZE);

            // 5. 构建所有的 DATA 消息
            for (int i = 0; i < totalChunks; i++) {
                int startPos = i * ProtocolConstants.CHUNK_SIZE;
                int endPos = Math.min(startPos + ProtocolConstants.CHUNK_SIZE, (int) fileSize);
                // 提取当前数据块
                byte[] chunkData = Arrays.copyOfRange(fileAllBytes, startPos, endPos);
                // 构建 DATA 消息（序列号从 1 开始）
                byte[] transDataMsg = buildTransDataMessage(
                    sessionId, i + 1, destPath, chunkData);
                // 封装到应用层包中
                byte[] dataPacket = buildApplicationPacket(
						ProtocolConstants.FILE_TRANSFER_TYPE, transDataMsg);
                allPackets.add(dataPacket);
            }
			// 6. 构建文件传输 END 消息
			byte[] transEndMsg = buildTransEndMessage(sessionId, destPath, fileAllBytes);
			byte[] endPacket = buildApplicationPacket(ProtocolConstants.FILE_TRANSFER_TYPE, transEndMsg);
			allPackets.add(endPacket);

			logger.info("文件传输数据包构建完成");
			logger.info("文件名: " + filename);
			logger.info("文件大小: " + fileSize + " 字节");
			logger.info("数据块数量: " + totalChunks);
			logger.info("数据包总数量: " + allPackets.size());

            return allPackets;

        } catch (Exception e) {
            throw new RuntimeException("文件打包失败: " + e.getMessage());
        }
    }

	/**
	 * 解析数据包
	 * @param packetData 完整的包数据
	 */
	public static PacketHeader parseApplicationPacket(byte[] packetData) {
		// 最小包头 19 字节 + 结束标志 2 字节
		if (packetData.length < 21) {
			throw new IllegalArgumentException("数据包长度不足");
		}
		ByteBuffer buffer = ByteBuffer.wrap(packetData);
		buffer.order(ByteOrder.LITTLE_ENDIAN);

		PacketHeader header = new PacketHeader();
		header.setMagicNumber(buffer.getShort());
		header.setVersion(buffer.get());
		header.setMsgType(buffer.getInt());
		header.setDataLength(buffer.getInt());
		header.setCrc32(buffer.getInt());
		header.setReserved(buffer.getInt());
		// 提取数据部分
		byte[] transData = new byte[header.getDataLength()];
		buffer.get(transData);
		// 提取结束标志
		header.setEndFlag(buffer.getShort());

		// 验证数据包完整性
		if (header.getMagicNumber() != ProtocolConstants.APP_MAGIC_NUMBER
				|| header.getEndFlag() != ProtocolConstants.APP_END_FLAG) {
			throw new IllegalArgumentException("数据包格式错误");
		}
		header.setTransLayerData(transData);

		return header;
	}

	/**
	 * 解析文件传输 START_ACK 消息
	 * @param transLayerData START_ACK 数据
	 */
	public static StartAckMessage parseStartAckMessage(byte[] transLayerData) {
		ByteBuffer buffer = ByteBuffer.wrap(transLayerData);
		buffer.order(ByteOrder.LITTLE_ENDIAN);

		StartAckMessage startAckMsg = new StartAckMessage();
		// 解析文件传输协议头
		startAckMsg.setMagicNumber(buffer.getInt());
		startAckMsg.setSessionId(buffer.getInt());
		startAckMsg.setVersion(buffer.get());
		startAckMsg.setMsgType(buffer.get());
		startAckMsg.setSeqNum(buffer.getInt());
		startAckMsg.setTotalSize(buffer.getInt());
		startAckMsg.setChunkSize(buffer.getInt());
		startAckMsg.setChecksum(buffer.getInt());

		try {
			// 解析路径信息
			int destLen = buffer.getInt();
			byte[] destPathBytes = new byte[destLen];
			buffer.get(destPathBytes);
			startAckMsg.setDestPath(new String(destPathBytes, StandardCharsets.UTF_8));

			// 解析 START_ACK 消息内容
			startAckMsg.setStatus(buffer.get());
			byte[] reasonBytes = new byte[64];
			buffer.get(reasonBytes);
			startAckMsg.setReason(new String(reasonBytes, "UTF-8").trim());
		} catch (UnsupportedEncodingException e) {
			logger.error("Parse start_ack ex: {}", e.getMessage(), e);
			return null;
		}

		return startAckMsg;
	}

	/**
	 * 解析文件传输 ACK/NAK 消息
	 * @param transLayerData ACK/NAK 数据
	 */
	public static AckNakMessage parseAckNakMessage(byte[] transLayerData) {
		ByteBuffer buffer = ByteBuffer.wrap(transLayerData);
		buffer.order(ByteOrder.LITTLE_ENDIAN);

		AckNakMessage ackNakMsg = new AckNakMessage();
		// 解析文件传输协议头
		ackNakMsg.setMagicNumber(buffer.getInt());
		ackNakMsg.setSessionId(buffer.getInt());
		ackNakMsg.setVersion(buffer.get());
		ackNakMsg.setMsgType(buffer.get());
		ackNakMsg.setSeqNum(buffer.getInt());
		ackNakMsg.setTotalSize(buffer.getInt());
		ackNakMsg.setChunkSize(buffer.getInt());
		ackNakMsg.setChecksum(buffer.getInt());

		try {
			// 解析路径信息
			int destLen = buffer.getInt();
			byte[] destPathBytes = new byte[destLen];
			buffer.get(destPathBytes);
			ackNakMsg.setDestPath(new String(destPathBytes, "UTF-8"));
		} catch (UnsupportedEncodingException e) {
			logger.error("Parse ack/nak ex: {}", e.getMessage(), e);
			return null;
		}

		// 根据 ACK/NAK 消息类型解析不同内容
		if (ackNakMsg.getMsgType() == ProtocolConstants.MSG_ACK) {
			// 解析 ACK 消息需额外确认的块列表
			int extraAckCount = ackNakMsg.getTotalSize();
			int[] extraAckBlocks = new int[extraAckCount];
			for (int i = 0; i < extraAckCount; i++) {
				extraAckBlocks[i] = buffer.getInt();
			}
			ackNakMsg.setExtraAcknowledgedBlocks(extraAckBlocks);

		} else if (ackNakMsg.getMsgType() == ProtocolConstants.MSG_NAK) {
			// 解析 NAK 消息的缺失块列表
			int missingCount = ackNakMsg.getTotalSize();
			int[] missingBlocks = new int[missingCount];
			for (int i = 0; i < missingCount; i++) {
				missingBlocks[i] = buffer.getInt();
			}
			ackNakMsg.setMissingBlocks(missingBlocks);
		}

		return ackNakMsg;
	}

	/**
     * 主方法 - 模拟测试
     */
    public static void main(String[] args) {

        // 模拟文件传输（START => START_ACK（必须等） => DATA => ACK/NAK（可以不等，最后一起算） => END）
        String filePath = "D:\\tmp\\tc12\\device\\files\\测试上传文件.doc"; // 要传输的文件
        String destPath = "/BMBx7/BIOS/KT4MRX"; // 目标设备路径
        int sessionId = 123456; // 会话ID
        String username = "admin"; // 用户名
        byte fileType = 1; // 文件类型

        try {
            // 构建完整的数据包序列
            List<byte[]> packets = ProtocolUtil.buildCompleteFilePacket(
					filePath, destPath, sessionId, username, fileType);

            // 验证第一个数据包（START 消息）
            if (!packets.isEmpty()) {
                byte[] firstPacket = packets.get(0);
				logger.info("第一个数据包长度: " + firstPacket.length + " 字节");

                // 验证 Magic Number
                ByteBuffer verifyBuffer = ByteBuffer.wrap(firstPacket);
                verifyBuffer.order(ByteOrder.LITTLE_ENDIAN);
                short magic = verifyBuffer.getShort();
				logger.info("Magic Number 验证: 0x"
						+ Integer.toHexString(magic & 0xFFFF));

                // 验证结束标志
                verifyBuffer.position(firstPacket.length - 2);
                short endFlag = verifyBuffer.getShort();
				logger.info("结束标志验证: 0x"
						+ Integer.toHexString(endFlag & 0xFFFF));
            }

        } catch (Exception e) {
			logger.error("测试数据包构建失败: " + e.getMessage());
        }

		/**
		// 模拟处理 ACK/NAK 示例
		byte[] simulatedAckNak = new byte[256];// 实际应从网络接收
		Set<Integer> acknowledgedBlocksSet = new HashSet<>();// 已确认的块集合
		Set<Integer> missingBlocksSet = new HashSet<>();// 缺失的块集合

		PacketHeader header = parseApplicationPacket(simulatedAckNak);
		AckNakMessage ackNakMsg = parseAckNakMessage(header.getTransLayerData());
		if (ackNakMsg.getMsgType() == ProtocolConstants.MSG_ACK) {
			logger.info("收到 ACK 累积确认消息");
			logger.info("最后一个连续块号: " + ackNakMsg.getSeqNum());
			logger.info("需额外确认的块数量: " + ackNakMsg.getTotalSize());
			// 更新已确认的块集合
			for (int i = 1; i <= ackNakMsg.getSeqNum(); i++) {
				acknowledgedBlocksSet.add(i);
			}
			// 处理需额外确认的块
			if (ackNakMsg.getExtraAcknowledgedBlocks() != null) {
				for (int block : ackNakMsg.getExtraAcknowledgedBlocks()) {
					acknowledgedBlocksSet.add(block);
				}
			}
		} else if (ackNakMsg.getMsgType() == ProtocolConstants.MSG_NAK) {
			logger.info("收到 NAK 否定确认消息");
			logger.info("缺失块数量: " + ackNakMsg.getTotalSize());
			// 处理缺失块重传
			if (ackNakMsg.getMissingBlocks() != null) {
				for (int block : ackNakMsg.getMissingBlocks()) {
					missingBlocksSet.add(block);
					acknowledgedBlocksSet.remove(block); // 从确认集合中移除
				}
				// 重传缺失块
				if (!missingBlocksSet.isEmpty()) {
					logger.info("开始重传缺失块: " + missingBlocksSet);
					for (Integer missBlock : missingBlocksSet) {
						logger.info("重传块 " + missBlock);
						// 这里应该调用实际的 DATA 消息发送方法
					}
					missingBlocksSet.clear();
				}
			}
		}
		 */
    }
}

2.2 常量类

package com.guoguocai.protocol.constant;

public interface ProtocolConstants {

	/**
	 * 包头
	 */
	short APP_MAGIC_NUMBER = (short) 0x0870;
	short APP_END_FLAG = (short) 0x7008;
	byte APP_VERSION = 1;
	int FILE_TRANSFER_TYPE = 0x3;

	/**
	 * 文件传输层
	 */
	int TRANS_MAGIC_NUMBER = 0x46545032; // "FTP2"
	byte TRANS_VERSION = 0x01;
	int CHUNK_SIZE = 4096 * 10;

	/**
	 * 文件传输消息类型
	 */
	byte MSG_START = 0x01;// 传输开始
	byte MSG_START_ACK = 0x02;// 开始确认
	byte MSG_DATA = 0x03;// 数据块
	byte MSG_ACK = 0x04;// 累积确认
	byte MSG_NAK = 0x05;// 否定确认/请求重传
	byte MSG_END = 0x06;// 传输结束

	/**
	 * 测试模拟数据
	 */
	int SESSION_ID = 123456;// 会话ID
	String USER_NAME = "testUser";// 用户名
	byte FILE_TYPE = 1;// 文件类型

}

2.3 包头结构

package com.guoguocai.protocol.dto;

import lombok.Data;

/**
 * 包头结构
 */
@Data
public class PacketHeader {

	// Magic Number
	private short magicNumber;

	// 协议版本
	private byte version;

	// 消息类型
	private int msgType;

	// 数据长度
	private int dataLength;

	// CRC32校验
	private int crc32;

	// 保留字段
	private int reserved;

	// 结束标志
	private short endFlag;

	// 传输层消息数据
	private byte[] transLayerData;
}

2.4 START_ACK 结构

package com.guoguocai.protocol.dto;

import lombok.Data;

/**
 * START_ACK 消息结构
 */
@Data
public class StartAckMessage {

	// Magic Number
	private int magicNumber;

	// 会话ID
	private int sessionId;

	// 版本号
	private byte version;

	// 消息类型
	private byte msgType;

	// 没有使用
	private int seqNum;

	// 没有使用
	private int totalSize;

	// 没有使用
	private int chunkSize;

	// 没有使用
	private int checksum;

	// 目标路径
	private String destPath;

	// 0:接受传输, 1:拒绝传输
	private byte status;

	// 拒绝原因
	private String reason;
}

2.5 ACK/NAK 结构

package com.guoguocai.protocol.dto;

import lombok.Data;

/**
 * ACK/NAK 消息结构
 */
@Data
public class AckNakMessage {

	// Magic Number
	private int magicNumber;

	// 会话ID
	private int sessionId;

	// 版本号
	private byte version;

	// 消息类型
	private byte msgType;

	// 在 ACK 消息中表示已确认的最后一个连续块号
	private int seqNum;

	// 在 ACK 中表示需额外确认的块数量，在 NAK 中表示缺失的块数量
	private int totalSize;

	// 没有使用
	private int chunkSize;

	// 没有使用
	private int checksum;

	// 目标路径
	private String destPath;

	// 需额外确认的块列表（ACK 消息使用，表示非连续但已确认的块序号数组）
	private int[] extraAcknowledgedBlocks;

	// 缺失块列表（NAK 消息使用，表示需要重传的块序号数组）
	private int[] missingBlocks;
}