Útmutató az UDP Java használatához

1. Áttekintés

Ebben a cikkben a Java-val folytatott hálózati kommunikációt fogjuk feltárni a User Datagram Protocol (UDP) protokollon keresztül.

Az UDP egy kommunikációs protokoll, amely független csomagokat továbbít a hálózaton az érkezési garancia és a szállítási sorrend garanciája nélkül.

Az interneten keresztül a legtöbb kommunikáció a Transmission Control Protocol (TCP) protokollon keresztül zajlik, azonban az UDP-nek megvan a maga helye, amelyet a következő szakaszban fogunk feltárni.

2. Miért érdemes használni az UDP-t?

Az UDP egészen más, mint a gyakoribb TCP. De mielőtt figyelembe vesszük az UDP felületi szintű hátrányait, fontos megértenünk, hogy a rezsi hiánya jelentősen gyorsabbá teheti, mint a TCP.

A sebességen kívül arra is emlékeznünk kell, hogy bizonyos típusú kommunikáció nem igényli a TCP megbízhatóságát, hanem ehelyett alacsony késleltetést jelent. A videó jó példa egy olyan alkalmazásra, amelynek előnyös lehet, ha TCP helyett UDP-t futtat.

3. UDP alkalmazások építése

Az UDP alkalmazások építése nagyon hasonlít a TCP rendszer kiépítésére; az egyetlen különbség az, hogy nem létesítünk pont-pont kapcsolatot az ügyfél és a szerver között.

A beállítás is nagyon egyszerű. A Java beépített hálózati támogatással szállítja az UDP-t - ami része a java.net csomag. Ezért a hálózati műveletek UDP-n keresztül történő végrehajtásához csak az osztályokat kell importálnunk a java.net csomag: java.net.DatagramSocket és java.net.DatagramPacket.

A következő szakaszokban megtanuljuk, hogyan kell megtervezni az UDP-n keresztül kommunikáló alkalmazásokat; ehhez az alkalmazáshoz a népszerű echo protokollt fogjuk használni.

Először felépítünk egy visszhangkiszolgálót, amely visszaküldi a neki küldött üzeneteket, majd egy visszhangklienst, amely csak tetszőleges üzeneteket küld a szervernek, és végül teszteljük az alkalmazást annak biztosítására, hogy minden jól működjön.

4. A szerver

Az UDP kommunikációban egyetlen üzenet van bekapszulázva a DatagramPacket amelyet a DatagramSocket.

Kezdjük egy egyszerű szerver beállításával:

nyilvános osztályú EchoServer kiterjeszti a Thread {private DatagramSocket socketet; privát logikai futás; privát bájt [] buf = új bájt [256]; public EchoServer () {socket = new DatagramSocket (4445); } public void run () {running = true; míg (fut) {DatagramPacket packet = new DatagramPacket (buf, buf.length); socket.receive (csomag); InetAddress cím = packet.getAddress (); int port = packet.getPort (); packet = new DatagramPacket (buf, buf.hossz, cím, port); String kapott = új karakterlánc (packet.getData (), 0, packet.getLength ()); if (kapott.egyenlő ("vég")) {fut = hamis; folytatni; } socket.send (csomag); } socket.close (); }}

Globálist hozunk létre DatagramSocket amelyet végig fogunk használni csomagok küldésére, egy bájt tömböt az üzeneteink csomagolására és egy állapotváltozót futás.

Az egyszerűség kedvéért a kiszolgáló bővül cérna, így mindent megvalósíthatunk a fuss módszer.

Belül fuss, létrehozunk egy darab ciklust, amely csak addig fut futás hamisra változik valamilyen hiba vagy az ügyfél által küldött felmondási üzenet.

A hurok tetején példányosítjuk a DatagramPacket bejövő üzenetek fogadására.

Ezután hívjuk a kap módszer a foglalaton. Ez a módszer addig blokkol, amíg egy üzenet meg nem érkezik, és az üzenetet a DatagramPacket átment hozzá.

Miután megkapta az üzenetet, lekérjük az ügyfél címét és portját, mivel elküldjük a választ

vissza.

Ezután létrehozunk egy DatagramPacket üzenet küldése az ügyfélnek. Figyelje meg az aláírás különbségét a fogadó csomaggal. Ehhez meg kell adni annak az ügyfélnek a címét és portját is, amelynek az üzenetet küldjük.

5. Az Ügyfél

Most indítsunk el egy egyszerű klienst ehhez az új szerverhez:

public class EchoClient {private DatagramSocket socket; privát InetAddress cím; privát bájt [] buf; public EchoClient () {socket = new DatagramSocket (); address = InetAddress.getByName ("localhost"); } public String sendEcho (String msg) {buf = msg.getBytes (); DatagramPacket packet = új DatagramPacket (buf, buf.length, address, 4445); socket.send (csomag); csomag = new DatagramPacket (buf, buf.length); socket.receive (csomag); String kapott = új karakterlánc (packet.getData (), 0, packet.getLength ()); beérkezett visszatérítés; } public void bezárás () {socket.close (); }}

A kód nem annyira különbözik a szerverétõl. Megvan a globális DatagramSocket és a szerver címe. Ezeket a konstruktoron belül példázzuk.

Van egy külön módszerünk, amely üzeneteket küld a szervernek és visszaküldi a választ.

Először konvertáljuk a string üzenetet bájt tömbgé, majd létrehozunk egy DatagramPacket üzenetek küldésére.

Következő - elküldjük az üzenetet. Azonnal átalakítjuk a DatagramPacket befogadóvá.

Amikor a visszhang megérkezik, a bájtokat karakterláncokká alakítjuk, és visszaadjuk a karakterláncot.

6. A teszt

Egy osztályban UDPTest.java, egyszerűen létrehozunk egy tesztet, hogy ellenőrizzük a két alkalmazás visszhangzó képességét:

public class UDPTest {EchoClient kliens; @A nyilvános void beállítása előtt () {új EchoServer (). Start (); kliens = új EchoClient (); } @Test public void whenCanSendAndReceivePacket_thenCorrect () {String echo = client.sendEcho ("hello server"); assertEquals ("hello server", echo); echo = client.sendEcho ("a szerver működik"); assertFalse (echo.equals ("hello szerver")); } @A nyilvános void után tearDown () {client.sendEcho ("end"); client.close (); }}

Ban ben beállít, elindítjuk a szervert, és létrehozzuk az ügyfelet is. Míg a tearDown módszerrel egy felmondási üzenetet küldünk a szervernek, hogy az bezáródhasson, és ezzel egyidejűleg bezárjuk az ügyfelet is.

7. Következtetés

Ebben a cikkben megismerkedtünk a User Datagram Protokollal és sikeresen felépítettük saját kliens-kiszolgáló alkalmazásainkat, amelyek UDP-n keresztül kommunikálnak.

A cikkben használt példák teljes forráskódjának megtekintéséhez nézze meg a GitHub projektet.