Dans ce projet, vous allez apprendre à construire une application de téléchargement d'images simple utilisant le protocole TCP. L'application est composée d'un client et d'un serveur, où le client peut télécharger une image sur le serveur, et le serveur recevra et stockera l'image.
👀 Aperçu
🎯 Tâches
Dans ce projet, vous allez apprendre :
Comment configurer un serveur pour écouter les connexions clientes entrantes et recevoir les images téléchargées
Comment implémenter un client pour lire un fichier image local et l'envoyer au serveur
Comment gérer la communication entre le client et le serveur à l'aide de sockets TCP
Comment fournir des réponses au client lors d'un téléchargement d'image réussi
🏆 Réalisations
Après avoir terminé ce projet, vous serez capable de :
Créer une architecture client-serveur en Java
Utiliser des sockets TCP pour le transfert de fichiers entre un client et un serveur
Gérer les opérations d'entrée/sortie de fichiers en Java
Implémenter des mécanismes de gestion des erreurs de base et de réponses
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{{"Téléchargement d'images basé sur le protocole TCP"}}
java/io -.-> lab-300368{{"Téléchargement d'images basé sur le protocole TCP"}}
java/net -.-> lab-300368{{"Téléchargement d'images basé sur le protocole TCP"}}
end
Configurez le serveur
Dans cette étape, vous allez apprendre à configurer le serveur pour recevoir l'image téléchargée.
Ouvrez le fichier org/labex/service/UploadService.java dans votre éditeur de code.
Dans la méthode main(), créez un objet ServerSocket pour écouter les connexions clientes entrantes sur le port 10203 :
try (ServerSocket server = new ServerSocket(10203)) {
// Continuously accept client connections
while (true) {
// Le serveur attend
// Retourne le Socket du client s'il y a une connexion
Socket client = server.accept();
InetAddress clientAddress = client.getInetAddress();
// Receive the uploaded image from the client
// Flux d'entrée : Lit le flux de fichier d'image envoyé par le client
// Flux de sortie : Écrit dans l'image locale
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);) {
// Read the image file stream from the client
// Write to the local file
byte[] buffer = new byte[1024];
int length = -1;
while ((length = bis.read(buffer))!= -1) {
bos.write(buffer, 0, length);
}
// Output message to the client
try (BufferedWriter writer = new BufferedWriter(
new OutputStreamWriter(client.getOutputStream()))) {
writer.write("Reception Complete");
writer.newLine();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
Le serveur continuera d'accepter les connexions clientes et de recevoir l'image téléchargée. L'image reçue sera stockée dans le fichier /home/labex/project/pic/mn.jpg.
Après avoir reçu l'image, le serveur enverra un message "Reception Complete" au client.
Implémentez le client
Dans cette étape, vous allez apprendre à implémenter le client pour télécharger une image sur le serveur.
Ouvrez le fichier org/labex/client/UploadClient.java dans votre éditeur de code.
Dans la méthode main(), créez un objet Socket pour vous connecter au serveur à 127.0.0.1:10203 :
try (
// Socket : Composant de communication du client
// Lecture de l'image locale => Envoi au serveur via le flux de sortie
// OutputStream : Envoie le flux de fichier d'image locale au serveur
// BufferedInputStream : Lit l'image locale
Socket client = new Socket("127.0.0.1", 10203);
OutputStream out = client.getOutputStream();
BufferedInputStream in = new BufferedInputStream(new FileInputStream(
"/home/labex/project/timg.jpg"))
) {
// Lecture de 1024 octets à chaque fois
byte[] buffer = new byte[1024];
int length = -1;
while ((length = in.read(buffer))!= -1) {
// Envoi du contenu lu au serveur via le flux de sortie
out.write(buffer, 0, length);
}
// Fin temporaire de l'"envoi" (Socket non fermé)
client.shutdownOutput();
// Lecture des réponses du serveur
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();
}
Le client lira le fichier d'image local /home/labex/project/timg.jpg et l'envoyera au serveur en utilisant le flux de sortie du socket.
Après avoir envoyé l'image, le client lira le message de réponse du serveur et l'affichera dans la console.
Si le serveur envoie le message "Reception Complete", cela signifie que le téléchargement d'image a réussi.
Maintenant, vous avez terminé l'implémentation du serveur et du client. Vous pouvez compiler et exécuter les programmes pour tester la fonctionnalité de téléchargement d'image.
Exécution
Ouvrez un terminal et exécutez la commande suivante pour compiler votre programme client et serveur :
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