[Java] L'utilisation d'UDP et de TCP

La différence entre UDP et TCP

UDP (User Datagram Protocol, User Datagram Protocol) et TCP (Transmission Control Protocol, Transmission Control Protocol) sont deux protocoles de couche de transport couramment utilisés dans les communications réseau. Ils présentent quelques différences essentielles :

连接性：
TCP est un protocole orienté connexion, tandis que UDP est un protocole sans connexion. TCP doit établir une connexion avant de communiquer et la libérer une fois la communication terminée. En revanche, UDP ne nécessite pas l'établissement d'une connexion et chaque paquet est envoyé indépendamment.

可靠性：
TCP fournit une transmission de données fiable, qui utilise des mécanismes d'accusé de réception et de retransmission pour assurer la fiabilité des paquets de données. Si des paquets sont perdus ou corrompus, TCP les renvoie. UDP ne fournit pas de garantie de fiabilité pour la transmission de données, il ne confirmera ni ne retransmettra après l'envoi de paquets de données.

顺序性：
TCP garantit l'ordre des paquets de données, c'est-à-dire que les paquets de données envoyés arriveront à la réception dans l'ordre dans lequel ils ont été envoyés. UDP ne garantit pas l'ordre des paquets de données, de sorte que l'extrémité réceptrice peut recevoir des paquets de données dans n'importe quel ordre.

打包和交付：
TCP utilise des flux d'octets pour emballer les données, puis les réassembler à la réception. UDP envoie chaque paquet de données sous la forme d'un paquet séparé, et l'extrémité réceptrice le reçoit également en fonction du paquet de données correspondant.

性能开销：
Étant donné que TCP assure la fiabilité et la séquentialité, il introduit plus de temps système, tels que l'établissement de la connexion, les mécanismes d'accusé de réception et de retransmission, et des algorithmes tels que le contrôle de flux et le contrôle de congestion. En revanche, UDP a moins de surcharge car il ne fournit pas ces fonctionnalités supplémentaires.

适用场景：
Étant donné que TCP fournit une garantie de fiabilité, il convient aux scénarios nécessitant une transmission de données fiable, tels que le transfert de fichiers, le courrier électronique, etc. UDP convient aux applications qui ont des exigences élevées en temps réel et peuvent tolérer la perte de données, telles que le streaming audio/vidéo, les jeux en ligne, etc.

téléchargement de données

Le téléchargement de données à l'aide d'UDP et de TCP peut être réalisé des manières suivantes :

使用 UDP 进行数据上传：

Le client divise les données en paquets de taille appropriée et les envoie au serveur à l'aide du protocole UDP.

Le serveur reçoit les paquets UDP et traite et stocke les données selon les besoins.

Le client peut choisir d'attendre la réponse de confirmation du serveur après l'envoi du paquet de données pour assurer une transmission de données fiable.

Veuillez noter qu'il existe un risque de perte de données lors de l'utilisation d'UDP pour le téléchargement de données et que vous devez mettre en œuvre vous-même la fiabilité et le traitement séquentiel des paquets de données.

使用 TCP 进行数据上传：

Le client communique avec le serveur en établissant une connexion TCP.

Le client divise les données en blocs de taille appropriée et les envoie au serveur à l'aide du protocole TCP.

Le serveur reçoit des blocs de données TCP et traite et stocke les données selon les besoins.

Le protocole TCP fournit des garanties de transmission de données et de séquence fiables, il n'est donc pas nécessaire de traiter en plus les problèmes de perte de paquets et de séquence.

Il est relativement simple de télécharger des données à l'aide de TCP, mais en raison de l'établissement de la connexion et du mécanisme de confirmation de TCP, un certain délai et une surcharge supplémentaire peuvent être introduits.

exemple de code

Code client pour le téléchargement de données via UDP :

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPUploadClient {
    
    
    public static void main(String[] args) throws IOException {
    
    
        String host = "127.0.0.1";
        int port = 8000;

        String data = "This is the data to upload";

        DatagramSocket socket = new DatagramSocket();

        InetAddress serverAddress = InetAddress.getByName(host);

        byte[] buffer = data.getBytes();

        // 分割数据为适当大小的数据包
        int packetSize = 1024;
        int numPackets = (int) Math.ceil((double) buffer.length / packetSize);

        for (int i = 0; i < numPackets; i++) {
    
    
            int offset = i * packetSize;
            int length = Math.min(packetSize, buffer.length - offset);
            byte[] packetData = new byte[length];
            System.arraycopy(buffer, offset, packetData, 0, length);

            // 发送数据包
            DatagramPacket packet = new DatagramPacket(packetData, packetData.length, serverAddress, port);
            socket.send(packet);
        }

        // 等待服务器的确认响应
        byte[] receiveBuffer = new byte[packetSize];
        DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
        socket.receive(receivePacket);

        // 处理服务器的确认响应
        String response = new String(receivePacket.getData(), receivePacket.getOffset(), receivePacket.getLength());
        System.out.println("Received response from server: " + response);

        socket.close();
    }
}

Code côté serveur pour le téléchargement de données à l'aide d'UDP :

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPUploadServer {
    
    
    public static void main(String[] args) throws IOException {
    
    
        int port = 8000;

        DatagramSocket socket = new DatagramSocket(port);

        byte[] buffer = new byte[1024];

        while (true) {
    
    
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            socket.receive(packet);

            // 处理接收到的数据包
            String data = new String(packet.getData(), packet.getOffset(), packet.getLength());
            System.out.println("Received data from client: " + data);

            // 发送确认响应给客户端
            String response = "Received the data successfully";
            byte[] responseBuffer = response.getBytes();
            DatagramPacket responsePacket = new DatagramPacket(responseBuffer, responseBuffer.length,
                    packet.getAddress(), packet.getPort());
            socket.send(responsePacket);
        }
    }
}

Code client pour le téléchargement de données via TCP :

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class TCPUploadClient {
    
    
    public static void main(String[] args) throws IOException {
    
    
        String host = "127.0.0.1";
        int port = 8000;

        String data = "This is the data to upload";

        Socket socket = new Socket(host, port);

        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(data.getBytes());

        // 等待服务器的确认响应
        byte[] buffer = new byte[1024];
        int bytesRead = socket.getInputStream().read(buffer);
        String response = new String(buffer, 0, bytesRead);
        System.out.println("Received response from server: " + response);

        socket.close();
    }
}

Code côté serveur pour le téléchargement de données via TCP :

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPUploadServer {
    
    
    public static void main(String[] args) throws IOException {
    
    
        int port = 8000;

        ServerSocket serverSocket = new ServerSocket(port);

        while (true) {
    
    
            Socket socket = serverSocket.accept();

            // 接收数据
            InputStream inputStream = socket.getInputStream();
            byte[] buffer = new byte[1024];
            int bytesRead = inputStream.read(buffer);

            // 处理接收到的数据
            String data = new String(buffer, 0, bytesRead);
            System.out.println("Received data from client: " + data);

            // 发送确认响应给客户端
            String response = "Received the data successfully";
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write(response.getBytes());

            socket.close();
        }
    }
}