Bildhochladen basierend auf TCP-Protokoll

Einführung

In diesem Projekt lernst du, wie du eine einfache Bildhochladungsanwendung mit dem TCP-Protokoll aufbaust. Die Anwendung besteht aus einem Client und einem Server, wobei der Client ein Bild an den Server hochladen kann und der Server das Bild empfangen und speichern wird.

👀 Vorschau

🎯 Aufgaben

In diesem Projekt wirst du lernen:

• Wie du einen Server einrichtest, um eingehende Clientverbindungen zu empfangen und hochgeladene Bilder zu empfangen
• Wie du einen Client implementierst, um eine lokale Bilddatei zu lesen und an den Server zu senden
• Wie du die Kommunikation zwischen Client und Server mit TCP-Sockets behandelst
• Wie du dem Client eine Rückmeldung geben, wenn das Bild erfolgreich hochgeladen wurde

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

• Ein Server-Client-Architektur mit Java zu erstellen
• TCP-Sockets für den Dateiübertrag zwischen Client und Server zu verwenden
• Datei-E/A-Operationen in Java zu behandeln
• Grundlegende Fehlerbehandlung und Rückmeldemechanismen zu implementieren

Skills Graph

Server einrichten

In diesem Schritt lernst du, wie du den Server einrichtest, um das hochgeladene Bild zu empfangen.

1. Öffne die Datei org/labex/service/UploadService.java in deinem Code-Editor.

2. In der main()-Methode erstelle ein ServerSocket-Objekt, um auf eingehende Clientverbindungen am Port 10203 zu lauschen:

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

        try (ServerSocket server = new ServerSocket(10203)) {
            // Ständig Clientverbindungen akzeptieren
            while (true) {
                // Server wartet
                // Gibt das Socket des Clients zurück, wenn es eine Verbindung gibt
                Socket client = server.accept();
                InetAddress clientAddress = client.getInetAddress();
                // Empfange das hochgeladene Bild vom Client
                // Eingabestream: Liest den Bilddateistrom, der vom Client gesendet wird
                // Ausgabestream: Schreibt in das lokale Bild
                String name = "/home/labex/project/pic/mn.jpg";

                try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(name));
                     InputStream in = client.getInputStream();
                     BufferedInputStream bis = new BufferedInputStream(in);) {

                    // Lies den Bilddateistrom vom Client
                    // Schreibe in die lokale Datei
                    byte[] buffer = new byte[1024];
                    int length = -1;
                    while ((length = bis.read(buffer))!= -1) {
                        bos.write(buffer, 0, length);
                    }

                    // Ausgabe einer Nachricht an den Client
                    try (BufferedWriter writer = new BufferedWriter(
                            new OutputStreamWriter(client.getOutputStream()))) {
                        writer.write("Reception Complete");
                        writer.newLine();
                    }
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

3. Der Server wird ständig Clientverbindungen akzeptieren und das hochgeladene Bild empfangen. Das empfangene Bild wird in der Datei /home/labex/project/pic/mn.jpg gespeichert.

4. Nachdem das Bild empfangen wurde, sendet der Server eine "Reception Complete"-Nachricht an den Client.

Client implementieren

In diesem Schritt lernst du, wie du den Client implementierst, um ein Bild an den Server zu uploaden.

1. Öffne die Datei org/labex/client/UploadClient.java in deinem Code-Editor.

2. In der main()-Methode erstelle ein Socket-Objekt, um sich an den Server unter 127.0.0.1:10203 zu verbinden:

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

        try (
            // Socket: Komponente für die Clientkommunikation
            // Lesen des lokalen Bilds => Senden an den Server über den Ausgabestream
            // OutputStream: Sendet den lokalen Bilddateistrom an den Server
            // BufferedInputStream: Liest das lokale Bild
            Socket client = new Socket("127.0.0.1", 10203);
            OutputStream out = client.getOutputStream();
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(
                    "/home/labex/project/timg.jpg"))
        ) {
            // 1024 Bytes jeweils lesen
            byte[] buffer = new byte[1024];
            int length = -1;
            while ((length = in.read(buffer))!= -1) {
                // Das gelesene Inhalt senden an den Server über den Ausgabestream
                out.write(buffer, 0, length);
            }
            // Vorübergehender Abschluss der "Ausgabe" (Socket nicht geschlossen)
            client.shutdownOutput();

            // Lesen der Rückmeldung vom Server
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()))) {
                String reply = reader.readLine();
                System.out.println(reply);
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

3. Der Client wird die lokale Bilddatei /home/labex/project/timg.jpg lesen und sie über den Ausgabestream des Sockets an den Server senden.

4. Nachdem das Bild gesendet wurde, wird der Client die Rückmeldungsnachricht vom Server lesen und sie in der Konsole ausgeben.

5. Wenn der Server die "Reception Complete"-Nachricht sendet, bedeutet das, dass das Bildhochladen erfolgreich war.

Jetzt hast du die Implementierung sowohl des Servers als auch des Clients abgeschlossen. Du kannst die Programme kompilieren und ausführen, um die Bildhochladungsfunktionalität zu testen.

Ausführen

Öffne ein Terminal und führe den folgenden Befehl aus, um deinen Client- und Serverprogramm zu kompilieren:

javac org/labex/client/UploadClient.java
javac org/labex/service/UploadService.java

Starte den Server, um auf den Client zu lauschen:

java org.labex.service.UploadService

Öffne ein weiteres Terminal, um den Client zu starten, um das Bild zu uploaden, und du wirst die Aufforderung erhalten: "Reception Complete"

java org.labex.client.UploadClient

Prüfe, ob der pic-Ordner das Bild enthält:

ls pic

Das Ausführungsverhalten ist wie folgt:

Zusammenfassung

Herzlichen Glückwunsch! Du hast dieses Projekt abgeschlossen. Du kannst in LabEx weitere Übungen absolvieren, um deine Fähigkeiten zu verbessern.