Eine Anleitung zu Java Sockets

1. Übersicht

Der Begriff Socket- Programmierung bezieht sich auf das Schreiben von Programmen, die auf mehreren Computern ausgeführt werden, auf denen alle Geräte über ein Netzwerk miteinander verbunden sind.

Es gibt zwei Kommunikationsprotokolle, die für die Socket-Programmierung verwendet werden können: User Datagram Protocol (UDP) und Transfer Control Protocol (TCP) .

Der Hauptunterschied zwischen beiden besteht darin, dass UDP verbindungslos ist, dh es gibt keine Sitzung zwischen dem Client und dem Server, während TCP verbindungsorientiert ist. Dies bedeutet, dass zuerst eine exklusive Verbindung zwischen Client und Server hergestellt werden muss, damit die Kommunikation stattfinden kann.

Dieses Tutorial enthält eine Einführung in die Socket-Programmierung über TCP / IP- Netzwerke und zeigt, wie Client / Server-Anwendungen in Java geschrieben werden. UDP ist kein Mainstream-Protokoll und kann daher nicht häufig vorkommen.

2. Projekteinrichtung

Java bietet eine Sammlung von Klassen und Schnittstellen, die sich um Kommunikationsdetails auf niedriger Ebene zwischen dem Client und dem Server kümmern.

Diese sind meistens im java.net- Paket enthalten, daher müssen wir den folgenden Import durchführen:

import java.net.*;

Wir benötigen auch das Paket java.io , das uns Eingabe- und Ausgabestreams zum Schreiben und Lesen während der Kommunikation bietet:

import java.io.*;

Der Einfachheit halber führen wir unsere Client- und Serverprogramme auf demselben Computer aus. Wenn wir sie auf verschiedenen Netzwerkcomputern ausführen würden, würde sich nur die IP-Adresse ändern. In diesem Fall verwenden wir localhost unter 127.0.0.1 .

3. Einfaches Beispiel

Lassen Sie uns mit den grundlegendsten Beispielen, die einen Client und einen Server betreffen, die Hände schmutzig machen . Es wird eine bidirektionale Kommunikationsanwendung sein, bei der der Client den Server begrüßt und der Server antwortet.

Erstellen wir die Serveranwendung in einer Klasse namens GreetServer.java mit dem folgenden Code.

Wir sind das Hauptverfahren und die globalen Variablen aufmerksam zu machen , wie wir alle Server in diesem Artikel ausgeführt werden. In den restlichen Beispielen in den Artikeln werden wir diese Art von sich wiederholendem Code weglassen:

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

Erstellen wir mit diesem Code auch einen Client namens GreetClient.java :

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

Starten wir den Server. In Ihrer IDE führen Sie dies einfach aus, indem Sie es als Java-Anwendung ausführen.

Und jetzt senden wir eine Begrüßung mit einem Komponententest an den Server, der bestätigt, dass der Server tatsächlich eine Begrüßung als Antwort sendet:

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

Machen Sie sich keine Sorgen, wenn Sie nicht ganz verstehen, was hier passiert, denn dieses Beispiel soll uns ein Gefühl dafür geben, was uns später in diesem Artikel erwartet.

In den folgenden Abschnitten werden wir die Socket-Kommunikation anhand dieses einfachen Beispiels analysieren und mit weiteren Beispielen tiefer in die Details eintauchen.

4. Wie Steckdosen funktionieren

Wir werden das obige Beispiel verwenden, um verschiedene Teile dieses Abschnitts durchzugehen.

Per Definition ist ein Socket ein Endpunkt einer bidirektionalen Kommunikationsverbindung zwischen zwei Programmen, die auf verschiedenen Computern in einem Netzwerk ausgeführt werden. Ein Socket ist an eine Portnummer gebunden, damit die Transportschicht die Anwendung identifizieren kann, an die Daten gesendet werden sollen.

4.1. Der Kellner

Normalerweise läuft ein Server auf einem bestimmten Computer im Netzwerk und verfügt über einen Socket, der an eine bestimmte Portnummer gebunden ist. In unserem Fall verwenden wir denselben Computer wie der Client und haben den Server an Port 6666 gestartet :

ServerSocket serverSocket = new ServerSocket(6666);

Der Server wartet nur und wartet auf den Socket, bis ein Client eine Verbindungsanforderung stellt. Dies geschieht im nächsten Schritt:

Socket clientSocket = serverSocket.accept();

Wenn der Servercode auf die Methode accept trifft , wird er blockiert, bis ein Client eine Verbindungsanforderung an ihn stellt.

Wenn alles gut geht, akzeptiert der Server die Verbindung. Bei der Annahme erhält der Server einen neuen Socket, clientSocket , der an denselben lokalen Port 6666 gebunden ist , und dessen Remote-Endpunkt auf die Adresse und den Port des Clients festgelegt ist.

Zu diesem Zeitpunkt stellt das neue Socket- Objekt den Server in direkte Verbindung mit dem Client. Anschließend können wir auf die Ausgabe- und Eingabestreams zugreifen, um Nachrichten zum bzw. vom Client zu schreiben und zu empfangen:

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

Ab hier kann der Server endlos Nachrichten mit dem Client austauschen, bis der Socket mit seinen Streams geschlossen ist.

In unserem Beispiel kann der Server jedoch nur eine Begrüßungsantwort senden, bevor die Verbindung geschlossen wird. Dies bedeutet, dass die Verbindung abgelehnt wird, wenn wir unseren Test erneut ausführen.

Um Kontinuität in der Kommunikation zu ermöglichen, müssen wir innerhalb einer while- Schleife aus dem Eingabestream lesen und erst beenden, wenn der Client eine Beendigungsanforderung sendet. Dies wird im folgenden Abschnitt in Aktion gesehen.

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.

Wir werden weiterhin EchoClient verwenden , um den Server zu testen. Dieses Mal werden wir mehrere Clients erstellen, die jeweils mehrere Nachrichten vom Server senden und empfangen.

Starten wir unseren Server mit seiner Hauptmethode an Port 5555 .

Aus Gründen der Klarheit werden wir weiterhin Tests in einer neuen Suite durchführen:

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

Wir können so viele dieser Testfälle erstellen, wie wir möchten, wobei jeder einen neuen Client hervorbringt und der Server alle von ihnen bedient.

7. Fazit

In diesem Tutorial haben wir uns auf eine Einführung in die Socket-Programmierung über TCP / IP konzentriert und eine einfache Client / Server-Anwendung in Java geschrieben.

Den vollständigen Quellcode für den Artikel finden Sie wie gewohnt im GitHub-Projekt.