Framework

En el desarrollo de software, un framework es una estructura de soporte definida en la cual otro proyecto de software puede ser organizado y desarrollado. Típicamente, un framework puede incluir soporte de programas, bibliotecas y un lenguaje interpretado entre otros software para ayudar a desarrollar y unir los diferentes componentes de un proyecto.

Un framework representa una arquitectura de software que modela las relaciones generales de las entidades del dominio. Provee una estructura y una metodología de trabajo la cual extiende o utiliza las aplicaciones del dominio.

Los Frameworks son diseñados con el intento de facilitar el desarrollo de software, permitiendo a los diseñadores y programadores pasar más tiempo identificando requerimientos de software que tratando con los tediosos detalles de bajo nivel de proveer un sistema funcional. Por ejemplo, un equipo que usa Apache Struts para desarrollar un sitio web de un banco puede enfocarse en cómo los retiros de ahorros van a funcionar en lugar de preocuparse de cómo se controla la navegación entre las páginas en una forma libre de errores. Sin embargo, hay quejas comunes acerca de que el uso de frameworks añade código innecesario y que la preponderancia de frameworks competitivos y complementarios significa que el tiempo que se pasaba programando y diseñando ahora se gasta en aprender a usar frameworks.

Fuera de las aplicaciones en la informática, un framework puede ser considerado como el conjunto de procesos y tecnologías usados para resolver un problema complejo. Es el esqueleto sobre el cual varios objetos son integrados para una solución dada.

Idea

Después de todo, un Framework debe ser consciente de todos estos requerimientos sin tener que ser intrusivo con las aplicaciones que permite dentro de si mismo. A esto le sumamos la capacidad de extenderse sin prejuicios para diversificar la expresión del programa mismo.

Básicos

Un Framework no es mas que una base de programación que atiende a sus descendientes (manejado de una forma estructural y/o en cascada) posibilitando cualquier respuesta ante las necesidades de sus miembros, o secciones de una aplicación (web, de este modo).

Arquitectura

Dentro de este aspecto, podemos basarnos en el modelo MVC (Controlador => Modelo => Vista) ya que debemos fragmentar nuestra programación. Tenemos que contemplar estos aspectos básicos en cuanto a la implementación de nuestro sistema:

Controlador: Con este apartado podemos controlar el acceso (incluso todo) a nuestra aplicación, esto pueden ser: archivos, scripts... programas; cualquier tipo de información que permita la interfaz. Así, podremos diversificar nuestro contenido de forma dinámica, y estática (a la vez); pues, solo debemos controlar ciertos aspectos (como se ha mencionado antes).

Modelo: Este miembro del controlador maneja las operaciones lógicas, y de manejo de información (previamente enviada por su ancestro) para resultar de una forma explicable, y sin titubeos. Cada miembro debe ser meticulosamente llamado, en su correcto nombre y en principio, con su verdadera naturaleza: el manejo de información, su complementación directa.

Vista: Al final, a este miembro de la familia le corresponde dibujar, o expresar la ultima forma de los datos: la interfaz gráfica que interactúa con el usuario final del programa (GUI). Después de todo, a este miembro le toca evidenciar la información obtenida hasta hacerla llegar con el controlador. Solo (e inicialmente), nos espera demostrar la información.

Estructura

Dentro del controlador, modelo o vista podemos manejar lo siguiente: datos. Depende de nosotros como interpretar y manejar estos 'datos'. Ahora, sabemos que el único dato de una dirección estática web es: conseguir un archivo físico en el disco duro o de internet, etc... e interpretado o no, el servidor responde.

El modelo, al igual que el controlador y la vista. Maneja todos los datos que se relacionen consigo (solo es el proceso medio de la separación por capas que ofrece la arquitectura MVC)

Y solo la vista, puede demostrar dicha información. Con lo cual ya hemos generado la jerarquia de nuestro programa: Controlador, Modelo y Vista.

Lógica

Al parecer, debemos inyectar ciertos objetos dentro de sus parientes en esta aplicación, solo así compartirán herencia y coherencia en su aplicación.

Rápidamente, para una aplicación Web sencilla debemos establecer estos objetos:

• Una base (MVC)
  
  
  • Controlador: este, debe ser capaz de manejar: rutas, archivos y clases/métodos/funciones.
  • Modelo: es como un script habitual en el servidor, solo que agrupado bajo un 'modelo' reutilizable.
  • Vista: como incluyendo cualquier archivo en nuestra ejecución, muy simple... deveras.
• Un sistema
  
  
  • Ruteador: con el, podemos dividir nuestras peticiones sin tantas condicionales.
  • Cargador: al fin, hay alguien que nos atiende y nos invita a la fiesta. <<< no se entiende, que alguien lo corrija por favor. Gracias. una persona que sepa tel tema que nos ayude.. si quiten esto.>>>

  Ejemplos

  // Index.php
        // -----
        // ------ Clases ------

        class Base {}
        class Controller extends Base {
          function load($name) {
                 require_once "app/model/$name.php";
                $this->$name =& new $name();
          }
        }

        class Model extends Controller {
          function view($name, $data) {
                extract($data);
                include "app/view/$name.php";
          }
        }
        // ------ Router & Loader ------
        function _route($controller, $model) {
          if (is_file("app/$controller.php")) {
                 require_once "app/$controller.php";
                 $object = new $controller();
                 $object->$model();
          }
        }
        // ----- Rutina -----
        _route($_GET['section'], $_GET['name']);

Esto cumple con algunas necesidades de simpleza informática. Ahora solo nos basta controlar estos procesos, ampliarlos y complementarles con algunos scripts mas.
  

  Aplicando

  Si nuestro archivo se llama Foo (clase), y nuestro otro archivo, Bar (metodo) tenemos que crear el siguiente archivo dentro de la carpeta app/ (o como se establezca)
  
// app/Foo.php
        // -----
        class Foo extends Controller {
                function Foo() {
                        $this->load('test');
                }

                function Bar() {
                 echo '<b>Testing!!!</b>';
                 echo $this->test->does();
          }
        }

  
  
  xindex, repedit
  Como resultado al solicitar (por ejemplo, ?section=Foo&name=Bar), deberíamos ver el siguiente texto: Testing!!!.

  Extendiendo

  Podremos extender nuestro sistema con clases, o funciones propias o de algun 'plugin' o libreria ajena. Solo que querremos extenderles sobre nuestro sistema actual, nuestro objeto basico.
  
// app/model/Test.php
        // -----
        class Test extends Model {
                function does() {
                        echo '<ins>Hecho esta!</ins>';
                        echo $this->view('look', array('my_var' => 'my_value'));
          }
        }
  
  Entonces, debemos usar la siguiente sentencia dentro de nuestro programa Foo: $this->load($this, 'test') o _load($this, 'test')
  Ya con esto, podremos utilizar las llamadas a $this->test->does() dentro del objeto o clase Foo.
  

  Viendo

  Para mostrar los resultado de todo nuestro computo necesitamos de vistas, o archivos de inclusión: plantillas, bloques... scripts. Suponiendo que ya ha sido todo, debemos de visualizarlo:
  
/ app/view/Look.php
        // -----
        echo 'Variable: ' . $my_var;

  
  Para poder ejecutar esto, se debe llamar esta sentencia: $this->view('look', array('my_var'=>'my_value')) ...obteniendo como resultado: Variable: my_value.