Parte1-Capitulo2

Capitulo 2. Conceptos básicos

1. MVC

1.1. Que es

En 1979, Trygve Reenskaug desarrolló una arquitectura para desarrollar aplicaciones interactivas. En este diseño existían tres partes: modelos, vistas y controladores. El modelo MVC permite hacer la separación de las capas de interfaz, modelo y lógica de control de ésta. La programación por capas, es un estilo de programación en la que el objetivo primordial es la separación de la lógica de negocios de la lógica de diseño, un ejemplo básico de esto es separar la capa de datos de la capa de presentación al usuario. La ventaja principal de este estilo, es que el desarrollo se puede llevar a cabo en varios niveles y en caso de algún cambio sólo se ataca al nivel requerido sin tener que revisar entre código mezclado. Además permite distribuir el trabajo de creación de una aplicación por niveles, de este modo, cada grupo de trabajo está totalmente abstraído del resto de niveles, simplemente es necesario conocer la API (Interfaz de Aplicación) que existe entre niveles. La división en capas reduce la complejidad, facilita la reutilización y acelera el proceso de ensamblar o desensamblar alguna capa, o sustituirla por otra distinta (pero con la misma responsabilidad). En una aplicación Web una petición se realiza usando HTTP y es enviado al controlador. El controlador puede interactuar de muchas formas con el modelo, luego el primero llama a la respectiva vista (interfaz de usuario) la cual obtiene el estado del modelo y lo muestra al usuario en una respuesta HTTP.

1.2. Implementación y uso

Kumbia aprovecha los mejores patrones de programación orientada a la web en especial el patrón MVC (Modelos, Vista, Controladores). Este capítulo describe el funcionamiento general de este paradigma en Kumbia. El objetivo de este patrón es el realizar y mantener la separación entre la lógica de nuestra aplicación, los datos y la presentación. Esta separación tiene algunas ventajas importantes, como:

IMAGEN MANUAL PÁG. 39

1.3. Información adicional

La base de Kumbia es el MVC, un tradicional patrón de diseño que funciona en tres capas:

En Kumbia los controladores están separados en partes, llamadas front controller y un en un conjunto de acciones. Cada acción sabe cómo reaccionar ante un determinado tipo de petición. Las vistas están separadas en layouts, templates y partials. El modelo ofrece una capa de abstracción de la base de datos utilizada además dan funcionalidad agregada a datos de sesión y validación de integridad relacional. Este modelo ayuda a separar el trabajo en lógica de negocios (modelos) y la presentación (Vistas).

Por ejemplo, si usted tiene una aplicación que corra tanto en equipos de escritorio y en dispositivos de bolsillo entonces podría crear dos vistas diferentes compartiendo las mismas acciones en el controlador y la lógica del modelo. El controlador ayuda a ocultar los detalles de protocolo utilizados en la petición (HTTP, modo consola, etc.) para el modelo y la vista.

Finalmente, el modelo abstrae la lógica de datos, que hace a los modelos independientes de las vistas La implementación de este modelo es muy liviana mediante pequeñas convenciones se puede lograr mucho poder y funcionalidad.

1.4. Caso práctico

Para hacer las cosas más claras, veamos un ejemplo de cómo una arquitectura MVC trabaja para un agregar al carrito. Primero, el usuario interactúa con la interfaz seleccionando un producto y presionando un botón, esto probablemente valida un formulario y envía una petición al servidor.
  1. El Front Controller recibe la notificación de una acción de usuario, y luego de ejecutar algunas tareas (enrutamiento, seguridad, etc.), entiende que debe ejecutar la acción de agregar en el controlador.
  2. La acción de agregar accede al modelo y actualiza el objeto del carrito en la sesión de usuario.
  3. Si la modificación es almacenada correctamente, la acción prepara el contenido que será devuelto en la respuesta – confirmación de la adición y una lista completa de los productos que están actualmente en el carrito. La vista ensambla la respuesta de la acción en el cuerpo de la aplicación para producir la página del carrito de compras.
  4. Finalmente es transferida al servidor Web que la envía al usuario, quien puede leerla e interactuará con ella de nuevo.

2. Parámetros con nombre

¡Wow!, Algo muy importante en Kumbia es la aplicación de los parámetros con nombre, éstas una característica muy importante usada a lo largo del framework y que es muy útil. Ésta ermite enviar los parámetros en un orden independiente sin que esto impida que funcionen. Los parámetros con nombre son una característica utilizada en otros lenguajes como Ruby en donde son ampliamente usados. La implementación nos permite de forma sencilla enviar los valores de los parámetros de todo tipo de funciones sin preocuparnos por el orden correcto de estos.

El uso es 'nombre: valor', es muy importante mantener el orden sintáctico para que
funcionen bien:

3. Obtención de valores

Las URLs de Kumbia están caracterizadas por tener varias partes cada una de ellas con una función conocida. Para obtener desde un controlador los valores que vienen en la URL podemos usar algunas propiedades útiles en el controlador:


EJEMPLO 1.

Url: http://www.kumbia.org/tienda/productos/buscar/12
El sitio es: kumbia.org
La aplicación es: tienda
El controlador es: productos
La acción es: buscar
El valor para id es: 12

Controlador tienda/productos_controller.php

1. <?php
2.
3. class ProductosController extends ApplicactionController {
4.
5.      public function buscar($id){
6.      /* */
7.      }
8. }
9.
10. ?>

Dentro del método buscar podemos obtener el valor de id osea 12 en nuestro ejemplo
colocando un parámetro al controlador $id podemos recoger este valor y utilizarlo
internamente.

Otras formas de hacer esto es utilizar los métodos post, get o request así:.

1. public function buscar(){
2.      $id = $this->request(“id”);
3.      // o también
4.      $id = $this->id;
5. }

¿Cómo saber el nombre del controlador actual?

6. public function buscar(){
7.      $controlador = $this->controller_name;
8. }

Cómo saber el nombre de la acción actual?

9.   public function buscar(){
10.      $controlador = $this->action_name;
11. }

EJEMPLO 2

Url: http://www.kumbia.org/noticias/registro/buscar_fecha/2006/12/01
El sitio es: kumbia.org
La aplicación es: noticias
El controlador es: registro
La acción es: buscar_fecha

La mejor forma de recoger estos valores es de la siguiente forma:

11. <?php
12.
13. class RegistroController extends ApplicactionController {
14.
15.       public function buscar_fecha($año, $mes, $dia){
16.      /* */
17.      }
18. }
19.
20. ?>


Como vemos los valores adicionales en la URL son automáticamente agregados como parámetros en la acción del controlador.

¿Que pasa con id en este ejemplo?

$id es el valor del primer parámetro siempre así que si nos referimos a éste, encontramo que tiene el valor 2006.

¿Cómo puedo obtener los parámetros extra si no sé cuántos son?

Aquí usamos la propiedad del controlador $parameters que contiene estos valores así que el ejemplo podríamos reescribirlo así:

21. <?php
22.
23. class RegistroController extends ApplicactionController {
24.
25.    public function buscar_fecha(){
26.      $año = $this->parameters[0];
27.      $mes = $this->parameters[1];
28.      $dia = $this->parameters[2];
29.      /* ... */
30.    }
31. }
32.


Por último podemos ver todos los parámetros que vienen en una url de Kumbia usando la propiedad del controlador $this->all_parameters. Una salida de esta variable en el ejemplo anterior con print_r muestra:

1. Array
2. (
3. [0] => registro
4. [1] => buscar_fecha
5. [2] => 2006
6. [3] => 12
7. [4] => 01
8. )

 

4. Uso de Paquetes (Namespace)

PHP5 no soporta el uso de paquetes, lo cual es una gran desventaja ya que no podemos
apoyarnos en estos para agrupar clases buscando cierto tipo de independencia para
administrarlas a nivel lógico.

Kumbia permite emular el concepto de paquetes (a nivel físico) muy conocido en Java e
integrarlo a nuestras aplicaciones.

 IMAGEN MANUAL PÁG.45

Los paquetes son grupos relacionados de clases e interfaces y proporcionan un mecanismo conveniente para manejar un gran juego de clases e interfaces y evitar los conflictos de nombres.

Los paquetes permiten hacer una organización de clases mediante directorios.
En el siguiente ejemplo tenemos una serie de archivos con clases y que contienen cierta funcionalidad en la cual no vamos a profundizar y llamaremos clases de usuario.

Este directorio está ubicado en la raíz del framework y contiene subdirectorios con clases que deben integrarse a nuestra aplicación.

Kumbia proporciona un método para incluir los archivos en forma de paquetes de esta forma:

1. kumbia::import('app.lib.*');

Así incluiríamos todos los archivos php que están en app/lib. La función también puede hacer una importación recursiva. Por ejemplo:

1. kumbia::import('app.com.*');

Importaría el contenido de com y sus sub-directorios.

1. kumbia::import('app.com.os.*');

y así solo los de app/com/os/