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
%%%%{init: {'theme':'neutral'}}%%%%
flowchart RL
java(("Java")) -.-> java/FileandIOManagementGroup(["File and I/O Management"])
java(("Java")) -.-> java/ConcurrentandNetworkProgrammingGroup(["Concurrent and Network Programming"])
java/FileandIOManagementGroup -.-> java/files("Files")
java/FileandIOManagementGroup -.-> java/io("IO")
java/ConcurrentandNetworkProgrammingGroup -.-> java/net("Net")
subgraph Lab Skills
java/files -.-> lab-300368{{"Bildhochladen basierend auf TCP-Protokoll"}}
java/io -.-> lab-300368{{"Bildhochladen basierend auf TCP-Protokoll"}}
java/net -.-> lab-300368{{"Bildhochladen basierend auf TCP-Protokoll"}}
end
Server einrichten
In diesem Schritt lernst du, wie du den Server einrichtest, um das hochgeladene Bild zu empfangen.
Öffne die Datei org/labex/service/UploadService.java in deinem Code-Editor.
In der main()-Methode erstelle ein ServerSocket-Objekt, um auf eingehende Clientverbindungen am Port 10203 zu lauschen:
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();
}
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.
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.
Öffne die Datei org/labex/client/UploadClient.java in deinem Code-Editor.
In der main()-Methode erstelle ein Socket-Objekt, um sich an den Server unter 127.0.0.1:10203 zu verbinden:
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();
}
Der Client wird die lokale Bilddatei /home/labex/project/timg.jpg lesen und sie über den Ausgabestream des Sockets an den Server senden.
Nachdem das Bild gesendet wurde, wird der Client die Rückmeldungsnachricht vom Server lesen und sie in der Konsole ausgeben.
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:
We use cookies for a number of reasons, such as keeping the website reliable and secure, to improve your experience on our website and to see how you interact with it. By accepting, you agree to our use of such cookies. Privacy Policy