streamalism.org

1. Oversigt

I denne artikel vil vi udforske netværkskommunikation med Java via User Datagram Protocol (UDP).

UDP er en kommunikationsprotokol, der sender uafhængige pakker over netværket uden nogen garanti for ankomst og ingen garanti for leveringsordren.

Mest kommunikation over internettet finder sted via Transmission Control Protocol (TCP), men UDP har sin plads, som vi vil undersøge i næste afsnit.

2. Hvorfor bruge UDP?

UDP er ret forskellig fra den mere almindelige TCP. Men inden man overvejer ulemperne på overfladeniveau ved UDP, er det vigtigt at forstå, at manglen på overhead kan gøre det betydeligt hurtigere end TCP.

Bortset fra hastighed er vi også nødt til at huske, at nogle former for kommunikation ikke kræver pålidelighed af TCP, men i stedet værdsætter lav latenstid. Videoen er et godt eksempel på en applikation, der kan have gavn af at køre over UDP i stedet for TCP.

3. Opbygning af UDP-applikationer

Opbygning af UDP-applikationer minder meget om at opbygge et TCP-system; den eneste forskel er, at vi ikke opretter en punkt-til-punkt-forbindelse mellem en klient og en server.

Opsætningen er også meget ligetil. Java leveres med indbygget netværksstøtte til UDP - som er en del af java.net pakke. For at udføre netværksoperationer over UDP behøver vi kun at importere klasser fra java.net pakke: java.net.DatagramSocket og java.net.DatagramPacket.

I de følgende afsnit vil vi lære at designe applikationer, der kommunikerer via UDP; vi bruger den populære ekkoprotokol til denne applikation.

Først opbygger vi en ekkoserver, der sender enhver besked sendt tilbage til den, derefter en ekkoklient, der bare sender en vilkårlig besked til serveren, og til sidst vil vi teste applikationen for at sikre, at alt fungerer fint.

4. Serveren

I UDP-kommunikation er en enkelt besked indkapslet i en DatagramPakke som sendes gennem en DatagramSocket.

Lad os starte med at oprette en simpel server:

offentlig klasse EchoServer udvider tråd {privat DatagramSocket-stik; privat boolsk løb; privat byte [] buf = ny byte [256]; offentlig EchoServer () {socket = ny DatagramSocket (4445); } public void run () {running = true; mens (kører) {DatagramPacket-pakke = ny DatagramPacket (buf, buf.length); socket.receive (pakke); InetAddress-adresse = packet.getAddress (); int port = packet.getPort (); pakke = ny DatagramPacket (buf, buf.længde, adresse, port); Streng modtaget = ny streng (packet.getData (), 0, packet.getLength ()); if (received.equals ("end")) {running = false; Blive ved; } socket.send (pakke); } socket.close (); }}

Vi skaber et globalt DatagramSocket som vi hele tiden vil bruge til at sende pakker, et byte-array til at pakke vores meddelelser og en kaldet statusvariabel kører.

For enkelheds skyld udvides serveren Tråd, så vi kan implementere alt inden i løb metode.

Inde løb, opretter vi en while-loop, der bare kører indtil kører ændres til falsk ved en eller anden fejl eller en opsigelsesmeddelelse fra klienten.

Øverst på sløjfen instantierer vi a DatagramPakke for at modtage indgående beskeder.

Dernæst kalder vi modtage metode på stikkontakten. Denne metode blokerer, indtil en meddelelse ankommer, og den gemmer beskeden inde i byte-arrayet i DatagramPakke videregivet til det.

Efter modtagelse af beskeden henter vi klientens adresse og port, da vi sender svaret

tilbage.

Dernæst opretter vi en DatagramPakke for at sende en besked til klienten. Bemærk forskellen i signatur med den modtagende pakke. Denne kræver også adresse og port på den klient, vi sender beskeden til.

5. Kunden

Lad os nu udrulle en simpel klient til denne nye server:

offentlig klasse EchoClient {privat DatagramSocket-stik; privat InetAddress-adresse; privat byte [] buf; offentlig EchoClient () {socket = ny DatagramSocket (); adresse = InetAddress.getByName ("localhost"); } offentlig streng sendEcho (streng msg) {buf = msg.getBytes (); DatagramPacket-pakke = ny DatagramPacket (buf, buf.length, adresse, 4445); socket.send (pakke); pakke = ny DatagramPacket (buf, buf.length); socket.receive (pakke); Streng modtaget = ny streng (packet.getData (), 0, packet.getLength ()); returnering modtaget } offentlig tomrum lukket () {socket.close (); }}

Koden er ikke så forskellig fra serverens. Vi har vores globale DatagramSocket og serverens adresse. Vi instantierer dem inde i konstruktøren.

Vi har en separat metode, der sender meddelelser til serveren og returnerer svaret.

Vi konverterer først strengmeddelelsen til et byte-array og opretter derefter en DatagramPakke til afsendelse af beskeder.

Dernæst - vi sender beskeden. Vi konverterer straks DatagramPakke ind i en modtagende.

Når ekkoet ankommer, konverterer vi bytes til en streng og returnerer strengen.

6. Testen

I en klasse UDPTest.java, opretter vi simpelthen en test for at kontrollere ekkoevnen hos vores to applikationer:

offentlig klasse UDPTest {EchoClient-klient; @Før offentlig ugyldig opsætning () {ny EchoServer (). Start (); klient = ny EchoClient (); } @Test offentlig ugyldig nårCanSendAndReceivePacket_thenCorrect () {String echo = client.sendEcho ("hej server"); assertEquals ("hej server", ekko); echo = client.sendEcho ("serveren fungerer"); assertFalse (echo.equals ("hej server")); } @ Efter offentlig ugyldighed tearDown () {client.sendEcho ("slut"); client.close (); }}

I Opsætning, vi starter serveren og opretter også klienten. Mens du er i rive ned metode, sender vi en opsigelsesbesked til serveren, så den kan lukke, og på samme tid lukker vi klienten.

7. Konklusion

I denne artikel har vi lært om User Datagram-protokollen og med succes bygget vores egne klient-server applikationer, der kommunikerer via UDP.

For at få fuld kildekode til eksemplerne i denne artikel kan du tjekke GitHub-projektet.