Téléchargement d'images basé sur le protocole TCP

Introduction

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

Configurer le serveur

Dans cette étape, vous allez apprendre à configurer le serveur pour recevoir l'image téléchargée.

1. Ouvrez le fichier org/labex/service/UploadService.java dans votre éditeur de code.

2. Dans la méthode main(), créez un objet ServerSocket pour écouter les connexions clientes entrantes sur le port 10203 :

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

3. 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.

4. 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.

1. Ouvrez le fichier org/labex/client/UploadClient.java dans votre éditeur de code.

2. Dans la méthode main(), créez un objet Socket pour vous connecter au serveur à 127.0.0.1:10203 :

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

3. 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.

4. Après avoir envoyé l'image, le client lira le message de réponse du serveur et l'affichera dans la console.

5. 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 :

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

Démarrez le serveur pour écouter le client :

java org.labex.service.UploadService

Ouvrez un autre terminal pour démarrer le client pour télécharger l'image, et vous obtiendrez l'invite : "Reception Complete"

java org.labex.client.UploadClient

Vérifiez si le dossier pic contient l'image ou non :

ls pic

L'effet de l'exécution est le suivant :

Résumé

Félicitations ! Vous avez terminé ce projet. Vous pouvez pratiquer plus de laboratoires sur LabEx pour améliorer vos compétences.