Mostrando entradas con la etiqueta patrones de diseño. Mostrar todas las entradas
Mostrando entradas con la etiqueta patrones de diseño. Mostrar todas las entradas

martes, 12 de febrero de 2008

Fabricas (GoF) - Creando objetos sin "new" - Factory method

Este patrón define una interfaz para crear un objeto, y deja a las subclases decidir cual clase instanciar.
Programar para las interfaces, NO para la implementación...

Que hay de malo en esta instrucción? : Auto a= new Sedan();

Al usar new() estamos instanciando de una clase concreta, por lo que estaremos programando contra la implementación. Es importante recordar que al acoplar nuestro código a una clase concreta, obtenemos una programación menos flexible y más frágil; o sea con más mantenimiento (y dolor de cabeza incremental) en un futuro propenso al cambio.

Ejemplifiquemos un modelo de nuestro auto:


Ante la creación de objetos de las subclases, es muy común que nuestro código se vea así:Y si tuvieramos que agregar nuevos subtipos de auto, ó eliminar otros?? --> Mayor mantenimiento y código propenso a errores !!

Identificar los aspectos que varían y separarlos de nuestro código...

Esto nos lleva a crear una nueva clase que llamaremos FabricaAutos que tendrá un método CrearAuto(int tipo) :









Con este desarrollo llegamos a un tipo de fábrica que llamaremos "Fábrica simple (simple factory), que si bien no es un patrón de diseño GoF, es una buena técnica creacional de objetos que nos acerca al siguiente patrón : Factory method

Nuestro modelo se complica...

Nuestro cliente de venta de autos (AutoShop) decide expander sus horizontes comerciales fuera de Argentina, específicamente a nuestro hermano pais de Brasil. Resulta que allí los tipos de modelos de auto difieren de los de nuestro pais; por ejemplo supongamos que los autos Rural poseen sólo 2 puertas en Brasil y 4 en Argentina, y las camionetas son doble cabina en Brasil y en Argentina no, etc, etc.
Veamos algunos cambios en nuestro código, comencemos con nuestra clase AutoShop, que ahora será abstracta:





(* protected abstract Auto CrearAuto(...))

Nuestro diagrama de clases con los AutoShops de cada pais:

Como usamos este código para entregar un Auto Sedan de nuestro AutoShop de Argentina?
Simple Factory vs Factory Method (GoF)
Simple factory decide e instancia, no tiene ninguna idea sobre que hacer con el objeto creado.
Factory method delega la creación de la instancia a las subclases, pero sabe que hacer con el objeto creado.

lunes, 4 de febrero de 2008

Estrategia (GoF) - Encapsulemos los algoritmos que varíen

Definamos este útil patrón: "Define una familia de algoritmos, encapsula cada uno y los hace intercambiables. La Estrategia deja que el algoritmo varíe independientemente de los clientes que lo usen".
Su diagrama:
Vamos a nuestro ejemplo de uso, tenemos que modelar el comportamiento de un jugador de fútbol:




Luego de modelar esto, se nos pide agregar la función de atajar , obviamente no para todos los subtipos, sólo el Arquero. Nuestra solución pasaría por agregar la subclase "Arquero" y el método "Atajar()" en mi clase Futbolista.


Ahora bien, le daríamos la posibilidad de atajar a todos los subtipos de futbolistas?, pues no, por lo que deberíamos también sobreescribir el método Atajar() en los demás subtipos, poniendo algún mensaje como "función no disponible" ó retornando null.
Y que pasaría si un futbolista "MedioCentral" decide defender en algún momento como DefensorLateral y atacar como Delantero??, difícil de solucionar con nuestro primer modelo, no?.
Un poco de diseño OO...

La herencia nos trae varios problemas asociados a la extensibilidad y al mantenimiento del código de nuestro modelo.

Nuestro principio básico a recordar aquí es : Encapsular lo que varía. Identifica los aspectos de tu aplicación que puedan variar y sepáralos del resto de tu código que no cambiará; de esta forma podremos alterar ó extender aquellas partes sin afectar al resto.

Todos los patrones de diseño aplican este concepto de una u otra forma, brindando un camino que nos permita variar una parte del sistema independientemente del resto.

Volvamos a nuestro futbolista...

Separemos los comportamientos que varían, sacando los métodos : atajar, defender y atacar, de la clase Futbolista. Luego creamos un grupo de clases que representarán cada comportamiento:

En nuestra clase futbolista, definimos el comportamiento via atributos del tipo de las interfaces definidas, y métodos de seteo (ó propiedades de escritura en C#) para poder configurar el comportamiento del futbolista en cualquier momento de la ejecución.



Por último hagamos un testing, generando un futbolista con cierto comportamiento :














Con la explicación de este patrón, termino esta miniserie de GoF (Decorador y Estrategia). En próximos post veremos algunos GoF creacionales.

martes, 22 de enero de 2008

Decorador (GoF) ó agregando responsabilidades a un objeto de forma dinámica

Las clases que componen la estructura del patrón decorador:



Comencemos por recordar un principio básico de diseño (abierto-cerrado): “las clases deben ser abiertas para la extensión pero cerradas para la modificación”.
Nuestro patrón GoF se basa en este principio (como tantos otros); para entender su implementación veamos una problemática para ejemplificar.

Tenemos una heladería, la cual además de vender variados gustos en distintos envases (copón, cucuruchos, vasitos), permite agregar diversos dulces al helado, por ej.: bañado de cobertura de chocolate, pasas de uva, almendras, nueces, granolas, rocklets, etc.
Por lo tanto el precio del producto variará en función de los adicionales agregados, por ej.: un cucurucho con nueces y rocklets se vende a 6$ (4$ del producto en sí + 2$ de agregados), un vasito con cobertura de chocolate se vende a 4$ (3$ del producto y 1$ la cobertura).

Nuestro diseño rígido:

Cada método Costo() necesita calcular el costo del tipo de producto y luego agregar los adic. llamando a la implementación de Costo() de la superclase.


Problemas de este diseño?
  • Al tener que agregar ó sacar adicionales, nos forzará a cambiar el método Costo() en la superclase y también agregar ó sacar las propiedades respectivas.

  • Podríamos tener que en sólo alguno de los tipos de productos como el “Copón” , se pudiera agregar un determinado adicional, como por ej.: “ensalada de frutas”.

  • Que pasaría si alguien quiere doble porción de “rocklets”?

Como se ve, la problemática para obtener el precio del producto, resulta interesante para diseñar, debido a las posibilidades de cambio en el algortimo que debe determinar su valor. Ante esta “posibilidad de cambio en el código” actual ó a futuro, debemos comenzar a pensar en alguna solución de diseño que nos permita la flexibilidad necesaria para incorporar los cambios sin tener que recodificar lo ya hecho, o sea con el menor impacto en nuestro código.

Apliquemos el patron para flexibilizar nuestro diseño:



Este diseño implica que cualquiera de nuestros productos concretos (copón, cucurucho,etc), puede tener 1 ó más objetos decoradores (Granola, Rocklet, etc.). De esta forma podría comprar un copón con doble ración de rocklets y nueces, ó cualquier combinación que desee, para luego solicitar su costo; el cual iría sumando los precios de los agregados hasta llegar al precio del producto concreto.

Veamos un ejemplo en código C#:

** nuestro producto Copón tiene una descrip. apropiada y un costo de 4.50$
public class Copon: Producto
{
public Copon()
{ descripcion=”Copón helado”;
precio=4.50;}

public decimal Costo()
{ return this.precio; }
}

** nuestro agregado de Rocklets hereda de Decorador
** debemos pasarle el producto a decorar en su constructor
** El costo de agregar rocklets a los helados es de 0.80$, y
** lo sumamos al costo del producto a decorar...

public class Rocklet: Decorador
{
Producto producto;

public Rocklet(Producto prod)
{ this.producto=prod;
this.precio=0.80;}

public decimal Costo()
{ return this.precio + this.producto.Costo();}
}
(** Supongamos que el adicional de nueces tiene un costo de 1$.)

Veamos como usarlo en un código cliente:

.....
Producto prod1=new Copon();
prod1=new Rocklet(prod1);
prod1=new Nuez(prod1);


** podemos agregar una nueva ración de rocklets?, claro

prod1=new Rocklet(prod1);

** mostramos el costo total del Copon con doble rocklets y nuez
System.out.println(prod1.Costo());
.....
Debería mostrar: 6.30$ (4.50+0.80+1), cabe aclarar que el método Costo() de prod1 se ejecuta recursivamente para ir capturando el precio del producto a decorar.

martes, 20 de noviembre de 2007

Arquitectura del software?


Muchas veces nos hablan de la arquitectura en el desarrollo de sistemas. Palabrita de moda quizás...; ingenieros, analistas y programadores que se hacen llamar "Arquitectos de software" como si de un título se tratase. Hasta yo la he puesto como título en mi Blog, entonces, cual es el significado de la Arquitectura en el desarrollo de un sistema?, tratemos de averiguarlo.

En setiembre de este año se realizaron las 36 jornadas de la Jaiio en mi ciudad (Mar del Plata), y al ver el temario de los seminarios, me informo de un curso especial de 8 hs. seguidas, llamado "Introducción a la arquitectura del software", dictado por el Gerente de relac. académicas de Microsoft y profesor de la UBA Pablo Michelis. Por supuesto para entender mejor este concepto y para agregar valor a mis clases me inscribí; esto intenta ser un breve resúmen del mismo.

Comencemos por definir "Arquitectura del soft":
"Estructura de sistemas o sistema de estructuras que consisten en elementos, sus propiedades externamente visibles y la relación entre ellos"
"Propiedades externamente visibles: qué es lo que debe saber/suponer un componente sobre otro?"
Por último :
"
Toda la arquitectura es diseño, pero no todo el diseño es arquitectura. La arquitectura representa las decisiones de diseño significativas que le dan forma a un sistema, donde lo significativo puede ser medido por el costo del cambio". (Grady Booch)

Creo que es la más simple y directa definición de arquitectura.

Basándonos en esta última definición podemos suponer que lo que distingue a la arquitectura de otro tipo de diseño es la significancia expresada en la dificultad ó costo del cambio.
La arquitectura del soft mantiene unidas las nociones de : diseño, estructura, estilo, racionalidad, proceso y costo.
Ahora bien, como podemos evaluar la calidad de una determinada arquitectura para nuestra solución de software? , quizás una buena arquitectura sea aquella en la que las decisiones de diseño significativas se lograron minimizar, evitando riesgos de cambio futuros. De esta forma estaríamos libres de cambiar varios aspectos del sistema sin el miedo a que tales cambios produzcan cascada de errores y cambios en el diseño que nos llevarían a altos costos de mantenimiento. Una buena arquitectura debe ser sustentable.

Como se relaciona esta visión de la arquitectura con la estructura del sistema?, pues construyamos componentes, clases, paquetes, ensamblados, etc. que sean altamente cohesivos y con bajo acoplamiento (nuestro ying y yang recuerdan?).
En una arquitectura con bajo acoplamiento, donde los puntos de variación futuras estén bien encapsulados, los efectos del cambio estarán bien aislados y el costo será relativamente bajo.
Por esto es que a nivel de arquitectura hablamos de los patrones de diseño, que nos permiten el desarrollo de mejores arquitecturas de software como por ejemplo la 3 capas explicada y ejemplificada en previos posts.

sábado, 22 de septiembre de 2007

Sigamos solucionando nuestro diseño con los patrones

Siguiendo con nuestra charla de diseño, determinemos la granularidad de los objetos intervinientes .
Los objetos varían enormemente en tamaño y número, y representan cualquier cosa desde hard a sistemas completos, por lo que como decidir que debería ser un objeto?
Veamos algunos patrones:
  • Fachada (GoF) describe como representar subsistemas ó procesos completos como objetos.
  • FlyWeight(GoF) describe como permitir un gran número de granularidad muy fina.
  • Abstract Factory (GoF) produce objetos cuya única resp. es crear otros objetos.
  • Visitor y Command (GoF) generan objetos cuya resp. es implementar una petición en otros objs. ó grupo de objs.

Especificar las interfaces de los objs.

Los patrones nos ayudan a definir interfaces identificando sus elementos clave y los tipos de datos que se envían a la interfaz. También especifican relaciones entre interfaces, ya que: requieren que algunas clases tengan interfaces parecidas ó les imponen restricciones; por ej:

Decorador y Proxy (GoF) requieren que las interfaces de sus objs. sean idénticos a los objs. deocrado y representado, respectivamente.

Especificar las implementaciones

Herencia de clases vs. herencia de interfaces, muchos de los patrones de diseño dependen de esta distinción. Por ej:

  • Los objs. de una cadena en Chain of Responsability (GoF) deben tener un tipo en común, pero normalmente no comparten la misma implementación.
  • En Composite (GoF), el componente define una interfaz común mientras que el compuesto suele definir una implementación en común.
  • Command, Observer, State y Strategy (GoF) suelen implementarse con clases abstractas que son interfaces puras.

En este tema, debemos tener en mente uno de los principios fundamentales del diseño OO: programar para interfaces, no para una implementación. Por que?

  • Ventajas de manipular objs. solamente en términos de la interfaz definida por las clases abstractas. Los clientes no tienen que conocer los tipos específicos de los objs. que usan, basta con que estos adhieran a la interfaz que esperan que esperan los clientes.
  • Reducción del acoplamiento entre subsistemas.
  • No se deben declarar variables como instancias de clases concretas, se ajustan simplemente a la interfaz definida por una clase concreta.
  • Para crear instancias de clases concretas usamos los patrones de creación; estos ofrecen distintos modos de asociar una interfaz con su implementación de manera transparente, y aseguran que el sistema se codifique en términos de interfaces, no de implementación.

Por último, pongamos a funcionar los mecanismos de reutilización:

Herencia vs. Composición

Son las 2 técnicas más comunes para reutilizar funcionalidad en sistemas OO.

La composición requiere que los objs. tengan en cta. las interfaces de otros, lo cual requiere interfaces cuidadosamente diseñadas, que no impidan que un obj. sea utilizado por otros. Optar por la composición ayuda a mantener cada clase encapsulada y centrada en una sola tarea. En los patrones de diseño veremos esta técnica aplicada una y otra vez...otro principio fundamental: favorecer la composición de objetos frente a la herencia de clases.

Pero qué es la composición?: método por el cual una nueva funcionalidad se obtiene mediante la creación de un objeto compuesto por otros objetos, ésta se logra delegando funcionalidad a uno de los objs. de la composición.

Mientras que la Herencia es un método por el cual la nueva funcionalidad se obtiene mediante la extensión de la implementación de un objeto existente. La superclase (generalización) captura los métodos y atributos comunes, y las subclases (especializadas) extienden la implementación con métodos y atrib. adicionales. Es más sencilla de llevar a cabo que la composición, pero...

Desventajas de la herencia:

  • Rompe la encapsulación, ya que expone la subclase a los detalles de implementación de su superclase
  • Reutilización de caja blanca, porque los detalles internos de la superclase son visibles a las subclases
  • Las subclases han de cambiar si la implementación de la superclase cambia

Entonces que usamos?, según Coad, solo utilizar herencia cuando:

  • una subclase expresa "es un tipo de" y no "es un rol desempeñado por".
  • una instancia de una subclase nunca necesita convertirse en un obj. de otra clase
  • una subclase extiende las resp. de su superclase, no las redefine ni las anula.
  • para una clase del problema del dominio actual, la subclase especializa un rol ó una transacción.

Por último utilicemos la Delegación cuando no existan relaciones estáticas entre clases, cuando la herencia no tenga sentido, por ej. para gestionar Roles.

Bien, como vemos obtener un buen diseño es difícil; lo primero que deberíamos saber es : que es un buen diseño?, los conceptos que detallamos antes nos ayudan a dilucidar esta pregunta. Lo segundo será aplicar los principios de diseño de forma sistemática, una buena solución es copiar a los que saben: aplicar los patrones, donde puedan aplicarse.

sábado, 8 de septiembre de 2007

Siguiendo con nuestra charla sobre como los patrones pueden socorrernos en nuestros difíciles momentos de diseño, veamos como "encontrar los objs. apropiados para asignarles responsabilidades".
Coincidamos en que lo más complicado del DOO es descomponer un sistema en objetos.
Para lograr este objetivo, resumamos las tareas del análisis:
  • Partimos de encontrar los conceptos de nuestro dominio de problema y así efectuar un modelo conceptual donde identificamos las clases que surgen del negocio (nuestros objs. de negocio) y sus asociaciones.
  • Luego deberíamos obtener diag. de secuencia del sistema (basados en nuestros CU) donde determinemos los eventos y operaciones del sistema
  • En este punto sería importante obtener los "contratos" de los CU, donde se responderá: que hacen las operaciones del sistema?. Mediante la descripción de las postcondiciones de los contratos podemos describir cómo cambia el sistema tras cada operación; esta descripción se realiza en términos de : creación y destrucc. de objetos, asociac. formadas y canceladas y modificac. de atributos.
Con toda esta documentación podremos comenzar nuestra tarea creativa más importante en el desarrollo de un sistema: el DISEÑO.
Ahora asignemos responsabilidad a nuestros objetos, aunque aclaremos que existen 2 categorías de responsabilidades: de Conocer y de Hacer.

Conocer

  • los datos privados encapsulados
  • los objetos relacionados
  • las cosas que puedan derivarse ó calcular

Hacer

  • algo el mismo: crear un obj. ó hacer un cálculo
  • iniciar una acción en otros objs.
  • controlar y coordinar actividades en otros objs.

Para asignar responsabilidad a nuestros objs. , hablemos de 3 patrones Grasp: Experto en información, Creador y Controlador. (es.wikipedia.org/wiki/Grasp)

experto en informac.: asignar la resp. a la clase que tiene la informac. necesaria para realizarla. Esto debe hacerse sin generar nuevos acoplamientos, manteniendo la cohesión alta.

creador: asignar a la clase B la resp. de crear un obj. de la clase A si se cumple que:

  • B agrega objs. de A
  • B contiene objs. de A
  • B registra objs. de A
  • B usa objs. de A cercanamente (directa)
  • B tiene los datos de inicialización que se pasan a un obj. A cuando es creado

Debemos agregar que muy a menudo la creación de un obj. es de alta complejidad, por lo que sería aconsejable delegar la creación a clases auxiliares llamadas "Fábricas" (factorys)

controlador: asignar la resp. de recibir ó gestionar un mensaje de evento del sistema a una clase que:

  • represente el sistema global ó subsistema (Fachada)
  • represente un escenario de CU en el que tiene lugar el evento (controladora de CU ó sesión)

Tener en cuenta que un controlador debería delegar en otros objs. el trabajo que se necesita hacer, sólo coordina y controla la actividad (compuesta de varias tareas).

Seguimos en el próximo....



viernes, 7 de septiembre de 2007

Principios de diseño - Como llegamos a los Design Patterns??



En una charla con mis alumnos de último año, intenté describir el proceso de pensamiento que nos lleva a la aplicación de los patrones de diseño.


Para empezar debemos recordar los conceptos básicos del diseño (no exclusivos del DOO), nuestro ying y yang : Acoplamiento y Cohesión, el 1ro. que determina el nivel de dependencia y el 2do. el nivel de unión interno (realizar una única función)

OK, teniendo en mente aquello, intentemos comprender los términos: Responsabilidad e independencia, con un diagrama UML de paquetes.

Por ej.:
Un paquete X del cual dependen muchos paquetes debe ser muy estable. No debe cambiar porque es Responsable de los 3 paquetes que dependen de él.
  • X es Independiente, no depende de nadie.
  • Su Estabilidad = Responsabilidad + Independencia


Existe alguna medida sencilla para saber que tan estable es un paquete?

Factor de Inestabilidad (I) => I=(Ce / (Ca + Ce)). Si I[0,1]=0 será totalmernte estable.

Donde : Ca (cuan responsable soy?) son clases fuera del paquete que dependen del él. Ce (cuan dependiente soy) son clases del paquete que dependen de clases externas a él.

"La estabilidad de un paquete debe ser proporcional a su nivel de Abstracción" (R.Martin-1996); esto implica que los paquetes con máxima estabilidad deben ser abstractos; y los inestables concretos.

Esto nos lleva a entender que aquellas decisiones de diseño y arquitectura de alto nivel de abstracción no suelen cambiar, así que los situaremos en paquetes estables. Aquí surge una pregunta interesante: como puede un paquete totalmente estable (I=0) ser lo suficientemente flexible como para soportar los cambios?. O sea, mejorarlo sin cambiarlo.
Respuesta, otro principio : Abierto-Cerrado. Clases que puedan ser extendidas sin modificar lo ya existente: clases abstractas.

Ahora bien, cuando intentamos seguir estos principios básicos del diseño, descubrimos que las estructuras que desarrollamos para cumplirlos, se repiten una y otra vez; esto es lo que conocemos como "Patrón de diseño". Estos deben ser soluciones probadas a los problemas de diseño más comunes, resolviéndonos los sig. puntos:

  1. Encontrar los obj. apropiados para asignarles responsabilidad.
  2. Determinar la granularidad (su nivel de abstracción) de los objetos.
  3. Especificar sus interfaces.
  4. Especificar las implementaciones que deben tener los objs. involucrados.
  5. Poner a funcionar los mecanismos de reutilización

Ahora debemos diferenciar 2 viejas categorías de patrones de diseño: GRASP y GoF

Los GRASP no implementan las soluciones, más bien nos llevan a pensar en el diseño, a nivel de principios generales (más principios de DOO...); mientras que los GoF nos dan una solución implementable con su propio diagrama de clases que nos muestra la forma en que debemos usarlos.

En próximas notas iremos viendo los patrones relacionados con cada uno de los 5 puntos que nos resuelven los patrones (patterns).