Una guida ai socket Java

1. Panoramica

Il termine programmazione socket si riferisce alla scrittura di programmi che vengono eseguiti su più computer in cui i dispositivi sono tutti collegati tra loro tramite una rete.

Sono disponibili due protocolli di comunicazione che è possibile utilizzare per la programmazione socket: UDP (User Datagram Protocol) e TCP (Transfer Control Protocol) .

La principale differenza tra i due è che UDP è senza connessione, il che significa che non c'è sessione tra il client e il server mentre il TCP è orientato alla connessione, il che significa che una connessione esclusiva deve essere prima stabilita tra client e server affinché la comunicazione abbia luogo.

Questo tutorial presenta un'introduzione alla programmazione dei socket su reti TCP / IP e dimostra come scrivere applicazioni client / server in Java. UDP non è un protocollo mainstream e come tale potrebbe non essere riscontrato spesso.

2. Configurazione del progetto

Java fornisce una raccolta di classi e interfacce che si prendono cura dei dettagli di comunicazione di basso livello tra il client e il server.

Questi sono per lo più contenuti nel pacchetto java.net , quindi dobbiamo effettuare la seguente importazione:

import java.net.*;

Abbiamo anche bisogno del pacchetto java.io che ci fornisce flussi di input e output su cui scrivere e da cui leggere durante la comunicazione:

import java.io.*;

Per semplicità, eseguiremo i nostri programmi client e server sullo stesso computer. Se dovessimo eseguirli su diversi computer in rete, l'unica cosa che cambierebbe sarebbe l'indirizzo IP, in questo caso useremo localhost su 127.0.0.1 .

3. Semplice esempio

Sporciamoci le mani con gli esempi più elementari che coinvolgono un client e un server . Sarà un'applicazione di comunicazione a due vie in cui il client saluta il server e il server risponde.

Creiamo l'applicazione server in una classe chiamata GreetServer.java con il codice seguente.

Includiamo il metodo principale e le variabili globali per attirare l'attenzione su come eseguiremo tutti i server in questo articolo. Nel resto degli esempi negli articoli, ometteremo questo tipo di codice più ripetitivo:

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); } }

Creiamo anche un client chiamato GreetClient.java con questo codice:

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(); } }

Avviamo il server; nel tuo IDE lo fai semplicemente eseguendolo come applicazione Java.

E ora inviamo un saluto al server utilizzando uno unit test, che conferma che il server invia effettivamente un saluto in risposta:

@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); }

Non preoccuparti se non capisci completamente cosa sta succedendo qui, poiché questo esempio ha lo scopo di darci un'idea di cosa aspettarci più avanti nell'articolo.

Nelle sezioni seguenti analizzeremo la comunicazione socket utilizzando questo semplice esempio e approfondiremo i dettagli con altri esempi.

4. Come funzionano i socket

Useremo l'esempio precedente per scorrere le diverse parti di questa sezione.

Per definizione, un socket è un endpoint di un collegamento di comunicazione bidirezionale tra due programmi in esecuzione su computer diversi in una rete. Un socket è associato a un numero di porta in modo che il livello di trasporto possa identificare l'applicazione a cui sono destinati i dati.

4.1. Il server

Di solito, un server viene eseguito su un computer specifico della rete e dispone di un socket associato a un numero di porta specifico. Nel nostro caso, utilizziamo lo stesso computer del client e abbiamo avviato il server sulla porta 6666 :

ServerSocket serverSocket = new ServerSocket(6666);

Il server attende solo, ascoltando il socket che un client effettui una richiesta di connessione. Questo accade nel passaggio successivo:

Socket clientSocket = serverSocket.accept();

Quando il codice del server incontra il metodo di accettazione , si blocca finché un client non effettua una richiesta di connessione ad esso.

Se tutto va bene, il server accetta la connessione. Dopo l'accettazione, il server ottiene un nuovo socket, clientSocket , associato alla stessa porta locale, 6666 , e ha anche il suo endpoint remoto impostato sull'indirizzo e sulla porta del client.

A questo punto il nuovo oggetto Socket mette il server in connessione diretta con il client, possiamo quindi accedere ai flussi di output e di input per scrivere e ricevere rispettivamente i messaggi da e verso il client:

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

From here onwards, the server is capable of exchanging messages with the client endlessly until the socket is closed with its streams.

However, in our example the server can only send a greeting response before it closes the connection, this means that if we ran our test again, the connection would be refused.

To allow continuity in communication, we will have to read from the input stream inside a while loop and only exit when the client sends a termination request, we will see this in action in the following section.

For every new client, the server needs a new socket returned by the accept call. The serverSocket is used to continue to listen for connection requests while tending to the needs of the connected clients. We have not allowed for this yet in our first example.

4.2. The Client

The client must know the hostname or IP of the machine on which the server is running and the port number on which the server is listening.

To make a connection request, the client tries to rendezvous with the server on the server's machine and port:

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

The client also needs to identify itself to the server so it binds to a local port number, assigned by the system, that it will use during this connection. We don't deal with this ourselves.

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.

Useremo ancora EchoClient per testare il server, questa volta creeremo più client che inviano e ricevono più messaggi dal server.

Avviamo il nostro server utilizzando il suo metodo principale sulla porta 5555 .

Per chiarezza, metteremo ancora i test in una nuova suite:

@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"); }

Potremmo creare quanti di questi casi di test vogliamo, ognuno generando un nuovo client e il server li servirà tutti.

7. Conclusione

In questo tutorial, ci siamo concentrati su un'introduzione alla programmazione socket su TCP / IP e abbiamo scritto una semplice applicazione client / server in Java.

Il codice sorgente completo dell'articolo può essere trovato, come al solito, nel progetto GitHub.