COMPARTE ESTE ARTÍCULO

En este artículo, te presentaré un ejercicio práctico para crear un servidor HTTP en Java que permita a los usuarios registrarse con un nombre de usuario y una contraseña, y luego validarse mediante la URL generada para acceder a sus datos. Este ejercicio es similar al anterior, pero se enfoca en la creación y validación de usuarios, ofreciendo una experiencia completa de inicio de sesión y validación a través de una URL dinámica. Al final del artículo, también encontrarás la solución en Java.


Ejercicio: Implementación de un Servidor HTTP con Validación de Usuarios

Objetivo:

Desarrollar un servidor HTTP en Java que permita a los usuarios registrarse proporcionando un nombre de usuario y una contraseña. El servidor generará una URL única para cada usuario, que podrá ser utilizada para validar el acceso a sus datos. La URL incluirá una ruta generada aleatoriamente que, al ser accedida, permitirá al usuario ver sus datos registrados.

Requisitos:

  1. Puerto de Escucha: El servidor debe escuchar en el puerto 8083.
  2. Registro de Usuarios: Se debe poder registrar un usuario enviando su nombre de usuario y contraseña mediante una solicitud GET a la ruta /registrar.
  3. Manejo de Usuarios:
  • Generar un identificador de usuario aleatorio de 8 caracteres.
  • Generar una ruta aleatoria de 6 caracteres que formará parte de la URL única para validar al usuario.
  • Responder al cliente con la URL completa (por ejemplo, http://localhost:8083/abc123).
  1. Validación de Usuario:
  • Verificar si la ruta existe en el mapa de usuarios registrados.
  • Si existe, responder con los datos del usuario (nombre de usuario y contraseña).
  • Si no existe, responder con un mensaje de error 404 indicando que la página no se encontró.
  1. Concurrencia: El servidor debe ser capaz de manejar múltiples solicitudes simultáneamente utilizando hilos.

Ejemplo de Comportamiento Esperado:

  1. El cliente envía una solicitud GET a http://localhost:8083/registrar?usuario=nombreUsuario&password=miPassword.
  2. El servidor genera un identificador de usuario y una URL, por ejemplo, http://localhost:8083/xyz789, y la envía al cliente.
  3. El cliente muestra la URL y envía una solicitud GET a http://localhost:8083/xyz789.
  4. El servidor responde con los datos del usuario.
  5. Si se accede a una ruta no válida, el servidor responde con un mensaje de error 404.

Solución en Java

A continuación, se presenta la implementación del servidor HTTP en Java que cumple con los requisitos del ejercicio:

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;

public class ServidorHTTP {

    private static Map<String, Usuario> usuarios = new HashMap<>();

    public static void main(String[] args) throws IOException {
        HttpServer server = HttpServer.create(new InetSocketAddress(8083), 0);
        server.createContext("/registrar", new RegistrarHandler());
        server.createContext("/", new ValidarHandler());
        server.setExecutor(Executors.newCachedThreadPool()); // Manejo concurrente de solicitudes
        server.start();
        System.out.println("Servidor HTTP iniciado en el puerto 8083");
    }

    static class RegistrarHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            if ("GET".equals(exchange.getRequestMethod())) {
                // Obtener parámetros de la URL
                String query = exchange.getRequestURI().getQuery();
                Map<String, String> params = parseQuery(query);

                String nombreUsuario = params.get("usuario");
                String password = params.get("password");

                if (nombreUsuario == null || password == null) {
                    String respuesta = "Faltan parámetros: usuario o password";
                    exchange.sendResponseHeaders(400, respuesta.getBytes().length);
                    OutputStream os = exchange.getResponseBody();
                    os.write(respuesta.getBytes());
                    os.close();
                    return;
                }

                // Generar un identificador de usuario aleatorio de 8 caracteres
                String idUsuario = generarCodigoAleatorio(8);

                // Generar una ruta aleatoria de 6 caracteres
                String ruta = generarCodigoAleatorio(6);

                // Crear un nuevo usuario y almacenar la información
                Usuario usuario = new Usuario(nombreUsuario, password, idUsuario);
                usuarios.put(ruta, usuario);

                // Construir la URL
                String url = "http://localhost:8083/" + ruta;

                // Responder al cliente con la URL
                String respuesta = "Usuario registrado con éxito. Valida tu usuario aquí: " + url;
                exchange.sendResponseHeaders(200, respuesta.getBytes().length);
                OutputStream os = exchange.getResponseBody();
                os.write(respuesta.getBytes());
                os.close();
            } else {
                exchange.sendResponseHeaders(405, -1); // Método no permitido
            }
        }

        private String generarCodigoAleatorio(int longitud) {
            String caracteres = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
            Random random = new Random();
            StringBuilder sb = new StringBuilder(longitud);
            for (int i = 0; i < longitud; i++) {
                sb.append(caracteres.charAt(random.nextInt(caracteres.length())));
            }
            return sb.toString();
        }

        private Map<String, String> parseQuery(String query) {
            Map<String, String> result = new HashMap<>();
            if (query == null || query.isEmpty()) {
                return result;
            }

            String[] pairs = query.split("&");
            for (String pair : pairs) {
                String[] keyValue = pair.split("=");
                if (keyValue.length > 1) {
                    result.put(keyValue[0], keyValue[1]);
                }
            }
            return result;
        }
    }

    static class ValidarHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            String ruta = exchange.getRequestURI().getPath().substring(1);

            if (usuarios.containsKey(ruta)) {
                Usuario usuario = usuarios.get(ruta);
                String respuesta = "Usuario: " + usuario.getNombreUsuario() + "\nPassword: " + usuario.getPassword();
                exchange.sendResponseHeaders(200, respuesta.getBytes().length);
                OutputStream os = exchange.getResponseBody();
                os.write(respuesta.getBytes());
                os.close();
            } else {
                String respuesta = "404 Not Found";
                exchange.sendResponseHeaders(404, respuesta.getBytes().length);
                OutputStream os = exchange.getResponseBody();
                os.write(respuesta.getBytes());
                os.close();
            }
        }
    }

    static class Usuario {
        private String nombreUsuario;
        private String password;
        private String idUsuario;

        public Usuario(String nombreUsuario, String password, String idUsuario) {
            this.nombreUsuario = nombreUsuario;
            this.password = password;
            this.idUsuario = idUsuario;
        }

        public String getNombreUsuario() {
            return nombreUsuario;
        }

        public String getPassword() {
            return password;
        }

        public String getIdUsuario() {
            return idUsuario;
        }
    }
}

Explicación del Código:

  1. Configuración del Servidor:
  • El servidor se configura para escuchar en el puerto 8083 y manejar las solicitudes en las rutas /registrar y /.
  • Se utiliza un Executor para manejar múltiples solicitudes de manera concurrente.
  1. Registro de Usuarios:
  • En la clase RegistrarHandler, se procesa una solicitud GET que incluye los parámetros usuario y password.
  • Se genera un identificador de usuario de 8 caracteres y una ruta aleatoria de 6 caracteres, que se almacena en un HashMap junto con la información del usuario.
  1. Validación de Usuarios:
  • La clase ValidarHandler maneja las solicitudes GET a la ruta generada para cada usuario. Si la ruta existe en el mapa, se responde con los datos del usuario. Si no, se responde con un error 404.
  1. Clase Usuario:
  • Se crea una clase Usuario para almacenar la información del usuario, incluyendo el nombre de usuario, la contraseña y el identificador generado.
  1. Manejo de Parámetros:
  • Se incluye un método parseQuery para extraer los parámetros de la URL.

Este ejercicio y su solución en Java proporcionan una excelente práctica para aprender a manejar el registro y validación de usuarios en un servidor HTTP. La implementación demuestra cómo se pueden gestionar usuarios de manera segura y eficiente, con rutas dinámicas y control de acceso a través de URLs únicas. ¡Espero que encuentres este ejercicio útil y que disfrutes implementándolo!

… … …

¡Coméntanos que te ha parecido este artículo al final de la página!

TÚ OPINIÓN IMPORTA


NUESTRAS ÚLTIMAS PUBLICACIONES

Contenido restringido

Acceso de usuarios existentes
   
Registro de un nuevo usuario
*Campo necesario

Categories:

Tags:

Comments are closed

Estado de acceso
ESTADO DE ACCESO
TRADUCTORES
COMPARTENOS
error: CONTENIDO PROTEGIDO