Mostrando entradas con la etiqueta MVC. Mostrar todas las entradas
Mostrando entradas con la etiqueta MVC. Mostrar todas las entradas

martes, 26 de octubre de 2010

Arquitectura de Django framework (parte 1)

En este post no voy a referirme a detalles de instalación ni a un getting started con este producto.
Django esta construido con Python, lenguaje OO, interpretado y con tipado dinámico (+ duck typing)
En Django todo comienza creando un proyecto, este servirá de base para luego crear nuestra aplicaciones. Creamos un proyecto así:

django-admin.py startproject mi_sitio
(django-admin.py es un utilitario de comandos para tareas de administracion del django)

Esto genera una carpeta con los archivos de python que se muestran en la clase Project
(* a partir de la versión 1.4 solo esta el manage.py en la carpeta del project, y se genera una carpeta - paquete, con el mismo nombre del project, ubicandose allí los archivos settings.py y urls.py)

Como vemos, un Project posee 3 archivos python:
  • Settings.py, formado por un conjunto se variables donde se setean por ej.: los detalles de conexión con la/s base de datos, directorios de archivos media y templates, aplicaciones ó módulos instalados en el proyecto.
  • Urls.py, es como una tabla donde se mapean las urls de nuestro proyecto con las funciones que controlan la creación de nuestros templates html, de aquí en más views de cada aplicación.
  • Manage.py, es un wrapper del django-admin.py que realiza las sig. tareas antes de delegar el comando al django-admin.py: 1) pone el paquete del proyecto en el sys.path, y 2) setea la variable DJANGO_SETTINGS_MODULE para que apunte al settings.py de su proyecto.
A continuación (desde la carpeta del project...) creamos la aplicación 'conferencias' que será parte de ese proyecto (1 ó + aplicaciones):
python manage.py startapp conferencias

Esto genera una nueva carpeta dependiente del proyecto, donde se crearán los archivos:
  • models.py, aquí crearemos las clases que forman el modelo de esa aplicación, nuestros 'business objects', por ej: Conferencia, Oyente, Disertante, etc.
  • views.py, aquí van los métodos que contienen la lógica de negocio que construirá la página, nuestras controladoras de Casos de uso. Cada una de estas funciones es llamada en Django : View y está mapeada a una url (no necesariamente todas...) del sitio web en el archivo urls.py del proyecto.
** Tanto projects como applications tienen un archivo python que no fue descripto anteriormente: __init__.py , este archivo es requerido por Python para tratar al directorio como un paquete, o sea un grupo de módulos (cada archivo .py).

Ejecutando el localhost para probar nuestro sitio
Django posee funcionalidad de web server para poder probar nuestras aplicaciones en un localhost, ejecutando el sig. comando desde la carpeta del proyecto:
python manage.py runserver

veremos en la consola que se validan los modelos (models.py de las aplicaciones) y luego nos muestra la versión de Django usada y que el server de desarrollo esta ejecutandose en http://127.0.0.1:8000/
Si queremos que la aplicación que se está generando se vea en otros clientes de la red podremos especificar el nro. de ip de nuestra máquina (y el puerto que deseemos) , por ej:
python manage.py runserver 10.0.0.78:8000

Al probar en nuestro browser favorito veremos un mensaje de bienvenida de Django.Django es un framework web MVC, aunque ellos lo describan como MVT (model-View-Template), es un tema de conceptos que esta bien explicado por la gente de Django.

jueves, 21 de octubre de 2010

Los Frameworks son nuestro silver bullet ?


Uno nace como programador de software aprendiendo un lenguaje determinado, luego otros, siempre desarrollando algoritmos que cumplan con la funcionalidad requerida del sistema.
Como no queremos volver a escribir las mismas soluciones generamos nuestras librerías de codigo para reutilizarlo, con el diseño orientado a objetos lo hacemos todo más flexible creando clases abstractas e interfaces, usando patrones de diseño, inyectores de dependencia, etc y aplicando alguna arquitectura que nos permita convertir nuestra solución en un producto.
Así cumplimos con nuestro objetivo de vivir de esta hermosa profesión, logrando vender nuestro software a diversos clientes con distintas variantes funcionales.
Siempre uno busca ir programando menos y reutilizar más nuestros componentes y por supuesto los de otros programadores que nos ofrecen los suyos (pagos ó gratuitos), esta metodología de trabajo nos irá llevando a nuestro silver bullet, y es la motivación principal de los creadores de FrameWorks (marcos de trabajo).
Un FrameWork es
una estructura conceptual y tecnológica de soporte, definida normalmente con artefactos o módulos de software concretos, con base en la cual otro proyecto de software puede ser organizado y desarrollado.

En mi experiencia como docente en la universidad, uno nota que muchos desarrolladores (generalmente colegas) de mucha experiencia, no conciben la idea del desarrollo con estas herramientas basandose en la desconfianza que genera tener que aprender algo nuevo que no sabré si el año que viene seguirá existiendo, ya que generalmente estos FrameWorks son proyectos de libre disponibilidad y open source, y su existencia depende de la buena voluntad de la comunidad que los compone y mejora dia a dia.
Si bien esta desconfianza es lógica, la proliferación de estas herramientas de desarrollo esencialmente en el ámbito web aplicando una arquitectura MVC , ampliamente consensuada y diría ya un standard para estos desarrollos, ha logrado que muchos programadores con conocimientos en diversos lenguajes de programación los utilice para lograr acercarse a su silver bullet.

Algunos buenos ejemplos de los mismos son para PHP: CodeIgniter, Symfony y CakePHP; para ASP Net: ASP Net MVC 2 , para Python: Django , para Java : JSF y Tapestry , para Ruby : RubyOnRails , etc.
Finalmente, todos los programadores que los usan no deben estar equivocados en su elección, particularmente me he convertido en un ferviente usuario de uno de ellos :
Django ,luego de haber investigado las características de varios de estos frameworks.


En futuros posts iremos investigando las ventajas que nos brindan a través de mi experiencia de uso.




martes, 27 de noviembre de 2007

EL futuro MVC de Asp Net

Luego de haber leído los artículos de Scott Guthrie y Dino Esposito voy a realizar un resúmen de la propuesta MVC para ASP NET.

Para crear una aplicación de este tipo con VS, elegimos un nuevo proyecto de tipo “ASP.NET MVC Web Application”, de esta forma se creará una nueva solución y se añadirán dos proyectos: un proyecto web en el que implementaremos nuestra aplicación y un proyecto de testing que usaremos para escribir test unitarios (TDD...)
La estructura por defecto de un ASP.NET MVC tiene 3 directorios:

  • /Controllers
  • /Models
  • /Views
Por lo cual, crear las clases controladoras en el directorio /Controllers, las de modelo de datos en /Models, y las vistas en el directorio /Views.
Cabe aclarar que el Framework no te obliga a usar esta estructura, pero el template usa este patrón. Consultando a Scott sobre el uso de ensamblados (dll) para la controladora y el modelo (mis capas de negocio y acceso a datos), dijo no existir problemas en agregar las referencias a los mismos y usarlos en el MVC en vez de las carpetas creadas por default; si no fuera así no podríamos usar nuestras controladoras y modelos de un proyecto a otro, debiendo reescribir código en cada solución.


Por defecto los proyectos MVC tienen unas reglas de enrutado de urls preconfiguradas, de esta forma podemos empezar a escribir el código usando un conjunto de convenciones para nombrar las urls que van a usarse en nuestra aplicación.

Las Controladoras...
El convenio por defecto es mapear el path de la url de una petición HTTP (por ejemplo: /Products/) a una clase cuyo nombre siga el patrón UrlPathController (por ejemplo: una url que termine con /Products/ se mapeará a la clase ProductsController).
Por lo tanto si agregamos la clase “ProductsController” (que herede de System.Web.MVC.Controller) a nuestro proyecto, el framework ASP.NET MVC la usará para procesar todas las peticiones cuya url contenga la cadena “/Products”. Es decir, será llamada para procesar las urls “/Products/Categories”, “/Products/List/Beverages”, “/Products/Detail/3″ (donde 3 será el id. del producto), etc.



El framework MVC nos permite definir “métodos de acción” en nuestro controladora, y la clase base Controller invocará el método apropiado, así que cuando recibimos una petición de la forma "/Products/Categories”, la regla de enrutado tratará la parte “Categories” como el nombre de la acción, y se invocará el método Categories() para procesar la petición, si recibimos una petición a la url "/Products/Detail/5", la regla tomará el nombre “Detail” como el nombre de la acción y se invocará al método Detail(), etc.

Como accedemos a los parámetros de las urls?
La clase base Controller expone un conjunto de objetos Request y Response que podemos usar. Estos objetos tienen la misma estructura que los objetos HttpRequest/HttpResponse a los que estamos acostumbrados en ASP.NET, la diferencia es que estos objetos están basados en interfaces en lugar de en clases selladas (sealed) (MVC trae las interfaces System.Web.IHttpRequest y System.Web.IHttpResponse), esto nos da la posibilidad de poder implementarlos como queramos, uno de sus usos será crear test unitarios para clases controlador.

En la acción List , aparece un parámetro de la categoría, que es parte de la URL, y un índice de página opcional (implementaremos paginado en el servidor y usaremos ese valor para indicar qué página de categoría mostrar en la petición).
Los parámetros opcionales se manejan usando tipos de datos nullables en los métodos de acción de las controladoras. El parámetro “int?” de nuestra acción List es nullable.



Construyendo las clases del Modelo
Para crear nuestras clases que accedan a la información de la BD, Scott lo realiza mediante "Linq to Sql" (ORM), el cual me permite obtener como resultados listas de objetos. También podría usar NHibernate o cualquier otro tipo de ORM, ó Ado.Net (no recomendado, ya que debo mapear registros a listas de objetos) para construir mis clases del Modelo.



Volviendo a nuestra controladora, vemos el uso que se hace del modelo creando un objeto de tipo "NorthwindDataContext" (clase creada con la utilidad de Linq), y llamando a sus métodos, como por ej.: en el método "Detail(int id)" donde llamamos a "northwind.GetProductById(id)".


Y la Vista??
Cuando implementamos los tres métodos de acción del controlador en la clase ProductsController, usamos los parámetros de la URL para obtener los objetos adecuados de nuestra BD, para luego seleccionar una vista adecuada para generar una resputesta HTML. Usaremos uno de los métodos RenderView() de la clase base Controller para espcificar la vista que queramos usar, así como explicitamente le pasaremos los datos específicos que queremos que la vista use para renderizar la respuesta. Por ej: RenderView("Detail", product), donde product es el objeto de tipo Product obtenido del llamado al Modelo.
Para crear la vista a la cual hacemos referencia en el ej. ("Detail"), podemos usar cualquier motor de templates para ayudarnos a generar la interfaz de usuario (incluyendo motores como NVelocity, Brail - y cualquiera que escribamos ). Por defecto ASP.NET MVC usa las páginas ASP.NET (.aspx), Master Pages (.master) y UserControls (.ascx).


Conclusiones
Este framework no reemplaza el modelo basado en WebForms de Asp.Net, sólo nos agrega la posibilidad de crear nuestras aplicaciones bajo este paradigma, aplicando a la perfección este viejo patrón de arquitectura (MVC).


En el post de Dino, se le pregunta a los lectores si han escuchado hablar de REST (Representational State Transfer) , el cual es otro patrón de arquitectura que encaja perfectamente en el proceso del MVC AspNet, que describimos anteriormente.
REST define cómo los recursos de la red deberían ser definidos y direccionados con el objetivo de: obtener menores tiempos de respuesta y separar las responsab. entre front-end y back-end. Se basa en los sig. principios:

  • Una aplicación expresa su estado e implementa su funcionalidad actuando sobre recursos lógicos.
  • Cada recurso es direccionado usando una URL específica.
  • Todas las ventajas que poseen esos recursos direccionables se agrupan en un juego de operaciones.

Por lo tanto el framework MVC de AspNet usa un modelo REST que compite con el modelo clásico de "postback" de AspNet.



Cada página se separa en 2 componentes (controladora y vista) que operan sobre el mismo modelo de datos; esto es opuesto al clásico modelo "code-behind" donde no existen barreras que nos fuercen a separar las responsab. entre controladoras y vistas.


Aunque manteniendo las clases "code-behind" (nuestras aspx.cs) lo más ligeras que sea posible y diseñando la capa de negocios de forma apropiada (ver ejemplo de capa de negocio), un buen desarrollador logra separar estas responsabilidades manteniendo la lógica de la aplicación en la capa que corresponda.

Bueno, en este post se ha intentado aclarar un poco de que trata un framework MVC, tomándolo como una opción más a la hora de desarrollar software para Web. Cualquier extensión al tema leer los posts de Scott y Dino que están referenciados al principio.

viernes, 23 de noviembre de 2007

Introducción a los frameworks MVC

Ya hemos visto una arquitectura de 3 capas lógicas, ahora investiguemos como desarrollar un MVC (model-view-controller) , que fue explicado muy someramente en este post.












Sin lugar a dudas estos frameworks han ganado terreno en el desarrollo de sitios Web, donde RubyOnRails ha sido la inspiración de otros desarrolladores de frameworks de este tipo. En el caso del mundo .NET, la creación de MonoRail sumó muchos adeptos en la comunidad de desarrolladores y todos comenzamos a mirar de reojo para cuando Microsoft sumaría una propuesta de desarrollo que rompiera con el modelo basado en WebForms (.aspx), ó al menos agregara la posibilidad del MVC.

El modelo actual de MS impone que los request de los clientes son solicitudes a páginas (WebForms) aspx que contienen controles Web ASP.Net, los cuales disparan eventos a una controladora de esa página. Esta controladora es normalmente código C# ó VB.Net agregado al WebForm, y conocido como "code behind" (aspx.cs ó aspx.vb). En este tipo de arquitectura el cliente hace Request a objetos de la capa de presentación (WebForms aspx), que luego llaman a su objeto controlador para pedirle funciones, estas luego harán solicitudes sobre el Modelo (mi acceso a datos en el 3 capas lógicas).

En el caso de un MVC, el Request se realiza a un objeto de tipo Controlador que crea una presentación como Response a esa solicitud. Si se fijan en el diagrama MVC dice que la "Controladora selecciona la Vista que irá como respuesta".

Pues bien, Microsoft responde a la comunidad de desarrolladores .NET con la siguiente sorpresa (quizás no tanto...) el dia 13/11/2007 : The Asp.Net MVC framework. Ver el extenso post que publicó el gran Scott Guthrie (jefe de proyectos de MS: IIS, ASP.NET, Atlas, CLR, Compact Framework, Windows Forms, etc, etc.).
Allí se aclara que será agregado al VS 2008 como una ventaja opcional, a través de un template para la creación de proyectos de tipo MVC, también que este modelo fuerza a una limpia separación de responsabilidades de la aplicación, que permite realizar testeos de los componentes soportando TDD (desarrollo manejado por el testing), y que provee mayor control sobre las URLs que se publican en su aplicación, y mayor control sobre el código HTML que se emite desde ellas.

Esta es una vista de como las URLs se mapean a clases Controladoras:

En el post de Scott, se aclara que en la mayoría de los frameworks Web (ASP Net WebForms,PHP,JSP,...) las URLs se mapean con archivos template almacenados en el disco del servidor web, por ej: un url "/Productos.aspx" tiene un archivo subyacente Productos.aspx en disco que maneja el procesamiento de la misma.

En cambio, en los frameworks MVC las URLs se mapean directamente a clases, estas son denominadas "Controladoras" y son las que procesan los Request entrantes, manejando las entradas del usuario, sus interacciones y ejecutando la lógica apropiada para el proceso. Una clase controladora llama a una vista, la cual genera la salida HTML que se enviará como Response.
En prox. posts entraré en más detalles sobre este ASP.Net MVC y en el modelo de WebForms.

lunes, 28 de mayo de 2007

Diseño en 3 capas? fisicas ó lógicas? es igual a patrón MVC?

Diseñar en 3 capas...trata sobre no poner todo tu código en las interfaces de usuario de tu sistema (IU). Para subsanar esto, la idea es tener 3 niveles de funcionalidad bien definidos :



  • Capa de presentación, con nuestras IU (formularios windows, páginas HTML,..) y sus controles visuales (textBox, comboBox, dataGrids) junto con sus eventos (los click y etc.)

  • Capa de negocio (lógica del dominio), aqui ira todo el código que define las reglas de negocio (cálculos, validaciones). Surge de los procesos que hemos encontrado en el análisis.

  • Capa de acceso a datos, el código que permite acceder a las fuentes de datos. Esencialmente trata sobre 4 operaciones básicas, llamadas CRUD (por Create-Retrieve-Update y Delete), que se realizan sobre cualquier fuente de datos (normalmente alguna base de datos relacional).

Debajo de esta última se encontrará la FUENTE de DATOS que permite la persistencia de los mismos en algún medio físico.

Este diseño corresponde a las 3 capas lógicas (3 layers). No confundir con las capas físicas ó parte (3 tiers) que corresponden al lugar donde se instalan los componentes de software.

En 3 tiers la ejecución está distribuida:



  • Front-End, donde se ejecutan las IU del cliente. Los Browsers.

  • MiddleWare, recibe solicitudes de las IU a través de la red. Estos son mensajes (XML, SOAP,...) que se envían mediante protocolos de transporte (HTTP,TCP,UDP,..). El Servidor Web.

  • BackEnd, nuestra base de datos ó algún proceso externo a nuestro software.

Por último "Modelo-Vista-Controlador" es un patrón de diseño de arquitectura que está asociado a la idea de 3 capas (3 layers), aunque su objetivo es aún más fino. El mismo se centra en la secuencia de ejecución, desde que se produce un evento en la capa de presentación hasta que el mismo es atendido en forma completa.





Las partes que lo componen son:



  • Vista: componente que recibe el estímulo y genera un evento, que puede involucrar a otros objetos de la IU. Corresponde a la capa de presentación, y al Front-End(en Web:Html, JavaScript,...), aunque suele haber parte en el MiddleWare (controles ASP,PHP,...)

  • Modelo: componente asociado a las entidades de negocio (cliente, factura, pago,...). En 3 capas incluye parte de la capa de negocio (entidades, pero no lógica de procesos) y toda la capa de acceso a datos. En 3 tiers se instala en el BackEnd (la BD) y parte en el MiddleWare (entidades de negocio y acceso a datos).

  • Controlador: componente asociado a la lógica de procesos del negocio. En 3 capas la parte que faltaba y en 3 tiers en el MiddleWare.