Einführung in diesen Abschnitt:

Dieser Abschnitt bringt Ihnen den letzten Teil von Socket: Socket-Kommunikation auf Basis des UDP-Protokolls. Im ersten Abschnitt haben wir die Unterschiede zwischen beiden bereits ausführlich verglichen. Der größte Unterschied zwischen TCP und UDP besteht darin, ob Client und Server vor der Datenübertragung eine Verbindung herstellen müssen. Wenn Sie TCP aus den beiden vorherigen Abschnitten gelernt haben, starten Sie vor der Übertragung den Server, rufen accept auf, warten auf die Verbindung des Clients, holen dann den Client-Socket und führen IO-Operationen aus. UDP benötigt dies jedoch nicht. UDP verwendet Datagramme als Träger für die Datenübertragung. Beim Übertragen definieren Sie zunächst die zu übertragenden Daten als Datagramm (Datagram), geben im Datagramm den Socket (Hostadresse und Portnummer) an, den die Daten erreichen müssen, und senden die Daten dann in Form eines Datagramms ab. Und dann gibt es nichts weiter. Ich weiß nicht, ob der Server es empfängt oder nicht, es sei denn, der Server sendet nach dem Empfang ein Bestätigungsdatagramm zurück~ Aus Zeitgründen schreibe ich kein separates Android-Beispiel, daher hier direkt der Java-Code~


1. Implementierungsschritte auf der Serverseite:

Schritt 1: Erstellen Sie einen DatagramSocket und geben Sie die Portnummer an
Schritt 2: Erstellen Sie ein DatagramPacket
Schritt 3: Empfangen Sie die vom Client gesendeten Dateninformationen
Schritt 4: Lesen Sie die Daten

Beispielcode:

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. Implementierungsschritte auf der Clientseite:

Schritt 1: Definieren Sie die zu sendenden Informationen
Schritt 2: Erstellen Sie ein DatagramPacket, das die zu sendenden Informationen enthält
Schritt 3: Erstellen Sie einen DatagramSocket
Schritt 4: Senden Sie die Daten

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();
    }
}

Zusammenfassung dieses Abschnitts:

The content of this section is relatively simple. It is just converting data into bytes, then putting them intoDatagramPacket(das Datagramm-Paket) zu packen. Beim Senden geben Sie die IP-Adresse und die Portnummer des Empfängers an; beim Empfangen verwenden Sie ein Byte-Array als Puffer! Beim Senden müssen Sie einDatagramSocket(die Klasse für die Ende-zu-Ende-Kommunikation)-Objekt erstellen und dann die send-Methode aufrufen, um das Datagramm-Paket an den Empfänger zu senden~ Der Code in diesem Abschnitt stammt aus einem Java-Socket-Tutorial von Muke Network. Wenn Sie interessiert sind, können Sie einen Blick darauf werfen:Java-Socket-Anwendung --- So wird Kommunikation in der Praxis umgesetzt