Ú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.