gniazdo UDP

Mówiąc o sieciach, nie sposób nie wspomnieć o modelu OSI.

Dziś w tym modelu najbardziej interesuje nas warstwa transportowa (4).

Na tym poziomie pracujemy z danymi, które idą „z punktu A do punktu B”. Głównym zadaniem warstwy transportowej jest zapewnienie dostarczenia wiadomości do miejsca docelowego przy zachowaniu prawidłowej kolejności. Istnieją 2 najpopularniejsze protokoły warstwy transportowej: TCP i UDP. Działają koncepcyjnie na różne sposoby, ale każdy ma swoje zalety, co pozwala na ich wykorzystanie w celu rozwiązania określonych problemów.

Najpierw przyjrzyjmy się, jak działa protokół TCP.

TCP (Transmission Control Protocol) to protokół sieciowy, który zapewnia ustanowienie połączenia między hostami przed wymianą danych.

Jest to bardzo niezawodny protokół, ponieważ za każdym razem, gdy wysyła kolejny pakiet danych, musi sprawdzić, czy dotarł poprzedni pakiet.

Przesyłane pakiety są porządkowane, aw przypadku problemów z danym pakietem (gdy odbiorca nie potwierdza, że ​​pakiet dotarł) wysyłany jest ponownie. Z tego powodu szybkość transmisji jest stosunkowo niska, ponieważ uporządkowanie i ścisła kontrola transmisji danych zajmuje więcej czasu.

I tu pojawia się jego „brat antagonista” – protokół UDP. W przeciwieństwie do TCP, kolejność i status każdego pakietu nie jest dla niego tak ważna, po prostu wysyła dane bez potwierdzenia dostarczenia. Co więcej, nie nawiązuje połączenia i w żaden sposób nie zależy od jego statusu.

Jego zadaniem jest po prostu wysłanie danych na adres. Wynika z tego główna wada protokołu - niska niezawodność, ponieważ może on po prostu gubić fragmenty danych. Ponadto odbiorca musi być przygotowany na to, że dane mogą dotrzeć nie po kolei. Protokół ma również zaletę - wyższą szybkość transmisji, dzięki temu, że zakres zadań tego protokołu ogranicza się do przesyłania danych.

Istnieją również różnice w sposobie samych przesyłanych danych. W protokole TCP dane są przesyłane strumieniowo, co oznacza, że ​​dane nie mają granic. W przypadku UDP dane są przesyłane w postaci datagramów i mają granice, a strona odbierająca sprawdza ich integralność, ale tylko wtedy, gdy wiadomość zostanie pomyślnie odebrana.

Podsumowując:

Java używa obiektów klas DatagramSocket i DatagramPacket do pracy z datagramami do transmisji przez UDP .

W celu wymiany danych nadawca i odbiorca tworzą gniazda typu datagram – obiekty klasy DatagramSocket . Klasa ma kilka konstruktorów, z których różnica polega na tym, gdzie zostanie podłączone utworzone gniazdo:

Klasa zawiera wiele metod dostępu i zarządzania parametrami gniazda (przyjrzymy się im nieco później), a także metod odbierania i wysyłania datagramów:

DatagramPacket to klasa reprezentująca pakiet datagramów. Pakiety datagramowe służą do implementacji usługi bezpołączeniowego dostarczania pakietów. Każda wiadomość jest kierowana z jednej maszyny do drugiej wyłącznie na podstawie informacji zawartych w tym pakiecie. Wiele pakietów wysyłanych z jednego komputera do drugiego może być kierowanych w różny sposób i może docierać w dowolnej kolejności. Dostawa paczek nie jest gwarantowana.

Konstruktorzy:

Ze schematu UDP pamiętamy, że połączenie nie jest nawiązywane, a pakiety są wysyłane na szczęście, w oczekiwaniu, że odbiorca na nie czeka. Ale używając metody klasy DatagramSocket connect(InetAddress addr, int port) można nawiązać połączenie.

Nawiązywane jest jednokierunkowe połączenie z hostem na podstawie adresu i portu: w celu wysyłania lub odbierania datagramów. Takie połączenie można zakończyć za pomocą metody rozłącz() .

Spróbujmy napisać kod serwera (strony odbierającej) w oparciu o DatagramSocket :

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

class Recipient {

   public static void main(String[] args) {
       try {
           DatagramSocket ds = new DatagramSocket(1050);

           while (true) {
               DatagramPacket pack = new DatagramPacket(new byte[5], 5);
               ds.receive(pack);
               System.out.println(new String(pack.getData()));
           }
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

Tworzymy obiekt DatagramSocket do nasłuchiwania na porcie 1050. Gdy otrzyma wiadomość, wypisuje ją na konsoli. Prześlemy słowo „Hello”, więc ograniczamy rozmiar bufora do pięciu bajtów.

Teraz tworzymy klasę nadawcy:

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

class Sender {
   private String host;
   private int port;

   Sender(String host, int port) {
       this.host = host;
       this.port = port;
   }

   private void sendMessage(String mes) {
       try {
           byte[] data = mes.getBytes();
           InetAddress address = InetAddress.getByName(host);
           DatagramPacket pack = new DatagramPacket(data, data.length, address, port);
           DatagramSocket ds = new DatagramSocket();
           ds.send(pack);
           ds.close();
       } catch (IOException e) {
           System.err.println(e);
       }
   }

   public static void main(String[] args) {
   Sender sender = new Sender("localhost", 1050);
   String message = "Hello";

   Timer timer = new Timer();
   timer.scheduleAtFixedRate(new TimerTask() {
       @Override
       public void run() {
           sender.sendMessage(message);
       }
   }, 1000, 1000);
}

}

W metodzie sendMessage tworzymy DatagramPacket , DatagramSocket i wysyłamy naszą wiadomość. Zauważ, że po wysłaniu DatagramSocket jest zamykany metodą close() .

W konsoli odbiorcy co sekundę widzimy przychodzącą wiadomość „Hello” wysłaną przez nadawcę. Oznacza to, że interakcja została nawiązana i wszystko działa poprawnie.