Carga de imágenes basada en el protocolo TCP

Introducción

En este proyecto, aprenderás a construir una aplicación simple de carga de imágenes utilizando el protocolo TCP. La aplicación consta de un cliente y un servidor, donde el cliente puede subir una imagen al servidor, y el servidor recibirá y almacenará la imagen.

👀 Vista previa

🎯 Tareas

En este proyecto, aprenderás:

• Cómo configurar un servidor para escuchar conexiones entrantes de clientes y recibir imágenes cargadas
• Cómo implementar un cliente para leer un archivo de imagen local y enviarlo al servidor
• Cómo manejar la comunicación entre el cliente y el servidor utilizando sockets TCP
• Cómo proporcionar retroalimentación al cliente tras la carga exitosa de la imagen

🏆 Logros

Después de completar este proyecto, podrás:

• Crear una arquitectura cliente-servidor utilizando Java
• Utilizar sockets TCP para la transferencia de archivos entre un cliente y un servidor
• Manejar operaciones de E/S de archivos en Java
• Implementar mecanismos básicos de manejo de errores y retroalimentación

Configurar el servidor

En este paso, aprenderás a configurar el servidor para recibir la imagen cargada.

1. Abra el archivo org/labex/service/UploadService.java en su editor de código.

2. En el método main(), cree un objeto ServerSocket para escuchar conexiones entrantes de clientes en el puerto 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)) {
            // Continuamente aceptar conexiones de clientes
            while (true) {
                // El servidor espera
                // Devuelve el Socket del cliente si hay una conexión
                Socket client = server.accept();
                InetAddress clientAddress = client.getInetAddress();
                // Recibir la imagen cargada del cliente
                // Flujo de entrada: Lee el flujo de archivo de imagen enviado por el cliente
                // Flujo de salida: Escribe en la imagen local
                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);) {

                    // Leer el flujo de archivo de imagen del cliente
                    // Escribir en el archivo local
                    byte[] buffer = new byte[1024];
                    int length = -1;
                    while ((length = bis.read(buffer))!= -1) {
                        bos.write(buffer, 0, length);
                    }

                    // Escribir mensaje al cliente
                    try (BufferedWriter writer = new BufferedWriter(
                            new OutputStreamWriter(client.getOutputStream()))) {
                        writer.write("Recepción Completa");
                        writer.newLine();
                    }
                }
            }

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

3. El servidor continuará aceptando conexiones de clientes y recibiendo la imagen cargada. La imagen recibida se almacenará en el archivo /home/labex/project/pic/mn.jpg.

4. Después de recibir la imagen, el servidor enviará un mensaje "Recepción Completa" al cliente.

Implementar el cliente

En este paso, aprenderás a implementar el cliente para subir una imagen al servidor.

1. Abra el archivo org/labex/client/UploadClient.java en su editor de código.

2. En el método main(), cree un objeto Socket para conectarse al servidor en 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: Componente para la comunicación del cliente
            // Leer imagen local => Enviar al servidor a través del flujo de salida
            // OutputStream: Envía el flujo de archivo de imagen local al servidor
            // BufferedInputStream: Lee la imagen local
            Socket client = new Socket("127.0.0.1", 10203);
            OutputStream out = client.getOutputStream();
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(
                    "/home/labex/project/timg.jpg"))
        ) {
            // Leer 1024 bytes cada vez
            byte[] buffer = new byte[1024];
            int length = -1;
            while ((length = in.read(buffer))!= -1) {
                // Enviar el contenido leído al servidor a través del flujo de salida
                out.write(buffer, 0, length);
            }
            // Fin temporal de "salida" (Socket no cerrado)
            client.shutdownOutput();

            // Leer la retroalimentación del servidor
            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. El cliente leerá el archivo de imagen local /home/labex/project/timg.jpg y lo enviará al servidor utilizando el flujo de salida del socket.

4. Después de enviar la imagen, el cliente leerá el mensaje de retroalimentación del servidor y lo imprimirá en la consola.

5. Si el servidor envía el mensaje "Recepción Completa", significa que la carga de la imagen fue exitosa.

Ahora, has completado la implementación tanto del servidor como del cliente. Puedes compilar y ejecutar los programas para probar la funcionalidad de carga de imágenes.

Ejecutar

Abra una terminal y ejecute el siguiente comando para compilar su programa de cliente y servidor:

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

Inicie el servidor para escuchar al cliente:

java org.labex.service.UploadService

Abra otra terminal para iniciar el cliente para subir la imagen, y obtendrá el mensaje: "Recepción Completa"

java org.labex.client.UploadClient

Verifique si la carpeta pic contiene la imagen o no:

ls pic

El efecto de ejecución es el siguiente:

Resumen

¡Felicidades! Has completado este proyecto. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.