基于udp基础上实现可靠数据传输java代码实现

UDP是一种无连接的协议，因此不提供可靠的数据传输。不过我们可以在UDP的基础上实现可靠数据传输，一种常用的方法是使用ACK确认机制和重传机制。下面是一个简单的Java代码实现：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.HashSet;
import java.util.Set;

public class ReliableUDPServer {
    private static final int TIMEOUT = 5000; // 超时时间，单位为毫秒
    private static final int MAX_TRIES = 3; // 最大重传次数
    private static final int PACKET_SIZE = 1024; // 每个数据包的大小

    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8000);
        byte[] buffer = new byte[PACKET_SIZE];
        DatagramPacket receivePacket = new DatagramPacket(buffer, PACKET_SIZE);
        Set<Integer> receivedSeqNums = new HashSet<>();
        int expectedSeqNum = 0;

        while (true) {
            socket.receive(receivePacket);
            Packet packet = Packet.fromBytes(buffer);
            if (packet.getSeqNum() == expectedSeqNum) { // 收到了期望的数据包
                receivedSeqNums.add(expectedSeqNum);
                expectedSeqNum++;
                System.out.println("Received packet with seqNum = " + packet.getSeqNum());
            }
            sendAck(packet.getSeqNum(), socket, receivePacket.getAddress(), receivePacket.getPort());

            if (receivedSeqNums.size() == 10) { // 收到了所有数据包
                break;
            }
        }

        socket.close();
        System.out.println("All packets received successfully!");
    }

    private static void sendAck(int seqNum, DatagramSocket socket, InetAddress address, int port) throws Exception {
        Packet ackPacket = new Packet(seqNum);
        byte[] ackBuffer = ackPacket.toBytes();
        DatagramPacket ackDatagram = new DatagramPacket(ackBuffer, ackBuffer.length, address, port);

        int tries = 0;
        boolean ackReceived = false;
        do {
            socket.send(ackDatagram);
            byte[] responseBuffer = new byte[PACKET_SIZE];
            DatagramPacket responseDatagram = new DatagramPacket(responseBuffer, PACKET_SIZE);
            socket.setSoTimeout(TIMEOUT);
            try {
                socket.receive(responseDatagram);
                Packet responsePacket = Packet.fromBytes(responseBuffer);
                if (responsePacket.getSeqNum() == seqNum) {
                    ackReceived = true;
                }
            } catch (SocketTimeoutException e) {
                tries++;
            }
        } while (!ackReceived && tries < MAX_TRIES);

        if (!ackReceived) {
            throw new Exception("Failed to receive ACK after " + MAX_TRIES + " tries");
        }
    }
}

class Packet {
    private int seqNum;

    public Packet(int seqNum) {
        this.seqNum = seqNum;
    }

    public int getSeqNum() {
        return seqNum;
    }

    public byte[] toBytes() {
        byte[] buffer = new byte[4];
        buffer[0] = (byte) (seqNum >> 24);
        buffer[1] = (byte) (seqNum >> 16);
        buffer[2] = (byte) (seqNum >> 8);
        buffer[3] = (byte) seqNum;
        return buffer;
    }

    public static Packet fromBytes(byte[] buffer) {
        int seqNum = ((buffer[0] & 0xFF) << 24) | ((buffer[1] & 0xFF) << 16) | ((buffer[2] & 0xFF) << 8) | (buffer[3] & 0xFF);
        return new Packet(seqNum);
    }
}

在这个代码中，我们假设发送方已经将所有数据包发送给了服务器，因此服务器只需要等待所有数据包都被接收到即可。服务器在接收到一个数据包之后，会先检查这个数据包的序列号是否是期望的序列号，如果是则说明这是一个还没有被接收过的数据包，将它的序列号加入到已接收的序列号集合中，然后期望序列号加1。接着服务器会发送一个ACK确认数据包给客户端，让客户端知道这个数据包已经被接收到了。如果服务器在一定时间内没有收到客户端的ACK确认数据包，就会重新发送ACK，最多重传MAX_TRIES次。当服务器收到了所有数据包时，就会退出循环并输出成功的信息。