Tutorial 20: Crear Datos con PDO Parte 1

 


¡Hola! En este tutorial vamos a empezar a conectar nuestro formulario de registro con la base de datos. El objetivo es que cuando un usuario llene el formulario y le dé a "Enviar", esa información viaje de manera segura hasta nuestro modelo, que es el encargado de hablar con la base de datos.

Imagina que estamos construyendo un edificio. Ya tenemos los planos (la base de datos) y ahora vamos a instalar la tubería por donde viajará la información. Esa tubería es PDO.

Paso 1: El Formulario (La Puerta de Entrada)

Primero, veamos nuestro formulario. Es la cara visible de nuestra aplicación, lo que el usuario ve y llena.

html
<h1>REGISTRO DE USUARIO</h1>

<form method="post">
    <input type="text" placeholder="Usuario" name="usuario" required>
    <input type="password" placeholder="Contraseña" name="password" required>
    <input type="email" placeholder="Email" name="email" required>
    <input type="submit" value="Enviar">
</form>

¿Qué es lo más importante aquí?

  1. method="post": Observa que no usamos method="get". ¿La diferencia? Cuando usas get, los datos del formulario se pegan en la URL (como cuando ves una dirección larga y complicada). Con post, los datos viajan "por dentro", de manera oculta. Es más seguro para cosas como contraseñas.

  2. name="...": Esto es CRUCIAL. El atributo name de cada campo (usuario, password, email) es como una etiqueta. Cuando el formulario se envía, PHP los reconoce y puede leer su contenido a través de $_POST["usuario"], $_POST["password"], etc. Sin el name, no podemos capturar lo que el usuario escribió.

  3. Sin action: Normalmente, el atributo action le dice al formulario a qué archivo debe ir. Al no ponerlo, le decimos que se envíe a sí mismo. Esto es parte de una buena práctica para que la lógica de envío esté en el mismo archivo que el formulario, haciendo más difícil que alguien malintencionado vea cómo procesamos los datos.

Paso 2: El Controlador (El Director de Orquesta)

Cuando el usuario hace clic en "Enviar", los datos viajan al servidor. El primer lugar al que llegan es al controlador. Piensa en el controlador como un director de orquesta: él no toca los instrumentos, pero le dice a cada músico (modelo) qué debe hacer.

Aquí tenemos nuestro controlador:

php
<?php
// Esto es parte de un archivo más grande, probablemente "controllers/controller.php"

class MvcController{

    # REGISTRO DE USUARIOS
    public function registroUsuarioController(){

        // El controlador recibe los datos del formulario a través de $_POST
        // Los organiza en un ARRAY para manejarlos más fácilmente.
        $datosController = array(
            "usuario"=>$_POST["usuario"],
            "password"=>$_POST["password"],
            "email"=>$_POST["email"]
        );

        // El controlador llama al modelo para que haga el trabajo pesado.
        // Le pasa dos cosas: los datos del usuario y el nombre de la tabla.
        $respuesta = Datos::registroUsuarioModel($datosController, "usuarios");

        // Finalmente, le muestra al usuario si todo salió bien o no.
        echo $respuesta;
    }
}
?>

Explicación paso a paso:

  1. public function registroUsuarioController(): Creamos una función pública, lo que significa que se puede llamar desde fuera de la clase.

  2. $datosController = array(...): Los datos vienen sueltos ($_POST["usuario"], $_POST["password"], etc.). Los metemos en una variable de tipo array para transportarlos todos juntos. Le ponemos nombres descriptivos a las posiciones (usuario, password, email) para no confundirnos.

  3. $respuesta = Datos::registroUsuarioModel(...): Aquí ocurre la magia. El controlador le dice a la clase Datos (que es nuestro modelo) que ejecute la función registroUsuarioModel. Usamos :: (dos puntos dobles) para llamar a esa función. Le pasamos dos "paquetes":

    • $datosController: El array con la información del usuario.

    • "usuarios": El nombre de la tabla de la base de datos donde queremos guardar la info.

  4. echo $respuesta;: El modelo hará su trabajo y nos devolverá un resultado (por ejemplo, "éxito" o "error"). El controlador toma ese resultado y se lo muestra al usuario en la pantalla.

Paso 3: El Modelo (El Albañil)

Ahora vamos al archivo del modelo (probablemente models/crud.php). El modelo es el que sabe cómo construir y ejecutar las órdenes en la base de datos. Es nuestro albañil.

php
<?php
// Incluimos la conexión a la base de datos para poder usarla.
require_once "models/conexion.php";

// La clase Datos "hereda" de la clase Conexion. Usamos "extends".
class Datos extends Conexion{

    # REGISTRO DE USUARIOS
    public function registroUsuarioModel($datosModel, $tabla){

        // Aquí es donde empezaremos a construir la consulta SQL...
        // Lo veremos en la Parte 2.

    }
}
?>

¿Qué pasa aquí?

  1. require_once "models/conexion.php": Primero, necesitamos los planos de la conexión a la base de datos. Este archivo tiene la clase Conexion que sabe cómo conectarse.

  2. class Datos extends Conexion: Aquí usamos la palabra clave extends. Esto significa que la clase Datos es una "clase hija" de la clase Conexion (la "clase padre").

    • ¿Para qué sirve extends? Para heredar. La clase Datos hereda todas las propiedades y métodos (funciones) de la clase Conexion. En concreto, queremos heredar el método conectar() que está en Conexion. Al heredar, podemos usar conectar() dentro de Datos como si fuera nuestro.

  3. public function registroUsuarioModel($datosModel, $tabla): Esta función recibe los dos paquetes que le envió el controlador:

    • $datosModel: Que es el array con el usuario, contraseña y email.

    • $tabla: Que es el string "usuarios".

  4. $stmt = Conexion::conectar()->prepare(...): Este es el siguiente paso, que veremos en la Parte 2. Por ahora, solo recuerda que prepare() es un método de PDO que nos ayuda a preparar la consulta SQL de forma segura para evitar que hackers maliciosos la modifiquen (esto se llama inyección SQL).

Paso 4: Juntándolo Todo en la Vista

Finalmente, en nuestro archivo de vista (donde está el formulario HTML), tenemos que llamar al controlador para que todo se active.

html
<!-- ... (el formulario HTML de arriba) ... -->

<?php
// Aquí abajo del formulario, creamos un objeto de la clase MvcController
$registro = new MvcController();
// Y le decimos a ese objeto que ejecute la función de registro
$registro -> registroUsuarioController();
?>

¿Cómo funciona esto?

  1. El usuario ve el formulario y lo llena.

  2. Hace clic en "Enviar".

  3. La página se recarga y se ejecuta el código PHP de abajo.

  4. Se crea el objeto $registro de la clase MvcController.

  5. Se ejecuta la función registroUsuarioController(), que ya vimos que recoge los datos del $_POST y llama al modelo.

  6. ¡El proceso ha comenzado!

Resumen de la Parte 1

Hoy hemos visto el "viaje" de los datos desde que el usuario los escribe hasta que llegan a las puertas de la base de datos.

  1. El Formulario captura los datos con method="post" y los etiqueta con el atributo name.

  2. El Controlador recibe los datos, los organiza en un array y llama al modelo para que los procese.

  3. El Modelo se prepara para recibir la orden. Ya tiene la conexión a la base de datos gracias a extends y está listo para construir la consulta SQL con PDO.

En la Parte 2, veremos exactamente qué va dentro de esa función del modelo (registroUsuarioModel) para usar prepare() y execute() y así, finalmente, guardar los datos en la base de datos. ¡No te lo pierdas

Comentarios

Publicar un comentario

Entradas más populares de este blog

token

  ¿Qué es un token? Un  token  es una cadena de caracteres que representa información específica, como credenciales de acceso, identificadores únicos o datos de sesión. Se utilizan comúnmente en: Autenticación y autorización (JWT, tokens de acceso) Protección CSRF (Cross-Site Request Forgery) Identificación única de recursos Contraseñas de un solo uso Ejemplo pequeño en PHP: Token de autenticación simple php <?php // Función para generar un token aleatorio function generarToken ( $longitud = 32 ) { return bin2hex ( random_bytes ( $longitud ) ) ; } // Generar un token $token = generarToken ( ) ; echo "Token generado: " . $token . "\n\n" ; // Simular verificación del token (en una aplicación real se guardaría en base de datos) function verificarToken ( $tokenAlmacenado , $tokenRecibido ) { return hash_equals ( $tokenAlmacenado , $tokenRecibido ) ; } // Ejemplo de uso $tokenAlmacenado = $token ; // En la práctica, esto ven...
Leer más

¿Qué es un token y cómo se utiliza en una API?

  ¿Qué es un token y cómo se utiliza en una API? ¿Qué es un token? Un  token  es una cadena de caracteres que actúa como credencial de acceso para autenticar y autorizar a un usuario o aplicación en una API. Funciona como una "llave digital" que permite acceder a recursos protegidos sin necesidad de compartir credenciales sensibles como usuario y contraseña en cada solicitud. Tipos comunes de tokens: JWT (JSON Web Token) : Token auto-contenido con información codificada Access Token : Para acceso a recursos Refresh Token : Para renovar access tokens expirados API Key : Clave simple de identificación Ejemplo con PHP usando JWT 1. Instalación de dependencias bash composer require firebase/php-jwt 2. Generar un token JWT php <?php require 'vendor/autoload.php' ; use Firebase \ JWT \ JWT ; use Firebase \ JWT \ Key ; class TokenManager { private $secretKey = "tu_clave_secreta_muy_segura" ; private $algorithm = 'HS256' ; ...
Leer más

Generación de Credenciales API

   Generación de Credenciales API Método 1: Credenciales básicas (API Key + Secret) php <?php // Generar credenciales seguras function generarCredencialesAPI ( ) { $api_key = bin2hex ( random_bytes ( 32 ) ) ; // 64 caracteres hexadecimales $api_secret = bin2hex ( random_bytes ( 64 ) ) ; // 128 caracteres hexadecimales return [ 'api_key' => $api_key , 'api_secret' => password_hash ( $api_secret , PASSWORD_DEFAULT ) ] ; } // Generar y guardar credenciales $credenciales = generarCredencialesAPI ( ) ; // Guardar en base de datos (ejemplo) // INSERT INTO api_credentials (api_key, api_secret_hash, created_at) // VALUES (:api_key, :api_secret, NOW()) ?> Método 2: Credenciales JWT php <?php use Firebase \ JWT \ JWT ; use Firebase \ JWT \ Key ; class JWTCredentials { private $secret_key ; public function __construct ( ) { $this -> secret_key = bin2hex ( r...
Leer más