Netzwerkprogrammierung in Java: Von Sockets bis NIO und WebSockets

Warum ist Netzwerkprogrammierung in Java eine Superkraft?

Stellen Sie sich vor: Sie schreiben Code, und plötzlich beginnt Ihr Programm mit einem anderen Programm auf der anderen Seite der Welt zu kommunizieren. Es sendet Anfragen, empfängt Antworten, synchronisiert Daten – und das alles in Millisekunden. Das ist keine Magie, das ist Netzwerkprogrammierung in Java. Wenn Sie nicht nur lokale Dienstprogramme, sondern echte verteilte Systeme, Chats, Online-Spiele oder REST-Dienste erstellen möchten – ohne Netzwerkprogrammierung geht es nicht.

Java bietet dafür ein leistungsstarkes Toolkit: von klassischen Socket und ServerSocket bis hin zu leistungsstarkem Java NIO (Non-blocking I/O) und modernen WebSockets. In diesem Artikel werden wir alle drei Ansätze durchgehen, Live-Code schreiben und verstehen, wie Sie das richtige Werkzeug für Ihre Aufgabe auswählen. Los geht's!

1. Klassische Sockets: Ein TCP-Chat „mal schnell“

Beginnen wir mit den Grundlagen. Sockets in Java sind der Einstiegspunkt in die Welt von TCP/IP. Der Server erstellt einen ServerSocket, horcht auf einem Port und nimmt Verbindungen an. Der Client erstellt einen Socket und verbindet sich mit dem Server. So einfach wie das Einmaleins.

Einen einfachen Echo-Server schreiben

Der Server empfängt eine Nachricht vom Client und sendet sie zurück (Echo). Der Code ist minimal, veranschaulicht aber das gesamte Konzept:

import java.io.*;import java.net.*;

public class EchoServer {    public static void main(String[] args) {        try (ServerSocket serverSocket = new ServerSocket(12345)) {            System.out.println("Server gestartet auf Port 12345...");            Socket clientSocket = serverSocket.accept(); // blockiert bis zur Verbindung            System.out.println("Client verbunden: " + clientSocket.getInetAddress());

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

            String inputLine;            while ((inputLine = in.readLine()) != null) {                System.out.println("Empfangen: " + inputLine);                out.println("Echo: " + inputLine);                if (inputLine.equalsIgnoreCase("exit")) break;            }        } catch (IOException e) {            e.printStackTrace();        }    }}

Und hier der Client, der Nachrichten sendet:

import java.io.*;import java.net.*;

public class EchoClient {    public static void main(String[] args) throws IOException {        Socket socket = new Socket("localhost", 12345);        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);        BufferedReader in = new BufferedReader(            new InputStreamReader(socket.getInputStream()));        BufferedReader stdIn = new BufferedReader(            new InputStreamReader(System.in));

        String userInput;        System.out.println("Geben Sie eine Nachricht ein (exit zum Beenden):");        while ((userInput = stdIn.readLine()) != null) {            out.println(userInput);            System.out.println("Serverantwort: " + in.readLine());            if (userInput.equalsIgnoreCase("exit")) break;        }        socket.close();    }}

Was ist hier wichtig? Die Methoden accept() und readLine() blockieren den Thread. Das bedeutet, dass während ein Client kommuniziert, andere warten müssen. Die Lösung ist Multithreading.

Multithread-Server: Mehrere Clients verarbeiten

Für jede neue Verbindung erstellen wir einen separaten Thread. Wir verwenden einen Thread-Pool ExecutorService, um nicht unnötig Tausende von Threads zu erzeugen:

import java.io.*;import java.net.*;import java.util.concurrent.*;

public class MultiThreadedServer {    private static final int PORT = 12345;    private static final ExecutorService threadPool = Executors.newFixe