{"id":479,"date":"2024-07-02T22:35:18","date_gmt":"2024-07-02T21:35:18","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=479"},"modified":"2024-07-04T22:35:36","modified_gmt":"2024-07-04T21:35:36","slug":"einfuehrung-in-udp-sockets-in-java","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=479","title":{"rendered":"Einf\u00fchrung in UDP-Sockets in Java"},"content":{"rendered":"\n

In der Netzwerkprogrammierung ist es oft notwendig, Daten zwischen verschiedenen Computern \u00fcber ein Netzwerk zu senden und zu empfangen. Java bietet verschiedene M\u00f6glichkeiten, dies zu erreichen, wobei eine der effizientesten Methoden die Verwendung von Sockets ist. Insbesondere User Datagram Protocol (UDP) Sockets bieten eine leichte und schnelle Methode zur Daten\u00fcbertragung. In diesem Artikel werden wir uns intensiv mit UDP-Sockets in Java besch\u00e4ftigen, sowohl auf Server- als auch auf Client-Seite, und die Unterschiede zwischen UDP und Transmission Control Protocol (TCP) erl\u00e4utern.<\/p>\n\n\n\n

Unterschiede zwischen UDP und TCP<\/h2>\n\n\n\n

Bevor wir in die Implementierung eintauchen, ist es wichtig, die grundlegenden Unterschiede zwischen UDP und TCP zu verstehen:<\/p>\n\n\n\n

    \n
  1. Verbindungsorientierung:<\/strong><\/li>\n<\/ol>\n\n\n\n
      \n
    • TCP:<\/strong> Verbindungsorientiert. Eine Verbindung muss vor der Daten\u00fcbertragung aufgebaut und nach der \u00dcbertragung abgebaut werden.<\/li>\n\n\n\n
    • UDP:<\/strong> Verbindungslos. Daten werden ohne vorherige Verbindung gesendet.<\/li>\n<\/ul>\n\n\n\n
        \n
      1. Zuverl\u00e4ssigkeit:<\/strong><\/li>\n<\/ol>\n\n\n\n
          \n
        • TCP:<\/strong> Bietet zuverl\u00e4ssige Daten\u00fcbertragung mit Fehlerkorrektur und Best\u00e4tigung (ACK).<\/li>\n\n\n\n
        • UDP:<\/strong> Bietet keine Garantie f\u00fcr die Zustellung. Pakete k\u00f6nnen verloren gehen oder in falscher Reihenfolge ankommen.<\/li>\n<\/ul>\n\n\n\n
            \n
          1. Daten\u00fcbertragung:<\/strong><\/li>\n<\/ol>\n\n\n\n
              \n
            • TCP:<\/strong> Stream-orientiert. Daten werden als kontinuierlicher Strom gesendet.<\/li>\n\n\n\n
            • UDP:<\/strong> Nachrichten-orientiert. Daten werden in Form von Datagrammen gesendet.<\/li>\n<\/ul>\n\n\n\n
                \n
              1. Geschwindigkeit:<\/strong><\/li>\n<\/ol>\n\n\n\n
                  \n
                • TCP:<\/strong> Langsamer aufgrund der zus\u00e4tzlichen Overheads f\u00fcr Verbindungsmanagement und Fehlerkorrektur.<\/li>\n\n\n\n
                • UDP:<\/strong> Schneller und effizienter f\u00fcr Anwendungen, die geringe Latenz erfordern.<\/li>\n<\/ul>\n\n\n\n

                  UDP eignet sich daher gut f\u00fcr Anwendungen, bei denen Geschwindigkeit wichtiger ist als Zuverl\u00e4ssigkeit, wie z.B. Echtzeit-Multimedia-Streaming oder Online-Gaming.<\/p>\n\n\n\n

                  Entwicklung einer UDP-Server-Anwendung<\/h2>\n\n\n\n

                  Schritt 1: Erstellung eines UDP-Sockets<\/h3>\n\n\n\n

                  Der erste Schritt zur Erstellung eines UDP-Servers besteht darin, einen DatagramSocket zu erstellen und an einen bestimmten Port zu binden.<\/p>\n\n\n

                  import<\/span> java.net.DatagramSocket;\nimport<\/span> java.net.SocketException;\n\npublic class<\/span> UDPServer<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        int port = 9876<\/span>;\n        try<\/span> {\n            DatagramSocket serverSocket = new<\/span> DatagramSocket(port);\n            System.out.println(\"Server gestartet auf Port \"<\/span> + port);\n        } catch<\/span> (SocketException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Schritt 2: Empfang von Daten<\/h3>\n\n\n\n
                  Ein UDP-Server empf\u00e4ngt Daten in Form von Datagram-Paketen. Diese werden mit Hilfe eines DatagramPacket-Objekts empfangen.<\/p>\n\n\n
                  import<\/span> java.net.DatagramPacket;\nimport<\/span> java.io.IOException;\n\npublic class<\/span> UDPServer<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        int port = 9876<\/span>;\n        try<\/span> {\n            DatagramSocket serverSocket = new<\/span> DatagramSocket(port);\n            System.out.println(\"Server gestartet auf Port \"<\/span> + port);\n\n            byte[] receiveData = new<\/span> byte[1024<\/span>];\n\n            while<\/span> (true<\/span>) {\n                DatagramPacket receivePacket = new<\/span> DatagramPacket(receiveData, receiveData.length);\n                serverSocket.receive(receivePacket);\n                String<\/span> message = new<\/span> String<\/span>(receivePacket.getData(), 0<\/span>, receivePacket.getLength());\n                System.out.println(\"Empfangene Nachricht: \"<\/span> + message);\n            }\n        } catch<\/span> (IOException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Schritt 3: Senden einer Antwort<\/h3>\n\n\n\n
                  Der Server kann auch Daten an den Client zur\u00fccksenden. Dies erfolgt ebenfalls mittels eines DatagramPacket-Objekts.<\/p>\n\n\n
                  import<\/span> java.net.InetAddress;\n\npublic class<\/span> UDPServer<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        int port = 9876<\/span>;\n        try<\/span> {\n            DatagramSocket serverSocket = new<\/span> DatagramSocket(port);\n            System.out.println(\"Server gestartet auf Port \"<\/span> + port);\n\n            byte[] receiveData = new<\/span> byte[1024<\/span>];\n            byte[] sendData;\n\n            while<\/span> (true<\/span>) {\n                DatagramPacket receivePacket = new<\/span> DatagramPacket(receiveData, receiveData.length);\n                serverSocket.receive(receivePacket);\n                String<\/span> message = new<\/span> String<\/span>(receivePacket.getData(), 0<\/span>, receivePacket.getLength());\n                System.out.println(\"Empfangene Nachricht: \"<\/span> + message);\n\n                \/\/ Antwort erstellen<\/span>\n                String<\/span> response = \"Hallo, Client!\"<\/span>;\n                sendData = response.getBytes();\n\n                InetAddress clientAddress = receivePacket.getAddress();\n                int clientPort = receivePacket.getPort();\n\n                DatagramPacket sendPacket = new<\/span> DatagramPacket(sendData, sendData.length, clientAddress, clientPort);\n                serverSocket.send(sendPacket);\n            }\n        } catch<\/span> (IOException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Entwicklung einer UDP-Client-Anwendung<\/h2>\n\n\n\n
                  Schritt 1: Erstellung eines UDP-Sockets<\/h3>\n\n\n\n
                  Analog zum Server muss auch der Client einen DatagramSocket erstellen.<\/p>\n\n\n
                  import<\/span> java.net.DatagramSocket;\nimport<\/span> java.net.SocketException;\n\npublic class<\/span> UDPClient<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        try<\/span> {\n            DatagramSocket clientSocket = new<\/span> DatagramSocket();\n            System.out.println(\"Client gestartet.\"<\/span>);\n        } catch<\/span> (SocketException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Schritt 2: Senden von Daten<\/h3>\n\n\n\n
                  Der Client sendet Daten an den Server mittels eines DatagramPacket-Objekts.<\/p>\n\n\n
                  import<\/span> java.net.DatagramPacket;\nimport<\/span> java.net.InetAddress;\nimport<\/span> java.io.IOException;\n\npublic class<\/span> UDPClient<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        try<\/span> {\n            DatagramSocket clientSocket = new<\/span> DatagramSocket();\n            InetAddress serverAddress = InetAddress.getByName(\"localhost\"<\/span>);\n            int serverPort = 9876<\/span>;\n\n            String<\/span> message = \"Hallo, Server!\"<\/span>;\n            byte[] sendData = message.getBytes();\n\n            DatagramPacket sendPacket = new<\/span> DatagramPacket(sendData, sendData.length, serverAddress, serverPort);\n            clientSocket.send(sendPacket);\n            System.out.println(\"Nachricht gesendet: \"<\/span> + message);\n        } catch<\/span> (IOException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Schritt 3: Empfang von Daten<\/h3>\n\n\n\n
                  Nach dem Senden der Daten kann der Client auch eine Antwort vom Server empfangen.<\/p>\n\n\n
                  public class<\/span> UDPClient<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        try<\/span> {\n            DatagramSocket clientSocket = new<\/span> DatagramSocket();\n            InetAddress serverAddress = InetAddress.getByName(\"localhost\"<\/span>);\n            int serverPort = 9876<\/span>;\n\n            String<\/span> message = \"Hallo, Server!\"<\/span>;\n            byte[] sendData = message.getBytes();\n\n            DatagramPacket sendPacket = new<\/span> DatagramPacket(sendData, sendData.length, serverAddress, serverPort);\n            clientSocket.send(sendPacket);\n            System.out.println(\"Nachricht gesendet: \"<\/span> + message);\n\n            byte[] receiveData = new<\/span> byte[1024<\/span>];\n            DatagramPacket receivePacket = new<\/span> DatagramPacket(receiveData, receiveData.length);\n            clientSocket.receive(receivePacket);\n            String<\/span> response = new<\/span> String<\/span>(receivePacket.getData(), 0<\/span>, receivePacket.getLength());\n            System.out.println(\"Antwort vom Server: \"<\/span> + response);\n        } catch<\/span> (IOException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Fazit<\/h2>\n\n\n\n
                  UDP-Sockets bieten eine einfache und effiziente M\u00f6glichkeit zur Daten\u00fcbertragung \u00fcber ein Netzwerk. Obwohl UDP weniger zuverl\u00e4ssig ist als TCP, kann es f\u00fcr Anwendungen, die geringe Latenz und hohe Geschwindigkeit erfordern, sehr n\u00fctzlich sein. Durch die Verwendung der Java DatagramSocket und DatagramPacket Klassen k\u00f6nnen sowohl Server- als auch Client-Anwendungen effektiv entwickelt werden. Mit den oben beschriebenen Schritten und Codebeispielen sollte die Implementierung von UDP-Sockets in Java klarer geworden sein.<\/p>\n","protected":false},"excerpt":{"rendered":"
                  In der Netzwerkprogrammierung ist es oft notwendig, Daten zwischen verschiedenen Computern \u00fcber ein Netzwerk zu senden und zu empfangen. Java bietet verschiedene M\u00f6glichkeiten, dies zu erreichen, wobei eine der effizientesten Methoden die Verwendung von Sockets ist. Insbesondere User Datagram Protocol (UDP) Sockets bieten eine leichte und schnelle Methode zur Daten\u00fcbertragung. In diesem Artikel werden wir […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-479","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/479","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=479"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/479\/revisions"}],"predecessor-version":[{"id":480,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/479\/revisions\/480"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=479"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=479"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=479"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}