Przewodnik po gniazdach Java

1. Przegląd

Termin programowanie w gniazdach odnosi się do pisania programów wykonywanych na wielu komputerach, w których wszystkie urządzenia są ze sobą połączone za pomocą sieci.

Istnieją dwa protokoły komunikacyjne, których można używać do programowania gniazd: User Datagram Protocol (UDP) i Transfer Control Protocol (TCP) .

Główna różnica między nimi polega na tym, że protokół UDP jest bezpołączeniowy, co oznacza, że ​​nie ma sesji między klientem a serwerem, podczas gdy protokół TCP jest zorientowany na połączenie, co oznacza, że ​​należy najpierw ustanowić połączenie na wyłączność między klientem a serwerem, aby mogła nastąpić komunikacja.

Ten samouczek przedstawia wprowadzenie do programowania gniazd w sieciach TCP / IP i pokazuje, jak pisać aplikacje klient / serwer w języku Java. UDP nie jest protokołem głównego nurtu i jako taki może nie być często spotykany.

2. Konfiguracja projektu

Java udostępnia zbiór klas i interfejsów, które zajmują się szczegółami komunikacji niskiego poziomu między klientem a serwerem.

Są one głównie zawarte w pakiecie java.net , więc musimy wykonać następujący import:

import java.net.*;

Potrzebujemy również pakietu java.io , który zapewnia nam strumienie wejściowe i wyjściowe do zapisu i odczytu podczas komunikacji:

import java.io.*;

Dla uproszczenia uruchomimy programy klienckie i serwerowe na tym samym komputerze. Gdybyśmy mieli je uruchamiać na różnych komputerach w sieci, jedyną rzeczą, która by się zmieniła, jest adres IP, w tym przypadku użyjemy localhost na 127.0.0.1 .

3. Prosty przykład

Zabrudzmy sobie ręce najbardziej podstawowymi przykładami dotyczącymi klienta i serwera . Będzie to dwukierunkowa aplikacja komunikacyjna, w której klient wita się z serwerem, a serwer odpowiada.

Utwórzmy aplikację serwerową w klasie o nazwie GreetServer.java z następującym kodem.

Mamy zawierać główne metody i zmienne globalne, aby zwrócić uwagę na to, jak będziemy działać wszystkie serwery w tym artykule. W pozostałych przykładach w artykułach pominiemy ten rodzaj bardziej powtarzalnego kodu:

public class GreetServer { private ServerSocket serverSocket; private Socket clientSocket; private PrintWriter out; private BufferedReader in; public void start(int port) { serverSocket = new ServerSocket(port); clientSocket = serverSocket.accept(); out = new PrintWriter(clientSocket.getOutputStream(), true); in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); String greeting = in.readLine(); if ("hello server".equals(greeting)) { out.println("hello client"); } else { out.println("unrecognised greeting"); } } public void stop() { in.close(); out.close(); clientSocket.close(); serverSocket.close(); } public static void main(String[] args) { GreetServer server=new GreetServer(); server.start(6666); } }

Utwórzmy też klienta o nazwie GreetClient.java z następującym kodem:

public class GreetClient { private Socket clientSocket; private PrintWriter out; private BufferedReader in; public void startConnection(String ip, int port) { clientSocket = new Socket(ip, port); out = new PrintWriter(clientSocket.getOutputStream(), true); in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); } public String sendMessage(String msg) { out.println(msg); String resp = in.readLine(); return resp; } public void stopConnection() { in.close(); out.close(); clientSocket.close(); } }

Uruchommy serwer; w swoim IDE robisz to po prostu uruchamiając go jako aplikację Java.

A teraz wyślijmy pozdrowienie do serwera za pomocą testu jednostkowego, który potwierdza, że ​​serwer faktycznie wysyła pozdrowienia w odpowiedzi:

@Test public void givenGreetingClient_whenServerRespondsWhenStarted_thenCorrect() { GreetClient client = new GreetClient(); client.startConnection("127.0.0.1", 6666); String response = client.sendMessage("hello server"); assertEquals("hello client", response); }

Nie martw się, jeśli nie do końca rozumiesz, co się tutaj dzieje, ponieważ ten przykład ma nam dać wyobrażenie o tym, czego możemy się spodziewać w dalszej części artykułu.

W następnych sekcjach omówimy komunikację przez gniazdo, korzystając z tego prostego przykładu i zagłębimy się w szczegóły z większą liczbą przykładów.

4. Jak działają gniazda

Skorzystamy z powyższego przykładu, aby przejść przez różne części tej sekcji.

Z definicji gniazdo to punkt końcowy dwukierunkowego łącza komunikacyjnego między dwoma programami działającymi na różnych komputerach w sieci. Gniazdo jest powiązane z numerem portu, dzięki czemu warstwa transportowa może zidentyfikować aplikację, do której przeznaczone są dane.

4.1. Serwer

Zwykle serwer działa na określonym komputerze w sieci i ma gniazdo, które jest powiązane z określonym numerem portu. W naszym przypadku korzystamy z tego samego komputera co klient i uruchomiliśmy serwer na porcie 6666 :

ServerSocket serverSocket = new ServerSocket(6666);

Serwer po prostu czeka, nasłuchując gniazda, aż klient wyśle ​​żądanie połączenia. Dzieje się to w następnym kroku:

Socket clientSocket = serverSocket.accept();

Gdy kod serwera napotyka metodę accept , blokuje się, dopóki klient nie wyśle ​​do niego żądania połączenia.

Jeśli wszystko pójdzie dobrze, serwer akceptuje połączenie. Po akceptacji serwer otrzymuje nowe gniazdo, clientSocket , powiązane z tym samym portem lokalnym 6666 , a także ma swój zdalny punkt końcowy ustawiony na adres i port klienta.

W tym momencie nowy obiekt Socket umieszcza serwer w bezpośrednim połączeniu z klientem, dzięki czemu możemy uzyskać dostęp do strumieni wyjściowych i wejściowych, aby odpowiednio pisać i odbierać komunikaty do i od klienta:

PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

Od tego momentu serwer może wymieniać wiadomości z klientem bez końca, aż gniazdo zostanie zamknięte jego strumieniami.

Jednak w naszym przykładzie serwer może wysłać tylko powitanie przed zamknięciem połączenia, co oznacza, że ​​gdybyśmy ponownie przeprowadzili nasz test, połączenie zostałoby odrzucone.

Aby umożliwić ciągłość komunikacji, będziemy musieli czytać ze strumienia wejściowego Wewnątrz natomiast pętla i tylko wyjście, gdy klient wysyła żądanie zakończenia, ujrzymy w akcji w następnym rozdziale.

Dla każdego nowego klienta serwer potrzebuje nowego gniazda zwróconego przez wywołanie accept . ServerSocket służy nadal nasłuchiwać żądań połączeń jednocześnie z tendencją do potrzeb klientów powiązanych. Nie pozwoliliśmy na to jeszcze w naszym pierwszym przykładzie.

4.2. Klient

Klient musi znać nazwę hosta lub adres IP maszyny, na której działa serwer, oraz numer portu, na którym nasłuchuje serwer.

Aby wykonać żądanie połączenia, klient próbuje spotkać się z serwerem na maszynie serwera i na porcie:

Socket clientSocket = new Socket("127.0.0.1", 6666);

Klient musi również zidentyfikować się na serwerze, więc wiąże się z lokalnym numerem portu, przypisanym przez system, z którego będzie korzystał podczas tego połączenia. Sami się tym nie zajmujemy.

The above constructor only creates a new socket when the server has accepted the connection, otherwise, we will get a connection refused exception. When successfully created we can then obtain input and output streams from it to communicate with the server:

PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

The input stream of the client is connected to the output stream of the server, just like the input stream of the server is connected to the output stream of the client.

5. Continuous Communication

Our current server blocks until a client connects to it and then blocks again to listen to a message from the client, after the single message, it closes the connection because we have not dealt with continuity.

So it is only helpful in ping requests, but imagine we would like to implement a chat server, continuous back and forth communication between server and client would definitely be required.

We will have to create a while loop to continuously observe the input stream of the server for incoming messages.

Let's create a new server called EchoServer.java whose sole purpose is to echo back whatever messages it receives from clients:

public class EchoServer { public void start(int port) { serverSocket = new ServerSocket(port); clientSocket = serverSocket.accept(); out = new PrintWriter(clientSocket.getOutputStream(), true); in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); String inputLine; while ((inputLine = in.readLine()) != null) { if (".".equals(inputLine)) { out.println("good bye"); break; } out.println(inputLine); } }

Notice that we have added a termination condition where the while loop exits when we receive a period character.

We will start EchoServer using the main method just as we did for the GreetServer. This time, we start it on another port such as 4444 to avoid confusion.

The EchoClient is similar to GreetClient, so we can duplicate the code. We are separating them for clarity.

In a different test class, we shall create a test to show that multiple requests to the EchoServer will be served without the server closing the socket. This is true as long as we are sending requests from the same client.

Dealing with multiple clients is a different case, which we shall see in a subsequent section.

Let's create a setup method to initiate a connection with the server:

@Before public void setup() { client = new EchoClient(); client.startConnection("127.0.0.1", 4444); }

We will equally create a tearDown method to release all our resources, this is best practice for every case where we use network resources:

@After public void tearDown() { client.stopConnection(); }

Let's then test our echo server with a few requests:

@Test public void givenClient_whenServerEchosMessage_thenCorrect() { String resp1 = client.sendMessage("hello"); String resp2 = client.sendMessage("world"); String resp3 = client.sendMessage("!"); String resp4 = client.sendMessage("."); assertEquals("hello", resp1); assertEquals("world", resp2); assertEquals("!", resp3); assertEquals("good bye", resp4); }

This is an improvement over the initial example, where we would only communicate once before the server closed our connection; now we send a termination signal to tell the server when we're done with the session.

6. Server With Multiple Clients

Much as the previous example was an improvement over the first one, it is still not that great a solution. A server must have the capacity to service many clients and many requests simultaneously.

Handling multiple clients is what we are going to cover in this section.

Another feature we will see here is that the same client could disconnect and reconnect again, without getting a connection refused exception or a connection reset on the server. Previously we were not able to do this.

This means that our server is going to be more robust and resilient across multiple requests from multiple clients.

How we will do this is to create a new socket for every new client and service that client's requests on a different thread. The number of clients being served simultaneously will equal the number of threads running.

The main thread will be running a while loop as it listens for new connections.

Enough talk, let's create another server called EchoMultiServer.java. Inside it, we will create a handler thread class to manage each client's communications on its socket:

public class EchoMultiServer { private ServerSocket serverSocket; public void start(int port) { serverSocket = new ServerSocket(port); while (true) new EchoClientHandler(serverSocket.accept()).start(); } public void stop() { serverSocket.close(); } private static class EchoClientHandler extends Thread { private Socket clientSocket; private PrintWriter out; private BufferedReader in; public EchoClientHandler(Socket socket) { this.clientSocket = socket; } public void run() { out = new PrintWriter(clientSocket.getOutputStream(), true); in = new BufferedReader( new InputStreamReader(clientSocket.getInputStream())); String inputLine; while ((inputLine = in.readLine()) != null) { if (".".equals(inputLine)) { out.println("bye"); break; } out.println(inputLine); } in.close(); out.close(); clientSocket.close(); } }

Notice that we now call accept inside a while loop. Every time the while loop is executed, it blocks on the accept call until a new client connects, then the handler thread, EchoClientHandler, is created for this client.

What happens inside the thread is what we previously did in the EchoServer where we handled only a single client. So the EchoMultiServer delegates this work to EchoClientHandler so that it can keep listening for more clients in the while loop.

Nadal będziemy używać EchoClient do testowania serwera, tym razem utworzymy wielu klientów, z których każdy będzie wysyłał i odbierał wiele wiadomości z serwera.

Zacznijmy nasz serwer przy użyciu jego głównej metody na porcie 5555 .

Dla jasności nadal będziemy umieszczać testy w nowym zestawie:

@Test public void givenClient1_whenServerResponds_thenCorrect() { EchoClient client1 = new EchoClient(); client1.startConnection("127.0.0.1", 5555); String msg1 = client1.sendMessage("hello"); String msg2 = client1.sendMessage("world"); String terminate = client1.sendMessage("."); assertEquals(msg1, "hello"); assertEquals(msg2, "world"); assertEquals(terminate, "bye"); } @Test public void givenClient2_whenServerResponds_thenCorrect() { EchoClient client2 = new EchoClient(); client2.startConnection("127.0.0.1", 5555); String msg1 = client2.sendMessage("hello"); String msg2 = client2.sendMessage("world"); String terminate = client2.sendMessage("."); assertEquals(msg1, "hello"); assertEquals(msg2, "world"); assertEquals(terminate, "bye"); }

Moglibyśmy stworzyć tyle przypadków testowych, ile byśmy chcieli, każdy z nich tworzy nowego klienta, a serwer będzie obsługiwał je wszystkie.

7. Wnioski

W tym samouczku skupiliśmy się na wprowadzeniu do programowania gniazd za pośrednictwem protokołu TCP / IP i napisaliśmy prostą aplikację klient / serwer w języku Java.

Pełny kod źródłowy artykułu można znaleźć - jak zwykle - w projekcie GitHub.