15-Aplicando el Patrón MVC en PHP - Parte 3: Integrando el Modelo y Completando el Ciclo

 


En la Parte 2, logramos que nuestro controlador interpretara la variable action de la URL y le dijera a la plantilla qué módulo de contenido incluir. Pero, ¿quién tiene la lógica para decidir cómo se debe mostrar ese contenido? ¿Y si en lugar de archivos HTML estáticos, quisieramos mostrar datos de una base de datos?

La respuesta es el Modelo. Es la capa encargada de toda la lógica de negocio y el acceso a los datos. En esta parte, vamos a:

  1. Entender el flujo completo de una petición en MVC.

  2. Crear una clase Modelo que contenga la lógica para seleccionar la vista correcta.

  3. Hacer que el Controlador se comunique con el Modelo para obtener la respuesta adecuada.

  4. Refinar nuestro código para que sea más claro y profesional.

El Flujo Completo de una Petición

Imaginemos que un usuario hace clic en el enlace "Nosotros". Esto es lo que sucede en una aplicación MVC bien construida:

  1. El Usuario (Navegador): Envía una petición a través de la URL: index.php?action=nosotros.

  2. El Front Controller (index.php): Es el único punto de entrada. Recibe la petición y llama al Controlador correspondiente.

  3. El Controlador (controller.php): Recibe la petición, la procesa (por ejemplo, sanitiza la variable action) y se la pasa al Modelo para que haga el trabajo pesado. Le dice: "Modelo, necesito la lógica para mostrar la página 'nosotros'".

  4. El Modelo (model.php): Contiene la lógica. Aquí es donde se decide qué archivo incluir, o más adelante, cómo consultar una base de datos. El modelo procesa la petición y le devuelve una respuesta al controlador (ej. la ruta del archivo a incluir, o un array de datos).

  5. El Controlador (de nuevo): Recibe la respuesta del Modelo y se la pasa a la Vista (plantilla).

  6. La Vista (template.php): Toma la respuesta (por ejemplo, la ruta de un módulo) y la muestra al usuario.

Nuestro objetivo en esta parte es conectar los pasos 3, 4 y 5.

Paso 1: Preparando el Escenario

Antes de empezar a codificar, asegurémonos de que tenemos la estructura correcta.

  1. index.php (Front Controller): Debe requerir tanto el controlador como el modelo, e invocar el método que muestra la plantilla.

    php
    <?php
// index.php
require_once "controllers/controller.php";
require_once "models/model.php";

$mvc = new MvcController();
$mvc->plantilla(); // Llama al método que carga la plantilla
?>

  2. views/modules/navegacion.php (Vista - Menú): Asegúrate de que todos los enlaces tengan la variable action con los valores correctos (inicio, nosotros, servicios, contactenos).

    php
    <nav>
    <ul>
        <li><a href="index.php?action=inicio">Inicio</a></li>
        <li><a href="index.php?action=nosotros">Nosotros</a></li>
        <li><a href="index.php?action=servicios">Servicios</a></li>
        <li><a href="index.php?action=contactenos">Contáctenos</a></li>
    </ul>
</nav>

  3. views/template.php (Vista - Plantilla): Por ahora, tendrá una línea para mostrar el resultado de nuestro controlador (esto lo cambiaremos después).

    php
    <!DOCTYPE html>
<html>
<head> <title>Mi Sitio MVC</title> </head>
<body>
    <header><h1>LOGOTIPO</h1></header>
    <?php include "modules/navegacion.php"; ?>
    <section>
        <?php
        // Aquí llamaremos al controlador para que muestre el contenido
        $mvc = new MvcController();
        $mvc->enlacesPaginasController();
        ?>
    </section>
</body>
</html>

Paso 2: El Controlador Recibe la Petición (controller.php)

Ahora, vamos a modificar nuestro controller.php para que tenga un método que capture la variable action.

php
<?php
// controllers/controller.php

class MvcController {

    // --- BLOQUE 1: LLAMADA A LA PLANTILLA ---
    public function plantilla() {
        include "views/template.php";
    }

    // --- BLOQUE 2: INTERACCIÓN DEL USUARIO ---
    public function enlacesPaginasController() {
        // 1. Recibir lo que el usuario envía a través de la URL (variable GET)
        if (isset($_GET["action"])) {
            $enlacesController = $_GET["action"];
        } else {
            // Si no hay acción, mostramos 'inicio' por defecto
            $enlacesController = "inicio";
        }

        // 2. Mostrar el resultado para verificar que funciona
        echo $enlacesController;
    }
}
?>

¿Qué hemos hecho?

  • Hemos creado el método enlacesPaginasController().

  • Dentro de él, capturamos el valor de $_GET["action"] y lo guardamos en $enlacesController. Usamos isset() para evitar errores si la variable no existe.

  • Por ahora, solo hacemos un echo para ver que recibimos "inicio", "nosotros", etc., en nuestra plantilla.

Si pruebas tu aplicación y haces clic en los enlaces, verás que en la sección <section> de la página aparece la palabra "inicio", "nosotros", etc. ¡El controlador ya está recibiendo la petición!

Paso 3: El Modelo Procesa la Lógica (models/model.php)

El controlador no debería tomar decisiones sobre qué archivo incluir. Esa es responsabilidad del Modelo. Vamos a crear la clase que hará este trabajo.

Crea el archivo models/model.php:

php
<?php
// models/model.php

class EnlacesPaginas {

    // Este método recibe el parámetro enviado desde el controlador
    public function enlacesPaginasModel($enlacesModel) {

        // Lógica: Si el valor coincide con el nombre de una página...
        if ($enlacesModel == "inicio" ||
            $enlacesModel == "nosotros" ||
            $enlacesModel == "servicios" ||
            $enlacesModel == "contactenos") {

            // ... entonces, construimos la ruta al módulo correspondiente
            $modulo = "views/modules/" . $enlacesModel . ".php";
        }

        // Devolvemos la ruta del módulo
        return $modulo;
    }
}
?>

¿Qué hemos hecho aquí?

  • Hemos creado la clase EnlacesPaginas.

  • Definimos el método enlacesPaginasModel($enlacesModel). La variable $enlacesModel recibirá el valor que le enviemos (ej. "nosotros").

  • Dentro del método, usamos una condición para validar que el valor recibido sea uno de los permitidos.

  • Si es válido, construimos la ruta completa al archivo dentro de la carpeta modules.

  • Finalmente, usamos return $modulo para devolver esa ruta al lugar desde donde fue llamado (el controlador). Esto es mucho mejor que usar echo, porque ahora podemos asignar el resultado a una variable.

Paso 4: El Controlador se Conecta con el Modelo (controller.php)

Ahora vamos a modificar el controlador para que, en lugar de hacer un echo, le pase el valor al modelo, reciba el resultado (la ruta del módulo), y se lo pase a la plantilla para que la incluya.

Actualiza controllers/controller.php:

php
<?php
// controllers/controller.php

class MvcController {

    public function plantilla() {
        include "views/template.php";
    }

    public function enlacesPaginasController() {
        if (isset($_GET["action"])) {
            $enlacesController = $_GET["action"];
        } else {
            $enlacesController = "inicio";
        }

        // --- NUEVO: Conexión con el Modelo ---
        // Llamamos a la clase del modelo y a su método.
        // Usamos '::' (Scope Resolution Operator) para acceder al método de la clase.
        // Pasamos la variable $enlacesController como parámetro al método del modelo.
        $respuesta = EnlacesPaginas::enlacesPaginasModel($enlacesController);

        // --- Incluir el módulo en la vista ---
        // 'include' se usa para mostrar el contenido del archivo.
        include $respuesta;
    }
}
?>

Paso 5: Refinando la Plantilla (template.php)

Notarás que en template.php estamos llamando al método enlacesPaginasController() y que él mismo ya está incluyendo (include) el archivo del módulo. Nuestra plantilla puede ser más simple, solo debe proveer el lugar donde el controlador "pintará" el contenido.

php
<!DOCTYPE html>
<html>
<head>
    <title>Mi Sitio MVC</title>
</head>
<body>
    <header><h1>LOGOTIPO</h1></header>

    <?php include "modules/navegacion.php"; ?>

    <section>
        <?php
        // Instanciamos el controlador y llamamos al método que se encarga
        // de conectar con el modelo e incluir el módulo correcto.
        $mvc = new MvcController();
        $mvc->enlacesPaginasController();
        ?>
    </section>

</body>
</html>

Probando el Ciclo Completo

  1. Abre tu navegador y ve a index.php. Verás la página con el contenido "PÁGINA DE INICIO".

  2. Haz clic en "Nosotros". La URL cambiará a index.php?action=nosotros y el contenido de la sección cambiará a "PÁGINA DE NOSOTROS".

  3. Prueba "Servicios" y "Contáctenos".

¡Ahora sí! El flujo está completo:

  1. El usuario hace clic → navegacion.php.

  2. La petición (action=nosotros) llega a index.php.

  3. index.php llama al controlador MvcController.

  4. El controlador llama al modelo EnlacesPaginas::enlacesPaginasModel('nosotros').

  5. El modelo evalúa, construye la ruta views/modules/nosotros.php y la devuelve.

  6. El controlador recibe la ruta y la incluye dentro de template.php.

  7. El usuario ve la página de "Nosotros".

Resumen y Conceptos Clave

  • El Modelo es el cerebro: Ahora toda la lógica de "qué archivo mostrar según la acción" está en el modelo. El controlador solo orquesta el proceso.

  • Comunicación con Parámetros y Retorno: El controlador le pasa datos al modelo ($enlacesController) y el modelo le retorna un resultado ($modulo). Esto es fundamental.

  • include vs return: El modelo usa return para devolver información. El controlador usa include para mostrar esa información en la vista.

  • Separación de Responsabilidades: Cada capa hace lo que le toca.

    • Vista: Muestra información.

    • Controlador: Recibe peticiones y las dirige.

    • Modelo: Procesa la lógica de negocio.

En la siguiente parte, podríamos modificar el modelo para que, en lugar de devolver la ruta de un archivo estático, consulte una base de datos y le devuelva los resultados al controlador, quien se los pasaría a una vista para ser mostrados. ¡Las posibilidades son infinitas!

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