Introduction de cette section :

Cette section vous présente la dernière partie de Socket : la communication par socket basée sur le protocole UDP. Dans la première section, nous avons déjà comparé en détail les différences entre les deux. La plus grande différence entre TCP et UDP est de savoir si le client et le serveur doivent établir une connexion avant la transmission des données. Si vous avez appris TCP dans les deux sections précédentes, avant la transmission vous démarrez le serveur, accept, attendez que le client se connecte, puis obtenez le socket client et effectuez des opérations d'E/S. Mais UDP n'en a pas besoin. UDP utilise des datagrammes comme support pour la transmission de données. Lors de la transmission, vous définissez d'abord les données à transmettre comme un datagramme (Datagram), spécifiez le Socket (adresse de l'hôte et numéro de port) que les données doivent atteindre dans le datagramme, puis envoyez les données sous forme de datagramme. Et ensuite il n'y a rien de plus. Je ne sais pas si le serveur le reçoit ou non, à moins que le serveur ne renvoie un datagramme de confirmation après l'avoir reçu~ En raison de contraintes de temps, je ne vais pas écrire un exemple Android séparé, donc voici directement le code Java~


1. Étapes d'implémentation côté serveur :

Étape 1: Créer un DatagramSocket et spécifier le numéro de port
Étape 2: Créer un DatagramPacket
Étape 3: Recevoir les informations de données envoyées par le client
Étape 4: Lire les données

Exemple de code:

public class UPDServer {
    public static void main(String[] args) throws IOException {
        /*
         * 接收客户端发送的数据
         */
        // 1.创建服务器端DatagramSocket,指定端口
        DatagramSocket socket = new DatagramSocket(12345);
        // 2.创建数据报,用于接收客户端发送的数据
        byte[] data = new byte[1024];// 创建字节数组,指定接收的数据包的大小
        DatagramPacket packet = new DatagramPacket(data, data.length);
        // 3.接收客户端发送的数据
        System.out.println("****服务器端已经启动,等待客户端发送数据");
        socket.receive(packet);// 此方法在接收到数据报之前会一直阻塞
        // 4.读取数据
        String info = new String(data, 0, packet.getLength());
        System.out.println("我是服务器,客户端说:" + info);

        /*
         * 向客户端响应数据
         */
        // 1.定义客户端的地址、端口号、数据
        InetAddress address = packet.getAddress();
        int port = packet.getPort();
        byte[] data2 = "欢迎您!".getBytes();
        // 2.创建数据报,包含响应的数据信息
        DatagramPacket packet2 = new DatagramPacket(data2, data2.length, address, port);
        // 3.响应客户端
        socket.send(packet2);
        // 4.关闭资源
        socket.close();
    }
}

2. Étapes d'implémentation côté client :

Étape 1: Définir les informations d'envoi
Étape 2: Créer un DatagramPacket contenant les informations à envoyer
Étape 3: Créer un DatagramSocket
Étape 4: Envoyer les données

public class UDPClient {
    public static void main(String[] args) throws IOException {
        /*
         * 向服务器端发送数据
         */
        // 1.定义服务器的地址、端口号、数据
        InetAddress address = InetAddress.getByName("localhost");
        int port = 8800;
        byte[] data = "用户名:admin;密码:123".getBytes();
        // 2.创建数据报,包含发送的数据信息
        DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
        // 3.创建DatagramSocket对象
        DatagramSocket socket = new DatagramSocket();
        // 4.向服务器端发送数据报
        socket.send(packet);

        /*
         * 接收服务器端响应的数据
         */
        // 1.创建数据报,用于接收服务器端响应的数据
        byte[] data2 = new byte[1024];
        DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
        // 2.接收服务器响应的数据
        socket.receive(packet2);
        // 3.读取数据
        String reply = new String(data2, 0, packet2.getLength());
        System.out.println("我是客户端,服务器说:" + reply);
        // 4.关闭资源
        socket.close();
    }
}

Résumé de cette section :

Le contenu de cette section est relativement simple. Il suffit de convertir les données en octets, puis de les placer dansDatagramPacket(le paquet de datagrammes). Lors de l'envoi, incluez l'adresse IP et le numéro de port du destinataire ; lors de la réception, utilisez un tableau d'octets pour mettre en mémoire tampon ! Lors de l'envoi, vous devez créer unDatagramSocket(la classe pour la communication de bout en bout) objet, puis appelez la méthode send pour envoyer le paquet de datagrammes au destinataire~ Le code de cette section provient d'un tutoriel Java Socket sur Muke Network. Si cela vous intéresse, vous pouvez y jeter un œil :Application Java Socket --- La communication se pratique ainsi