Upload de Imagens Baseado no Protocolo TCP

Introdução

Neste projeto, você aprenderá como construir uma aplicação simples de upload de imagens usando o protocolo TCP. A aplicação consiste em um cliente e um servidor, onde o cliente pode fazer upload de uma imagem para o servidor, e o servidor receberá e armazenará a imagem.

👀 Pré-visualização

🎯 Tarefas

Neste projeto, você aprenderá:

• Como configurar um servidor para ouvir conexões de clientes recebidas e receber imagens carregadas
• Como implementar um cliente para ler um arquivo de imagem local e enviá-lo para o servidor
• Como lidar com a comunicação entre o cliente e o servidor usando sockets TCP
• Como fornecer feedback ao cliente após o upload bem-sucedido da imagem

🏆 Conquistas

Após concluir este projeto, você será capaz de:

• Criar uma arquitetura cliente-servidor usando Java
• Usar sockets TCP para transferência de arquivos entre um cliente e um servidor
• Lidar com operações de I/O de arquivos em Java
• Implementar tratamento básico de erros e mecanismos de feedback

Configurar o Servidor

Nesta etapa, você aprenderá como configurar o servidor para receber a imagem carregada.

1. Abra o arquivo org/labex/service/UploadService.java no seu editor de código.

2. No método main(), crie um objeto ServerSocket para ouvir as conexões de clientes recebidas na porta 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 aceitar conexões de clientes
            while (true) {
                // Servidor espera
                // Retorna o Socket do cliente se houver uma conexão
                Socket client = server.accept();
                InetAddress clientAddress = client.getInetAddress();
                // Receber a imagem carregada do cliente
                // Fluxo de entrada: Lê o fluxo do arquivo de imagem enviado pelo cliente
                // Fluxo de saída: Escreve na imagem 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);) {

                    // Lê o fluxo do arquivo de imagem do cliente
                    // Escreve no arquivo local
                    byte[] buffer = new byte[1024];
                    int length = -1;
                    while ((length = bis.read(buffer)) != -1) {
                        bos.write(buffer, 0, length);
                    }

                    // Mensagem de saída para o cliente
                    try (BufferedWriter writer = new BufferedWriter(
                            new OutputStreamWriter(client.getOutputStream()))) {
                        writer.write("Reception Complete");
                        writer.newLine();
                    }
                }
            }

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

3. O servidor aceitará continuamente as conexões de clientes e receberá a imagem carregada. A imagem recebida será armazenada no arquivo /home/labex/project/pic/mn.jpg.

4. Após receber a imagem, o servidor enviará uma mensagem "Reception Complete" para o cliente.

Implementar o Cliente

Nesta etapa, você aprenderá como implementar o cliente para fazer upload de uma imagem para o servidor.

1. Abra o arquivo org/labex/client/UploadClient.java no seu editor de código.

2. No método main(), crie um objeto Socket para conectar ao servidor em 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 comunicação do cliente
            // Lendo imagem local => Enviando para o servidor via fluxo de saída
            // OutputStream: Envia o fluxo do arquivo de imagem local para o servidor
            // BufferedInputStream: Lê a imagem 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"))
        ) {
            // Lendo 1024 bytes a cada vez
            byte[] buffer = new byte[1024];
            int length = -1;
            while ((length = in.read(buffer)) != -1) {
                // Enviando o conteúdo lido para o servidor via fluxo de saída
                out.write(buffer, 0, length);
            }
            // Fim temporário da "saída" (Socket não fechado)
            client.shutdownOutput();

            // Lendo feedback do 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. O cliente lerá o arquivo de imagem local /home/labex/project/timg.jpg e o enviará para o servidor usando o fluxo de saída do socket.

4. Após enviar a imagem, o cliente lerá a mensagem de feedback do servidor e a imprimirá no console.

5. Se o servidor enviar a mensagem "Reception Complete", significa que o upload da imagem foi bem-sucedido.

Agora, você concluiu a implementação tanto do servidor quanto do cliente. Você pode compilar e executar os programas para testar a funcionalidade de upload de imagem.

Executar

Abra um terminal e execute o seguinte comando para compilar seu programa cliente e servidor:

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

Inicie o servidor para ouvir o cliente:

java org.labex.service.UploadService

Abra outro terminal para iniciar o cliente para fazer upload da imagem, e você receberá o prompt: "Reception Complete"

java org.labex.client.UploadClient

Verifique se a pasta pic contém a imagem ou não:

ls pic

O efeito da execução é o seguinte:

Resumo

Parabéns! Você concluiu este projeto. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.