Un guide des sockets Java

1. Vue d'ensemble

Le terme programmation de socket fait référence à l'écriture de programmes qui s'exécutent sur plusieurs ordinateurs dans lesquels les périphériques sont tous connectés les uns aux autres à l'aide d'un réseau.

Il existe deux protocoles de communication que l'on peut utiliser pour la programmation de socket: User Datagram Protocol (UDP) et Transfer Control Protocol (TCP) .

La principale différence entre les deux est que UDP est sans connexion, ce qui signifie qu'il n'y a pas de session entre le client et le serveur tandis que TCP est orienté connexion, ce qui signifie qu'une connexion exclusive doit d'abord être établie entre le client et le serveur pour que la communication ait lieu.

Ce didacticiel présente une introduction à la programmation de sockets sur des réseaux TCP / IP et montre comment écrire des applications client / serveur en Java. UDP n'est pas un protocole courant et, en tant que tel, peut ne pas être souvent rencontré.

2. Configuration du projet

Java fournit une collection de classes et d'interfaces qui prennent en charge les détails de communication de bas niveau entre le client et le serveur.

Ceux-ci sont principalement contenus dans le package java.net , nous devons donc effectuer l'importation suivante:

import java.net.*;

Nous avons également besoin du package java.io qui nous donne des flux d'entrée et de sortie pour écrire et lire tout en communiquant:

import java.io.*;

Par souci de simplicité, nous exécuterons nos programmes client et serveur sur le même ordinateur. Si nous devions les exécuter sur différents ordinateurs en réseau, la seule chose qui changerait est l'adresse IP, dans ce cas, nous utiliserons localhost sur 127.0.0.1 .

3. Exemple simple

Mettons la main à la pâte avec les exemples les plus élémentaires impliquant un client et un serveur . Ce sera une application de communication bidirectionnelle où le client salue le serveur et le serveur répond.

Créons l'application serveur dans une classe appelée GreetServer.java avec le code suivant.

Nous incluons la méthode principale et les variables globales pour attirer l'attention sur la façon dont nous exécuterons tous les serveurs dans cet article. Dans le reste des exemples des articles, nous omettons ce type de code plus répétitif:

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

Créons également un client appelé GreetClient.java avec ce code:

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

Commençons le serveur; dans votre IDE, vous faites cela en l'exécutant simplement comme une application Java.

Et maintenant, envoyons un message d'accueil au serveur à l'aide d'un test unitaire, qui confirme que le serveur envoie réellement un message d'accueil en réponse:

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

Ne vous inquiétez pas si vous ne comprenez pas entièrement ce qui se passe ici, car cet exemple est destiné à nous donner une idée de ce à quoi nous attendre plus tard dans l'article.

Dans les sections suivantes, nous allons disséquer la communication socket à l' aide de cet exemple simple et approfondir les détails avec plus d'exemples.

4. Comment fonctionnent les sockets

Nous utiliserons l'exemple ci-dessus pour parcourir les différentes parties de cette section.

Par définition, une socket est l'un des points de terminaison d'une liaison de communication bidirectionnelle entre deux programmes s'exécutant sur différents ordinateurs d'un réseau. Un socket est lié à un numéro de port afin que la couche de transport puisse identifier l'application à laquelle les données sont destinées à être envoyées.

4.1. Le serveur

En général, un serveur s'exécute sur un ordinateur spécifique du réseau et possède un socket lié à un numéro de port spécifique. Dans notre cas, nous utilisons le même ordinateur que le client et avons démarré le serveur sur le port 6666 :

ServerSocket serverSocket = new ServerSocket(6666);

Le serveur attend juste, écoutant le socket qu'un client fasse une demande de connexion. Cela se produit à l'étape suivante:

Socket clientSocket = serverSocket.accept();

Lorsque le code serveur rencontre la méthode accept , il se bloque jusqu'à ce qu'un client lui fasse une demande de connexion.

Si tout se passe bien, le serveur accepte la connexion. Lors de l'acceptation, le serveur obtient un nouveau socket, clientSocket , lié au même port local, 6666 , et son point de terminaison distant est également défini sur l'adresse et le port du client.

À ce stade, le nouvel objet Socket met le serveur en connexion directe avec le client, nous pouvons alors accéder aux flux de sortie et d'entrée pour écrire et recevoir des messages vers et depuis le client respectivement:

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

A partir de là, le serveur est capable d'échanger des messages avec le client à l'infini jusqu'à ce que le socket soit fermé avec ses flux.

Cependant, dans notre exemple, le serveur ne peut envoyer qu'une réponse de bienvenue avant de fermer la connexion, cela signifie que si nous réexécutions notre test, la connexion serait refusée.

Pour assurer la continuité de la communication, nous devrons lire à partir du flux d'entrée dans un tout en boucle et la sortie que lorsque le client envoie une demande de résiliation, nous verrons cela en action dans la section suivante.

Pour chaque nouveau client, le serveur a besoin d'un nouveau socket renvoyé par l' appel d' acceptation . Le serverSocket est utilisé pour continuer à écouter les demandes de connexion tout en répondant aux besoins des clients connectés. Nous ne l'avons pas encore autorisé dans notre premier exemple.

4.2. Le client

Le client doit connaître le nom d'hôte ou l'adresse IP de la machine sur laquelle le serveur s'exécute et le numéro de port sur lequel le serveur écoute.

Pour faire une demande de connexion, le client essaie de se rendre avec le serveur sur la machine et le port du serveur:

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

Le client doit également s'identifier auprès du serveur afin qu'il se lie à un numéro de port local, attribué par le système, qu'il utilisera lors de cette connexion. Nous ne traitons pas cela nous-mêmes.

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.

Nous utiliserons toujours EchoClient pour tester le serveur, cette fois nous créerons plusieurs clients chacun envoyant et recevant plusieurs messages du serveur.

Commençons notre serveur en utilisant sa méthode principale sur le port 5555 .

Pour plus de clarté, nous allons tout de même mettre les tests dans une nouvelle 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"); }

Nous pourrions créer autant de ces cas de test que nous le souhaitons, chacun engendrant un nouveau client et le serveur les desservira tous.

7. Conclusion

Dans ce didacticiel, nous nous sommes concentrés sur une introduction à la programmation de sockets sur TCP / IP et avons écrit une simple application client / serveur en Java.

Le code source complet de l'article se trouve - comme d'habitude - dans le projet GitHub.