Desarrollo de aplicaciones web. Modulando los objetos. Parte XIX


Desarrollo de aplicaciones web. Modulando los objetos. Parte XIX

En este articulo daremos forma y funcionalidad al modulo de productos. Implementaremos las clases que este objeto necesita para cumplir su propósito en nuestra aplicación.



Para que un modulo exista como tal en nuestra aplicación, debe cumplir la condición de existir dentro de la carpeta módulos como una carpeta propia, que llevara por nombre el del objeto que representa (Al ser un concepto, el nombre debería estar en plural). Así por ejemplo, tenemos la carpeta productos que controla al objeto producto o bien, tenemos al modulo usuarios que relaciona al objeto usuario.
Cualquier otro concepto (u objeto) que necesitemos manejar dentro de la aplicación estará dentro de un modulo por defecto y llevara por nombre index. Así por ejemplo, tenemos al controlador hijo errorControlador o a indexControlador dentro de esta carpeta, pues no realizan ninguna tarea asociada directamente a un objeto en particular.
Siguiendo la misma idea, cada modulo deberá contar con un controlador hijo por defecto llamado indexControlador. Este controlador recibirá todas aquellas peticiones que no encuentren cabida en los demás controladores del modulo.

Un modulo es un conjunto de controladores referentes a un objeto y cada uno de estos realiza una determinada acción sobre el objeto o a un conjunto de estos

Definición


Estructura del modulo Productos de nuestra aplicación
Estructura del modulo Productos de nuestra aplicación

Cada carpeta de un modulo debe incluir en su interior una estructura MVC. En la carpeta controlador van los controladores del objeto, en la carpeta modelo encontramos los modelos de los controladores y en la carpeta vista irán las vistas de los controladores.
Recordemos que el patrón MVC organiza la estructura, tanto física (su estructura en carpetas) como lógica (su estructura en capas), sobre la cual se diseña una aplicación.

En el articulo anterior dejamos definidas las clases básicas de un objeto producto para el modulo productos.
Controladores básicos relacionado al modulo productos
Controladores básicos relacionado al modulo productos

  • indexControlador, el controlador por defecto
  • buscarControlador, realiza la búsqueda de un producto
  • listarControlador, muestra la lista de productos
  • agregarControlador, ingresa un nuevo producto
  • editarControlador, actualiza la información de un producto
  • eliminarControlador, elimina un producto existente

¿Podemos crear mas controladores?
Pues si, cada objeto tendrá tantos controladores como acciones ocurren sobre el.

Clase Petición


Cuando un usuario realiza una petición, la aplicación debe identificar los siguientes aspectos de esta:
  • El modulo encargado, por defecto sera el modulo index
  • El controlador responsable, por defecto sera indexControlador
  • El método llamado, por defecto el método index()
  • Los parámetros involucrados, siempre y cuando existan

Veamos unos ejemplos para entender el funcionamiento.
Ejemplo 1: Ante la petición mas básica http://locahost/tienda la aplicación determina lo siguiente:
 /* Esta seria la vista de entrada a la aplicación */
Modulo : index
Controlador: indexControlador
Método : index()
Parámetros : null

Ejemplo 2: Ante la petición http://locahost/tienda/productos/buscar la aplicación determina lo siguiente:
 /* Esta seria la vista relacionada a la búsqueda de un producto */
Modulo : productos
Controlador: buscarControlador
Método : index()
Parámetros : null

Ejemplo 3: Ante la petición http://locahost/tienda/producto/barros-luco la aplicación determina lo siguiente:
 /* Esta seria la vista relacionada al producto barros luco */
Modulo : productos
Controlador: productoControlador
Método : index()
Parámetros : array('barros-luco')

Ejemplo 4: Ante la petición http://locahost/tienda/productos/agregar la aplicación determina lo siguiente:
 /* Esta seria la vista relacionada a agregar un nuevo producto */
Modulo : productos
Controlador: agregarControlador
Método : index()
Parámetros : null

Recordemos que la aplicación recibe peticiones tipo http://localhost/tienda/modulo/controlador/metodo/param1/param2/... por lo tanto, los ejemplo anteriores sirven para cualquier objeto de nuestra aplicación, sean estos usuarios, categorías, pedidos, clientes, etc.
Por razones de espacio no mostrare la clase Peticion pero en el archivo adjunto estará comentada. Esta clase es la que cambia principalmente para poder asignar los módulos.

Los controladores y sus modelos


La estructura básica de un controlador viene dado por este molde:
<?php /* Clase indexControlador */
namespace Modulos\Index\Controlador; /* Acá cambia la palabra 'Index' por la correspondiente al modulo */
use Core\Controlador as Controlador;
final class indexControlador extends Controlador {
/*
* Variables de clase
*/
private $_modelo; /* Variable privada para el modelo */
public function __construct() {
/*
* Código del constructor
*/
$this->_modelo = $this->cargarModelo("index"); /* A la variable se le asigna un objeto de su modelo */
}
public function index() {
/*
* Código del método
*/
$recuperaDatosDelModelo = $this->_modelo->hacerAlgoEnBaseDeDatos(); /* llamada y asignación */
}
]

Recordar que si existe algún método público diferente al método index() tal ves sea necesario construir otro controlador para ese método especifico. La cantidad de métodos privado no influye en nada respecto de la cohesión de la clase y mientras mas métodos, mucho mejor (jeje)
La estructura básica del modelo de un controlador viene dado por este molde:
<?php /* Clase indexModelo */
namespace Modulos\Index\Modelo; /* Acá cambia la palabra 'Index' por la correspondiente al modulo */
use Core\Modelo as Modelo;
final class indexModelo extends Modelo {
public function __construct() {
parent::__contruct();
}
public function hacerAlgoEnBaseDeDatos() {
/*
* Código del método
*/
}
}

En los modelos de los controladores pueden haber tantos métodos públicos como privados como se necesite y no afectara la cohesión de la clase.
Las clases que habíamos definido para el modulo productos van en el código fuente.

Alta cohesión, bajo acoplamiento


Supongamos que el usuario quiere ver todos los productos de una determinada categoría ('bebidas'). La lógica de nosotros nos dice que deberíamos acceder a los objetos productos que estén relacionado con los objetos categorías de esa categoría especifica para así mostrar en pantalla lo que pide el usuario.
La petición seria mas o menos http://localhost/tienda/productos/categoria/bebidas lo que resolveríamos como:
 /* Vista relacionada a todos los productos de la categoría 'bebidas' */
Modulo : productos
Controlador: categoriaControlador
Método : index()
Parámetros : array('bebidas')

De esto obtengo que debo crear dentro del modulo para productos un controlador categoriaControlador lo que me afecta el acoplamiento del modulo.
¿Como lo arreglo?
Obligando al usuario a realizar una petición http://localhost/tienda/categoria/bebidas por medio de por ejemplo, un link.
La cohesión disminuye en peticiones como http://localhost/tienda/productos/producto/agregar
 /* Vista relacionada a un nuevo producto */
Modulo : productos
Controlador: productoControlador
Método : agregar()
Parámetros : null

Esto me dice que el método agregar() debe ser publico, y mas el método por defecto index() del mismo controlador, serian dos métodos públicos, dos acciones a realizar por el mismo controlador.
¿Como lo arreglo?
Obligando al usuario a realizar una petición http://localhost/tienda/productos/agregar por medio de por ejemplo, un link en el menú del backend.

Estos últimos dos ejemplo, sobre mostrar los productos por categoría especifica o bien el agregar un nuevo producto, están implementados en el código fuente que les entrego al final (jeje)

Ultimas consideraciones


Es necesario entender la importancia de la Modularidad de nuestra aplicación. Por ejemplo, necesitamos implementar una aplicación para administrar una biblioteca, pero no definimos el objeto categorías sino mas bien el objeto secciones. Si usamos el molde de esta aplicación, solo nos restaría copiar la carpeta categorias, cambiarle el nombre a esta junto a los namespace de los controladores y modelos.
¿Se pierde cohesión? ¿Se pierde en acoplamiento?
No debería, pues nuestra aplicación es modular y si manejamos la misma estructura en diferentes aplicaciones podemos exportar estos módulos si necesidad de hacer mayores cambios y menos tener que escribirlos de nuevo.

Trabajo con la librería holder JS para poder rellenar los espacios en los que vendrían las imágenes de los productos.
Saludos, comenten y nos leemos en un próximo articulo.

PD. Puedes descargar el código fuente desde acá

Etiquetas php mvc modulos

Ultima actualización Sábado 31 de Marzo, 2018




Agregar Comentario