Patrones de diseño GoF (Gang of Four)

En anteriores post, hemos visto algunos de los patrones que son parte del GOF. Pero como una imagen vale más que mil palabras, aquí les dejo este link en donde podrán encontrar un excelente PDF con los diagramas UML de los principales patrones.

Esta no es la única opción, ya que también existe el poster de Head Fisrt Design Patterns, pero que a diferencia de la opción anterior, esta utlima es pagada.

Este es un poster que Cerebro no puede dejar de tener!!

El patrón “Cadena de Responsabilidad” (Chain of Responsibility) - Parte VI

Los últimos ataques han sido todo un éxito, cada día se logran nuevas conquistas!!!. Debido a esto, Cerebro se ha visto en la necesidad de aumentar el número de robots dentro de sus tropas. Ahora su ejército se encuentra organizado en una estructura jerárquica, para lo cual ascendió a sus mejores solados a rangos como “General” o “Coronel”.

Con esta nueva estructura será mucho fácil dar órdenes a su ejército, el simplemente dará la orden a su “General Mazinger Z” quien al leer el comunicado decidirá si debe ejecutarla el o deberá derivarla a un sub-alterno; y así sucesivamente en la jerarquía hasta llegar al “Soldado El Galactico”.

Genial…..como siempre este plan es simple……es magnífico……es perfecto…….pero!!!!!!!

Cerebro se ha dado cuenta nuevamente que ha olvidado algo muy importante, su mecanismo de comunicación (implementado con el patrón “Observador”) ya no le sirve. Ahora tiene una estructura jerárquica, y necesita que la orden pase a través de esta estructura hasta el sub-alterno al que se le desee enviar este mensaje. Por lo tanto necesita un mecanismo en el cual el receptor del mensaje pueda no solo ejecutar la orden, sino también poder comunicar esta a su sub-alterno en el caso de que no fuera dirigida a él.

Una solución sería ir replicando el patrón “Observador” en cada uno de sus niveles jerárquicos, pero esta no es la solución más optima..

Debido a todos estos problemas, recurre nuevamente a su gurú “Martin Fowler” y encuentra la solución perfecta!!!!. Cerebro ha visto que el patrón “Cadena de Responsabilidad” (Chain of Responsibility) es ideal para solucionar su problema.

Primero necesitara definir la clase “Mensaje”, la cual contendrá a quien esta dirigida la orden y cuáles son las instrucciones a ejecutar.

package cadena.de.responsabilidad;<br /><br />public class Mensaje {<br /><br /> private String para;<br /> private String contenido;<br /><br /> public Mensaje(String para, String contenido) {<br /> this.para = para;<br /> this.contenido = contenido;<br /> }<br /><br /> public String getPara() {<br /> return para;<br /> }<br /><br /> public void setPara(String para) {<br /> this.para = para;<br /> }<br /><br /> public String getContenido() {<br /> return contenido;<br /> }<br /><br /> public void setContenido(String contenido) {<br /> this.contenido = contenido;<br /> }<br /> <br />}

Luego, deberá definir la clase abstracta “EjecutarOrdenAltoMando”, la cual deberán extender cada uno de los elementos de su ejército.

package cadena.de.responsabilidad;<br /><br />abstract class EjecutarOrdenAltoMando {<br /><br /> protected EjecutarOrdenAltoMando subAlterno;<br /><br /><br /> public void setSubAlterno(EjecutarOrdenAltoMando subAlterno){<br /> this.subAlterno = subAlterno;<br /> }<br /><br /> public abstract void ejecutarOrden(Mensaje mensaje);<br /><br />}

Ahora, cada sub-alterno que extienda la clase abstracta, deberá definir un mecanismo que permita discriminar si la orden enviada la debe ejecutar el, o en caso contrario, enviar la orden a su sub-alterno.

package cadena.de.responsabilidad;<br /><br />class GeneralMazingerZ extends EjecutarOrdenAltoMando {<br /><br /> public void ejecutarOrden(Mensaje mensaje){<br /> if (mensaje.getPara().equals("OrdenGeneral")){<br /> System.out.println(mensaje.getContenido());<br /> }<br /> else if (subAlterno != null){<br /> subAlterno.ejecutarOrden(mensaje);<br /> }<br /> }<br /><br />}

package cadena.de.responsabilidad;<br /><br />class CoronelElVengador extends EjecutarOrdenAltoMando {<br /><br /> public void ejecutarOrden(Mensaje mensaje){<br /> if (mensaje.getPara().equals("OrdenCoronel")){<br /> System.out.println(mensaje.getContenido());<br /> }<br /> else if (subAlterno != null){<br /> subAlterno.ejecutarOrden(mensaje);<br /> }<br /> }<br /><br />}

package cadena.de.responsabilidad;<br /><br />class SoldadoElGalatico extends EjecutarOrdenAltoMando {<br /><br /> public void ejecutarOrden(Mensaje mensaje){<br /> if (mensaje.getPara().equals("OrdenSoldado")){<br /> System.out.println(mensaje.getContenido());<br /> }<br /> else{<br /> System.out.println("EL TIPO DE ORDEN NO EXISTE");<br /> }<br /> }<br /><br />}

Finalmente, será muy fácil para Cerebro enviar un mensaje a su ejército, el simplemente dará la orden a su “General” y listo!!

package cadena.de.responsabilidad;<br /><br />public class Cerebro {<br /><br /> public static Mensaje[] generarMensajes(){<br /> Mensaje mensajes [] = {<br /> new Mensaje("OrdenGeneral", "Ejecutar Orden General Mazinger Z"),<br /> new Mensaje("OrdenCoronel", "Ejecutar Orden Coronel El Vengador"),<br /> new Mensaje("OrdenSoldado", "Ejecutar Orden Soldado El Galatico"),<br /> new Mensaje("OrdenCoronel", "Ejecutar Orden Coronel El Vengador"),<br /> new Mensaje("OrdenGeneral", "Ejecutar Orden General Mazinger Z"),<br /> new Mensaje("OrdenSoldado", "Ejecutar Orden Soldado El Galatico") <br /> };<br /> return mensajes;<br /> }<br /><br /> public static EjecutarOrdenAltoMando configurarCadena(){<br /> EjecutarOrdenAltoMando generalMazingerZ = new GeneralMazingerZ();<br /> EjecutarOrdenAltoMando coronelElVengador = new CoronelElVengador();<br /> EjecutarOrdenAltoMando soldadoElGalatico = new SoldadoElGalatico();<br /> generalMazingerZ.setSubAlterno(coronelElVengador);<br /> coronelElVengador.setSubAlterno(soldadoElGalatico);<br /> return generalMazingerZ;<br /> }<br /><br /> public static void main(String[] args) {<br /> EjecutarOrdenAltoMando generalMazingerZ = configurarCadena();<br /> for(Mensaje mensaje : generarMensajes()){<br /> generalMazingerZ.ejecutarOrden(mensaje);<br /> }<br /> }<br /><br />}

Cerebro lo ha conseguido nuevamente, ha logrado diseñar un nuevo mecanismo de comunicación para su ejército, continuando su malvado plan………“TRATAR DE CONQUISTAR AL MUNDO!!!!”

El patrón "Memento" - Parte V

Cerebro se siente preparado para llevar a cabo su malvado plan. Tiene los conocimientos teóricos, tiene los conocimientos prácticos, pero hay tantos detalles que pulir antes de lanzarse a la conquista del mundo!.

En los ejemplos anteriores, hemos visto como Cerebro ha implementado el “Patron Prototype” (para crear su ejército de robots clones), el “Patron Extension Objects” (para asignarles sus roles), el “Patron Command” (para asignarles las ordenes), y el ”Patron Observer” (para implementar el sistema de comunicaciones). Parece que Cerebro ha estado bastante ocupado implementando patrones, pero ha sido suficiente?. NO!!.

Si recuerdan el “Patron Observer”, dejamos a los robots “Mazinger Z” y “El Vengador” en el instante previo al ataque final. Están esperando a recibir la orden de ataque. Cada robot esta alerta, escuchando la radio, esperando escuchar la señal secreta, para abandonar su posición y lanzarse a cumplir las órdenes recibidas.

Cerebro está a punto de presionar el botón de "Atacar", cuando de repente se da cuenta de que algo no está bien. Qué pasa si me veo obligado a dar la orden de retirada a mis tropas?. No es que mi plan vaya a fallar (después de todo soy un genio del mal), pero ya se sabe, no se puede confiar en los subordinados, y que pasa si tengo que cancelar el ataque cuando mis huestes ya han comenzado a avanzar?.

Ciertamente, Cerebro es un genio. Se ha dado cuenta de un sutil error en su plan. Qué pasaría si tiene que dar la orden de cancelar el ataque cuando sus tropas ya han abandonado su posición inicial?. Bueno, ha implementado un mecanismo de comunicaciones, así que puede mandar la señal secreta de retirada, no?. Pero hay un problema; los robots “Mazinger Z” y “El Vengador” no implementan un buen sistema del manejo de la memoria (sabía que no tenía que instalarles Windows!!!!).

La cuestión es complicada. Un robot “Mazinger Z” y “El Vengador” no tienen buen manejo de la memoria. Solo pueden recordar una cosa a la vez. Por tanto, pueden recordar que tienen que atacar, que tienen que moverse hacia algún lugar, pero en cuanto se meten esa información en la memoria no son capaces de recordar nada más.

Dicho de otra forma, Cerebro les puede decir que vuelvan a su posición original, pero eso no va a servir de nada, porque no se acuerdan de cuál era su posición original.

Peeeeeero, Cerebro recuerda vagamente, como entre una nebulosa, haber leído algo del “Patron Memento” de su gurú “Martin Fowler”.

Qué pasaría si cada robot “Mazinger Z” y “El Vengador” fuera capaz de escribir en un cuaderno su posición inicial, y entregara ese cuaderno a su Sargento?. Y si el Sargento guardara esos cuadernos, y se los entregara a sus propietarios en el caso de que necesitasen volver a las posiciones iníciales?. Problema resuelto!. Es perfecto!. Las ovejas y las vacas solo tendrán que recordar una posición (la posición hacia la que se supone que tiene que ir, sin importar si están atacando o están en retirada), mientras una entidad externa les guardara la información que necesitaran para retirarse.

Pero cómo puede un robot “Mazinger Z” o “El Vengador” guardar su información relevante en un cuaderno?. Fácil, cada robot será responsable de crear una instancia de la clase en la que se va a guardar su información interna, y la entregara a su sargento.

package memento.paso1;<br /><br />public class MazingerZMemento {<br /><br /> private int numeroSerie;<br /> private String ubicacion;<br /><br /> public MazingerZMemento(int numeroSerie, String ubicacion) {<br /> this.numeroSerie = numeroSerie;<br /> this.ubicacion = ubicacion;<br /> }<br /><br /> public String getUbicacion() {<br /> return ubicacion;<br /> }<br /><br /> public void setUbicacion(String ubicacion) {<br /> this.ubicacion = ubicacion;<br /> }<br /><br />}

Un momento!. Cerebro se ha dado cuenta de que hay un punto débil en su plan. Si el Sargento guarda los cuadernos con las posiciones iníciales de los robots, hay riesgos de seguridad. Qué pasa si los enemigos roban esa información?. O incluso peor!!. Y si los enemigos no roban esa información, pero la sustituyen por información falsa?. Pero……un momento!. Si la información contenida en los cuadernos estuviera encriptado, o solo fuera accesible por los robots, el problema estaría resuelto, nadie podría cambiarla!.

Por tanto, para evitar posibles cambios en esa información, Cerebro va a tomar dos medidas drásticas. Por un lado, todos los valores guardados en la clase MazingerZMemento solo se podrán asignar a través del constructor. De ese modo, Cerebro se asegura que solo se podrán asignar al crear la clase, y nunca después.

Pero desgraciadamente, no es suficiente (es tan difícil conseguir un buen plan…uffff). Cerebro quiere evitar que la información guardada en el “Memento” sea modificada. De hecho, quiere que solo sea el robot “Mazinger Z” o “El Vengador”, el que pueda crear su memento correspondiente, y asignar sus valores. De esa forma, puede asegurarse de que nadie modifique esa información.

Hacer eso en Java es bastante fácil. Basta con colocar la clase MazingerZMemento en el mismo package que la clase "MazingerZ", y hacer tanto su constructor como sus variables de clase protected. De esa forma, solo pueden crear instancias de esa clase otras clases que estén en su mismo paquete.

Por tanto la clase “MazingerZ” es:

package memento.paso2;<br /><br />public class MazingerZMemento {<br /><br /> protected int numeroSerie;<br /> protected String ubicacion;<br /><br /> protected MazingerZMemento(int numeroSerie, String ubicacion) {<br /> this.numeroSerie = numeroSerie;<br /> this.ubicacion = ubicacion;<br /> }<br /><br />}

package memento.paso2;<br /><br />public class MazingerZ {<br /><br /> private int numeroSerie;<br /> private String ubicacion;<br /><br /> public MazingerZ(int numeroSerie, String ubicacion) {<br /> this.numeroSerie = numeroSerie;<br /> this.ubicacion = ubicacion;<br /> }<br /><br /> public MazingerZMemento getMemento() {<br /> return new MazingerZMemento(numeroSerie, ubicacion);<br /> }<br /><br /> public void setMemento(MazingerZMemento memento) {<br /> numeroSerie = memento.numeroSerie;<br /> ubicacion = memento.ubicacion;<br /> }<br /><br /> public String getUbicacion() {<br /> return ubicacion;<br /> }<br /><br /> public void setUbicacion(String ubicacion) {<br /> this.ubicacion = ubicacion;<br /> }<br /><br /> public String toString() {<br /> return "MazingerZ : numeroSerie " + numeroSerie + " ubicacion " + ubicacion;<br /> }<br /><br />}

package memento.paso2;<br /><br />public class Sargento {<br /><br /> public void atacar() {<br /> MazingerZ mazingerZ = new MazingerZ(1, "5.2345");<br /> MazingerZMemento estadoInicial = mazingerZ.getMemento();<br /> System.out.println("posicion inicial");<br /> System.out.println(mazingerZ);<br /> System.out.println("cambiar esta posicion");<br /> mazingerZ.setUbicacion("2.9961");<br /> System.out.println("nueva posicion");<br /> System.out.println(mazingerZ);<br /> System.out.println("volver a la ubicacion inicial!");<br /> mazingerZ.setMemento(estadoInicial);<br /> System.out.println(mazingerZ);<br /> }<br /><br /> public static void main(String[] args) {<br /> Sargento sargento = new Sargento();<br /> sargento.atacar();<br /> }<br /><br />}

Cerebro lo ha conseguido de nuevo!!. Ha sido capaz de encapsular el estado interno de un objeto en otro objeto distinto, y encapsularlo tan bien que ese segundo objeto solo puede ser utilizado por el objeto que lo creo.

Ya está todo listo para conquistar al mundo!!!!!!!!

Parte 6

El patrón "Observer" (Observador) - Parte IV

Esta desencadenado!!!!! El primer ataque ha sido lanzado. Cerebro ha dado las órdenes a sus tropas para dominar el mundo.

En los ejemplos anteriores hemos visto como Cerebro ha conseguido clonar cualquier robot utilizando un “Patron Prototype”, ha conseguido darles un rol dinámicamente con el “Patron Extension Objects”, y ha repartido las ordenes con un “Patron command”.

Pero como ya sabemos, Cerebro está loco, pero no es tonto. Sabe, que algo puede salir mal, que un pequeño detalle puede destruir sus planes de dominar el mundo. Pero también sabe que una retirada a tiempo es una victoria.

Por lo tanto, ha equipado a sus tropas de una radio de comunicaciones. Pero, porque ha hecho esto?. Sencillo, en el fragor de la batalla, las comunicaciones directas se hacen complicadas. Es difícil hacer llegar las ordenes, y muchas veces no se tiene claro a quien le estamos dando esas órdenes ( será a “Mazinger Z” o “El Vengador”? ). Conquistar el mundo no es fácil, de hecho muchos lo han intentado pero no lo han conseguido.

Cerebro ha estudiado con detenimiento todos los intentos anteriores para no reproducir los mismos errores que otros han cometido. Qué pasaría si para dar nuevas órdenes, necesitase que el sargento “Mazinger Z” tuviese que recorrer la trinchera indicando uno por uno a todos los robots que se retirasen?. Desde que le diese la orden al primer robot, hasta que se la diese al último, pasaría un tiempo precioso. Además, y si ocurre algo por el camino?. Las posibilidades de que las órdenes no lleguen a todos los integrantes de la tropa son amplias.

Sabiendo esto, Cerebro recurre nuevamente a su gurú “Marin Fowler” y decide hacer un cambio fácil y rápido el comportamiento de sus tropas, utilizando el “Patron Observer”.

Como Cerebro no es tonto, ha encontrado una malvada forma de enviar las órdenes a sus tropas. Los robots “Mazinger Z” y “El Vengador”, estarán equipados con una radio que sintoniza “La señal del mal”. Sus tropas estarán atentas a la radio, y cuando esta emita una canción de “Metallica” les indicara que acción deben tomar.

El código sería algo así:

package observer.paso1;<br /><br />public class Mensaje {<br /><br /> private String mensaje = "";<br /><br /> public String getMensaje() {<br /> return mensaje;<br /> }<br /><br /> public void setMensaje(String mensaje) {<br /> this.mensaje = mensaje;<br /> }<br /><br />}

package observer.paso1;<br /><br />public interface Observador {<br /><br /> public void actualizar(Mensaje informacion);<br /><br />}

package observer.paso1;<br /><br />public interface Sujeto {<br /><br /> public void addObservador(Observador obs);<br /><br /> public void removerObservador(Observador obs);<br /><br /> public void notificarObservador();<br /><br />}

package observer.paso1;<br /><br />public class MazingerZ implements Observador {<br /><br /> public MazingerZ() {<br /> System.out.println("Construyendo robot Mazinger Z");<br /> }<br /><br /> private void mostrar(String arg) {<br /> System.out.println("Mazinger Z : " + arg);<br /> }<br /><br /> public void actualizar(Mensaje mensaje) {<br /> mostrar("Actualizado");<br /> String kk = mensaje.getMensaje();<br /> mostrar("Mensaje de texto : " + kk);<br /> }<br /><br />}

package observer.paso1;<br /><br />public class ElVengador implements Observador {<br /><br /> public ElVengador() {<br /> System.out.println("Construyendo robot El Vengador");<br /> }<br /><br /> private void mostrar(String arg) {<br /> System.out.println("El Vengador : " + arg);<br /> }<br /><br /> public void actualizar(Mensaje mensaje) {<br /> mostrar("Actualizado");<br /> String kk = mensaje.getMensaje();<br /> mostrar("Mensaje de texto : " + kk);<br /> }<br /><br />}

package observer.paso1;<br /><br />import java.util.ArrayList;<br /><br />public class Cerebro implements Sujeto {<br /><br /> private ArrayList misObservadores;<br /> private Mensaje mensaje;<br /><br /> public Cerebro(){<br /> mostrar("Creando a Cerebro");<br /> misObservadores = new ArrayList();<br /> }<br /><br /> public void mostrar(String arg){<br /> System.out.println("Cerebro : "+arg);<br /> }<br /><br /> public void addObservador(Observador observador){<br /> mostrar("Anadido un nuevo Observador");<br /> misObservadores.add(observador);<br /> mostrar("Ya tengo : " + misObservadores.size() + " observadores ");<br /> }<br /><br /> public void removerObservador(Observador observador){<br /> mostrar("Eliminando un observador");<br /> misObservadores.remove(observador);<br /> mostrar("ahora me quedan : " + misObservadores.size() + " observadores ");<br /> }<br /><br /> public void notificarObservador(){<br /> mostrar("notificar observador");<br /> mensaje = new Mensaje();<br /> mensaje.setMensaje("En la nave");<br /> for( int i = 0; i < misObservadores.size(); i++ ){<br /> Observador observador = (Observador) misObservadores.get(i);<br /> observador.actualizar(mensaje);<br /> }<br /> }<br /><br />}

package observer.paso1;<br /><br />public class Test {<br /><br /> public static void main(String[] args) {<br /> Cerebro cerebro = new Cerebro();<br /> MazingerZ mazingerZ1 = new MazingerZ();<br /> ElVengador elVengador1 = new ElVengador();<br /> MazingerZ mazingerZ2 = new MazingerZ();<br /> ElVengador elVengador2 = new ElVengador();<br /> MazingerZ mazingerZ3 = new MazingerZ();<br /> ElVengador elVengador3 = new ElVengador();<br /> cerebro.addObservador(mazingerZ1);<br /> cerebro.addObservador(mazingerZ2);<br /> cerebro.addObservador(mazingerZ3);<br /> cerebro.addObservador(elVengador1);<br /> cerebro.addObservador(elVengador2);<br /> cerebro.addObservador(elVengador3);<br /> cerebro.removerObservador(mazingerZ1);<br /> cerebro.notificarObservador();<br /> }<br /><br />}

De este modo, Cerebro se puede comunicar rápidamente con todas sus tropas. Es brillante, es genial, es maravilloso, es.........perfecto?. Bueno, la verdad es que está muy bien, pero imaginemos por un momento, una situación en la que un robot consigue infiltrarse en el alto mando enemigo, y descubre que el enemigo está a punto de ser derrotado, y justo en ese momento de éxtasis, la radio emite “The Call of Ktulu" (la canción que indica a las tropas que hay que retirarse).

NOOOOOOOOO (bueno, esto está traducido, claramente, un robot diría algo así como BEP-BEP-BEP). Nuestro robot espía, tiene una información valiosísima, pero que no puede comunicar a su alto mando, porque la forma de transmisión es únicamente de tipo “Push” (desde Cerebro a sus tropas), por lo que no hay retorno.

Qué situación, el robot necesita transmitir que el ataque debe continuar pero......jajajajajajajaja, Cerebro ha pensado en ello, y ha decidido implementar un “Patron observer” que permita la transmisión tipo “Push” (del sujeto emisor a todos los sujetos receptores) y tipo “Pull” (uno de los objetos receptores, puede solicitar una información al objeto emisor para que este la envié a todos los demás). Así, nuestro robot espía, estará equipado con un número de teléfono al que podrá llamar y solicitar que emitan "Master of Puppets", y cuando esta canción sea emitida por la radio, los robots “Mazinger Z” y “El Vengador” que la escuchen, sabrán que ha llegado el momento de la ofensiva final!!!. Para ello, Cerebro deberá modificar ligeramente su código.

El primer paso será que nuestro sujeto, implementara un nuevo método que hemos añadido a la interfaz Sujeto( solicitarInformacion ), que permitirá recibir las llamadas telefónicas del robot espía. Veremos también que el constructor de los robots “Mazinger Z” y “El Vengador” también ha cambiado un poco. Ahora estos robots, almacenaran una referencia al constructor. También modificaremos el código de nuestro robot “Mazinger Z” (suponemos que este será el robot espía en el momento en que decide que pese a lo que emite la radio, hay que atacar y pide que se emita “Master of Puppets” que es otra señal de ataque ).

El código final sería algo así:

package observer.paso2;<br /><br />import observer.paso1.Mensaje;<br />import observer.paso1.Observador;<br /><br />public interface Sujeto {<br /><br /> public void addObservador(Observador obs);<br /><br /> public void removerObservador(Observador obs);<br /><br /> public void notificarObservador(Mensaje mensaje);<br /><br /> public void solicitarInformacion(String arg);<br /><br />}

package observer.paso2;<br /><br />import observer.paso1.Mensaje;<br />import observer.paso1.Observador;<br /><br />public class MazingerZ implements Observador {<br /><br /> private Sujeto cerebro;<br /><br /> public MazingerZ(Sujeto sujeto) {<br /> mostrar("creando a Mazinger Z");<br /> this.cerebro = sujeto;<br /> this.cerebro.addObservador(this);<br /> this.cerebro.solicitarInformacion("Master of Puppets");<br /> }<br /><br /> private void mostrar(String arg) {<br /> System.out.println("Mazinger Z : " + arg);<br /> }<br /><br /> public void actualizar(Mensaje mensaje) {<br /> mostrar("Actualizandome : " + mensaje.getMensaje());<br /> }<br /><br />}

package observer.paso2;<br /><br />import observer.paso1.Mensaje;<br />import observer.paso1.Observador;<br /><br />public class ElVengador implements Observador {<br /><br /> public ElVengador(){<br /> mostrar("creando a El Vengador");<br /> }<br /><br /> private void mostrar(String arg) {<br /> System.out.println("El Vengador : " + arg);<br /> }<br /><br /> public void actualizar(Mensaje mensaje) {<br /> mostrar("Actualizandome : " + mensaje.getMensaje());<br /> }<br /><br />}

package observer.paso2;<br /><br />import java.util.ArrayList;<br /><br />import observer.paso1.Mensaje;<br />import observer.paso1.Observador;<br /><br />public class Cerebro implements Sujeto{<br /><br /> private ArrayList misObservadores;<br /><br /> public Cerebro(){<br /> mostrar("Creando un nuevo Cerebro");<br /> misObservadores = new ArrayList();<br /> }<br /><br /> public void mostrar(String arg){<br /> System.out.println("Cerebro : "+arg);<br /> }<br /><br /> public void addObservador(Observador obs){<br /> mostrar("Anadido un nuevo observador");<br /> misObservadores.add(obs);<br /> mostrar("Ya tengo : " + misObservadores.size() + " observadores ");<br /> }<br /><br /> public void removerObservador(Observador obs){<br /> mostrar("Eliminando observador");<br /> misObservadores.remove(misObservadores.indexOf(obs));<br /> mostrar("ahora me quedan : " + misObservadores.size() + " observadores ");<br /> }<br /><br /> public void notificarObservador(Mensaje msg ){<br /> mostrar("notificar observadores");<br /> for( int i = 0; i < misObservadores.size(); i++ ){<br /> Observador obs = (Observador) misObservadores.get(i);<br /> obs.actualizar(msg);<br /> }<br /> }<br /><br /> public void solicitarInformacion(String arg){<br /> mostrar("recibiendo una peticion");<br /> Mensaje mensaje = new Mensaje();<br /> mensaje.setMensaje(arg);<br /> this.notificarObservador(mensaje);<br /> }<br /><br />}

package observer.paso2;<br /><br />public class Test {<br /><br /> public static void main(String[] args) {<br /> Cerebro dispar = new Cerebro();<br /> MazingerZ mazingerZ = new MazingerZ(dispar);<br /> }<br /><br />}

Evidentemente, Cerebro que ha estudiado la API de JAVA y sabe que existe la clase java.util.Observable y la interface java.util.Observer. La primera no la ha utilizado, pues eso implicaría que Cerebro extienda o herede de “Observable”. Esto podría ser posible, pero en realidad Cerebro extiende de una larga extirpe de profesores diabólicos empeñados en conquistar el mundo, y ni quiere ni puede extender de Observable. ( class Cerebro extends ExtirpeDeProfesoresDiabolicos, Observable --> esto no es posible ). Por eso ha decidido construirse su propia interface “Sujeto”.

Con respecto a la interface java.util.Observer, si la podría haber utilizado para que sus robots “Mazinger Z” y “El Vengador” la implementasen en lugar de implementar “Observador”, pero ya saben, los genios del mal les gusta hacer las cosas a su manera.

Esta historia continuara……

PARTE 5

El patrón "Command" - Parte III

Todo está preparado. Cerebro ya cuenta con un gran número de copias de los robots “Mazinger Z” y “El Vengador”. Además, ha asignado los roles a cada uno de estos. Es el momento perfecto para que Cerebro lance su ataque final. Ha llegado el momento de conquistar el mundo!!!!

Pero como dará Cerebro la orden de atacar a sus tropas?.

Cerebro está loco, pero no es idiota. Quiere conquistar el mundo, para lo cual ha ideado un plan malvado perfecto!!!. Pero sabe que tener un buen plan (aunque sea malvado) no es una garantía para el éxito. Necesita un plan de emergencia.

Cerebro quiere que algunos de sus robots soldados participen en el primer (y por tanto, glorioso) ataque. Pero también quiere reservar unos cuantos robots soldados y dejarlos descansando, mientras sus colegas son masacrados en el campo de batalla, para que puedan ser utilizados como refuerzos.

Pero, como podrá hacerlo?. Cerebro es un genio muuuuuy ocupado, por lo tanto el ataque debe poder ser lanzado sin mucha intervención de su parte. Algo tan simple como apretar el botón de "Dominar el Mundo" sería perfecto. Es rápido, es fácil, y Cerebro puede delegar la tarea incluso a Pinky.

Eso sería perfecto, pero para conseguirlo tiene que encontrar la forma de poderle decir a cada robot que es lo que se supone que debe hacer cuando el "glorioso momento del ataque" llegue.

Pero cómo ?. El unico conocimiento que tiene Cerebro de los robots soldados es su interfaz, porque sabe que cada robot soldado implementa la interfaz AccionSoldado.

Resumiendo, lo que en realidad necesita es que algunos robots ejecuten uno de los métodos de AccionSoldado, y otros robots ejecuten uno distinto cuando reciban la orden de atacar.

package command.paso1;<br /><br />public interface AccionSoldado {<br /><br /> public void destruir();<br /><br /> public void mover();<br /><br /> public void esperarPorMasOrdenes();<br /><br />}

package command.paso1;<br /><br />import extensionobject.paso1.AccionesBasicas;<br />import extensionobject.paso1.Rol;<br /><br />public class RolSoldado extends Rol implements AccionSoldado{<br /><br /> private AccionesBasicas sujeto;<br /><br /> public RolSoldado(AccionesBasicas sujeto){<br /> this.sujeto = sujeto;<br /> System.out.println("RolSoldado creado");<br /> }<br /><br /> public void destruir(){<br /> System.out.println("Interfaz soldado destruir");<br /> sujeto.moverBrazos();<br /> }<br /><br /> public void mover(){<br /> System.out.println("Interfaz soldado mover");<br /> sujeto.moverBrazos();<br /> }<br /><br /> public void esperarPorMasOrdenes(){<br /> System.out.println("Estoy esperando por mas ordenes!!!!");<br /> }<br /><br />}

Tanto la interfaz AccionSoldado como la clase RolSoldado no han cambiado.

Cerebro ha logrado crear diez mil robots soldados, y diez mil robots fabricantes, utilizando dos arrays para almacenar una referencia a todos ellos.

Por tanto, al apretar el botón de "Al ataqueeeeeeeeeeeeeee" podría hacer algo así…..

public void atacar( CommandActions aLasArmas [ ] ) {<br /> int contRobots = aLasArmas.length;<br /><br /> for( int idx=0; idx < contRobots; idx++ ) {<br /> aLasArmas [ idx ].ejecutar( );<br /> }<br /><br />}

Cerebro está loco, pero no es un tonto. No le gusta la solución que ha encontrado. Por que?. Bueno, no es exactamente lo que quería. Cerebro simplemente quiere poder decir "Al ataqueeeeeeeee", y comenzar a reírse histéricamente mientras los robots se lanzan ciegamente a cumplir sus órdenes.

Cerebro sospecha que todo podría ser mucho más fácil si pudiera darle a cada uno de los robots un sobre conteniendo sus órdenes. Cuando el "Momento de gloria" llegue, simplemente le tendría que decirle a cada robot que habrá el sobre y obedezca las ordenes contenidas en el. Pero él no quiere saber de qué forma tienen que cumplir esas órdenes los robots, de hecho, ni siquiera quiere saber si le está mandando algo a un robot “Mazinger Z” o “El Vengador”, o a lo que sea.

Pero justo en ese momento, comienza a reírse con más fuerza que nunca. Porque ha recordado el patrón Command.

Cerebro quiere dar cuatro órdenes diferentes. Dos para ser obedecidas por los robots soldado ("ataca", y "espera hasta recibir nuevas órdenes"), y las otras dos dirigidas a los robots fabricantes ( "comienza a construir la fortaleza", y "diseña armas" ).

Para esto, va a encapsular la orden y el receptor de dicha orden, en un paquete ( el sobre ). Cómo?....

En primer lugar, escribirá la siguiente interfaz:

public interface CommandActions {<br /> <br /> public void ejecutar( );<br /><br />}

Y los distintos comandos serán…..

package command.paso3;<br /><br />public interface CommandActions {<br /><br /> public void ejecutar();<br /><br />}

package command.paso3;<br /><br />import command.paso1.AccionSoldado;<br /><br />public class SoldadoAtacar implements CommandActions {<br /><br /> private AccionSoldado recivir;<br /><br /> public SoldadoAtacar(AccionSoldado soldado){<br /> recivir = soldado;<br /> }<br /><br /> public void ejecutar(){<br /> recivir.destruir();<br /> }<br /><br />}

package command.paso3;<br /><br />import command.paso1.AccionSoldado;<br /><br />public class SoldadoEsperar implements CommandActions {<br /><br /> private AccionSoldado recivir;<br /><br /> public SoldadoEsperar(AccionSoldado soldado) {<br /> recivir = soldado;<br /> }<br /><br /> public void ejecutar() {<br /> recivir.esperarPorMasOrdenes();<br /> }<br /><br />}

package command.paso3;<br /><br />import extensionobject.paso1.AccionFabricante;<br /><br />public class FabricanteConstruir implements CommandActions {<br /><br /> private AccionFabricante recivir;<br /><br /> public FabricanteConstruir(AccionFabricante fabricante) {<br /> recivir = fabricante;<br /> }<br /><br /> public void ejecutar() {<br /> recivir.construir();<br /> }<br /><br />}

package command.paso3;<br /><br />import extensionobject.paso1.AccionFabricante;<br /><br />public class FabricanteDisenar implements CommandActions {<br /><br /> private AccionFabricante recivir;<br /><br /> public FabricanteDisenar(AccionFabricante fabricante) {<br /> recivir = fabricante;<br /> }<br /><br /> public void ejecutar() {<br /> recivir.disenar();<br /> }<br /><br />}

Por tanto, cuando Cerebro presione el botón de "al ataqueeeeeeeeee", tendrá que hacer un método algo así:

public void atacar( CommandActions aLasArmas [ ] ) {<br /> int contRobots = aLasArmas.length;<br /> for( int idx=0; idx < contRobots; idx++ ) {<br /> aLasArmas [ idx ].ejecutar( );<br /> }<br />}

Este método recibe como parámetro un array conteniendo todos los comandos. Ese array se podría construir con un código similar a este…..

package command.paso4;<br /><br />import command.paso1.AccionSoldado;<br />import command.paso1.RolSoldado;<br />import extensionobject.paso1.AccionFabricante;<br />import extensionobject.paso1.RolFabricante;<br />import command.paso3.SoldadoAtacar;<br />import command.paso3.SoldadoEsperar;<br />import command.paso3.CommandActions;<br />import command.paso3.FabricanteConstruir;<br />import command.paso3.FabricanteDisenar;<br />import extensionobject.paso2.MazingerZ;<br /><br />public class Disparar {<br /><br /> public Disparar() {<br /> }<br /><br /> public void atacar(CommandActions aLasArmas[]) {<br /> int contRobots = aLasArmas.length;<br /> for (int idx = 0; idx < contRobots; idx++) {<br /> aLasArmas[idx].ejecutar();<br /> }<br /> }<br /><br /> public static void main(String[] args) {<br /> MazingerZ mazingerZ = null;<br /> CommandActions aLasArmas[] = new CommandActions[20];<br /> AccionSoldado accionSoldado = null;<br /> AccionFabricante accionFabricante = null;<br /> SoldadoAtacar soldadoAtacar = null;<br /> SoldadoEsperar soldadoEsperar = null;<br /> FabricanteConstruir fabricanteConstruir = null;<br /> FabricanteDisenar fabricanteDisenar = null;<br /> for (int i = 0; i < 5; i++) {<br /> mazingerZ = new MazingerZ();<br /> mazingerZ.addExtension("RolSoldado", new RolSoldado(mazingerZ));<br /> accionSoldado = (AccionSoldado) mazingerZ.getExtension("RolSoldado");<br /> soldadoAtacar = new SoldadoAtacar(accionSoldado);<br /> aLasArmas[i] = soldadoAtacar;<br /> }<br /> for (int i = 5; i < 10; i++) {<br /> mazingerZ = new MazingerZ();<br /> mazingerZ.addExtension("RolSoldado", new RolSoldado(mazingerZ));<br /> accionSoldado = (AccionSoldado) mazingerZ.getExtension("RolSoldado");<br /> soldadoEsperar = new SoldadoEsperar(accionSoldado);<br /> aLasArmas[i] = soldadoEsperar;<br /> }<br /> for (int i = 10; i < 15; i++) {<br /> mazingerZ = new MazingerZ();<br /> mazingerZ.addExtension("RolCampesino", new RolFabricante(mazingerZ));<br /> accionFabricante = (AccionFabricante) mazingerZ.getExtension("RolCampesino");<br /> fabricanteConstruir = new FabricanteConstruir(accionFabricante);<br /> aLasArmas[i] = fabricanteConstruir;<br /> }<br /> for (int i = 15; i < 20; i++) {<br /> mazingerZ = new MazingerZ();<br /> mazingerZ.addExtension("RolCampesino", new RolFabricante(mazingerZ));<br /> accionFabricante = (AccionFabricante) mazingerZ.getExtension("RolCampesino");<br /> fabricanteDisenar = new FabricanteDisenar(accionFabricante);<br /> aLasArmas[i] = fabricanteDisenar;<br /> }<br /><br /> //A LA TAQUE!!!!<br /> System.out.println("*******************************************");<br /> Disparar cerebro = new Disparar();<br /> cerebro.atacar(aLasArmas);<br /> }<br /><br />}

El código es horrible, pero sirve para ilustrar como Cerebro ha creado una colección de objetos, cada uno de los cuales encapsula un comando y el receptor de dicho comando.

Ahora, Cerebro no necesita saber nada acerca de esos comandos, ni del receptor de los mismos. Simplemente tiene que decir "ejecutar el comando!!", y el comando hará el resto.

De hecho, Cerebro ha conseguido desacoplar tres procesos diferentes: la creación de los objetos (implementando el patrón Prototype ), la asignación de roles a esos objetos ( con el patrón Extension Objects ), y la forma en que esos roles pasan a la acción ( el patron Command ).

Con esto, ha dado un paso más en su malvado plan de CONQUISTAR AL MUNDO!!!!!

PARTE 4

El patrón “Extension Objects” - Parte II

En el episodio anterior, Cerebro logro programar una máquina capaz de crear muchas copias de robots, logrando construir un gran ejército para CONQUISTAR AL MUNDO!!!.

Pero de repente, se dio cuenta que va a necesitar muchos robots del tipo “Mazinger Z” y también del tipo “El Vengador”, pero no todos los robots deberían tener el mismo rol. Por qué?. Bueno, dominar el mundo no es fácil. Hace falta organización. Hace falta un malvado plan!.

Entonces Cerebro ideo un plan. Quiere entrenar a algunos de sus robots como soldados para crear maquinas de matar sin misericordia!!!!.

Pero también quiere que otros robots trabajen en las fábricas haciendo armas, y también necesita que otro grupo de robots trabaje en la construcción de una fortaleza…….ufff.

Por lo tanto, se puede decir que necesita poder asignar distintos roles a los robots que ha construido.

Entonces, Cerebro comienza a pensar…….muy bien, ya tengo una clase que representa un robot “Mazinger Z”, pero ahora necesito tener un “Mazinger Z” que se comporte como un soldado, otro que se comporte como un fabricante, otro como constructor y lo mismo para “El Vengador”. Eso suena a "extender la funcionalidad de una clase", o no?....Brillante!!.

Escribiré una clase “MazingerZSoldado” que extienda a “MazingerZ”, y otra clase, “MazingerZFabricante”, que también extienda a “MazingerZ”.

Pero antes de ponerse a escribir código, Cerebro se da cuenta que probablemente esa no sea la mejor solución, porque cada vez que quiera asignar un nuevo rol a una robot, tendrá que escribir una nueva subclase (por ejemplo, una “MazingerZIngeniero”, o una “MazingerZConstructor”).

Además, el no sabe a priori cuantos roles va a necesitar asignar a un robot. Todo depende de lo que necesite en el futuro. Necesita dar soporte a la adición de interfaces desconocidas a la clase “MazingerZ”.

También se da cuenta que su primera forma de atacar el problema tiene otro punto débil, y es que no podrá re-asignar un rol. Si crea un “MazingerZSoldado”, tendrá esta para siempre, aunque la necesite para construir nuevos robots.

Pero también se da cuenta de otro punto débil, este es mucho más sutil. Una clase “MazingerZSoldado” y una “MazingerZ” son exactamente lo mismo. La única diferencia es que una de ellas tiene un comportamiento particular, pero en esencia, son lo mismo. Por tanto, no es muy apropiado representarlas utilizando clases distintas.

Cerebro está loco, pero no es tonto. Por tanto, decide que ha encontrado demasiados puntos débiles para su idea inicial, y que por tanto, es el momento de acudir al patrón “Extension Objects”.

Este patrón intenta anticipar la extensión de la interfaz de un objeto en el futuro (eso quiere decir: se pueden añadir interfaces a una clase en tiempo de ejecución). Así que empieza a leer, y a reírse. Y cuanto más lee, mas se ríe.

La idea es muy sencilla. Una clase (MazingerZ) será capaz de cambiar la interfaz que implementa en tiempo de ejecución, seleccionando esa interfaz de entre una colección de objetos ( los Extension Objects ). Cada uno de esos objetos encapsularan uno de los roles (MazingerZSoldado, MazingerZFabricante,... ).

Pero como será capaz la clase “MazingerZ“ de seleccionar la interfaz a implementar? Y de igual manera la clase “ElVengador”?. Bien, ambas clases implementaran la siguiente interfaz.

public interface Sujeto{<br /><br /> public Rol getExtension( String nombreExt );<br /><br />}

La clase “MazingerZ” implementa una interfaz para encapsular las acciones que implementa por ser un robot (mover la cabeza, mover las piernas, los brazos).

package extensionobject.paso1;<br /><br />public interface Sujeto {<br /><br /> public Rol getExtension( String nombreExt );<br /><br />}

package extensionobject.paso1;<br /><br />public interface AccionesBasicas {<br /><br /> void moverBrazos( );<br /> void moverPiernas( );<br /> void moverCabeza( );<br /><br />}

package extensionobject.paso1;<br /><br />public interface AccionFabricante {<br /><br /> void construir();<br /> void disenar();<br /><br />}

package extensionobject.paso1;<br /><br />public interface AccionSoldado {<br /><br /> void atacar();<br /> void defender();<br /><br />}

package extensionobject.paso1;<br /><br />public abstract class Rol {<br /><br />}

package extensionobject.paso1;<br /><br />public class RolFabricante extends Rol implements AccionFabricante{<br /><br /> private AccionesBasicas sujeto;<br /> <br /> public RolFabricante(AccionesBasicas sujeto){<br /> this.sujeto = sujeto;<br /> System.out.println("RolFabricante creado");<br /> }<br /><br /> public void construir(){<br /> System.out.println("Interfaz construir ejecutada");<br /> sujeto.moverBrazos();<br /> sujeto.moverPiernas();<br /> }<br /><br /> public void disenar(){<br /> System.out.println("Interfaz disenar ejecutada");<br /> sujeto.moverCabeza();<br /> sujeto.moverBrazos();<br /> }<br /><br />}

package extensionobject.paso1;<br /><br />public class RolSoldado extends Rol implements AccionSoldado{<br /><br /> private AccionesBasicas sujeto;<br /> <br /> public RolSoldado(AccionesBasicas sujeto){<br /> this.sujeto = sujeto;<br /> System.out.println("RolSoldado creado");<br /> }<br /><br /> public void atacar() {<br /> System.out.println("Interfaz atacar ejecutada");<br /> sujeto.moverBrazos();<br /> sujeto.moverPiernas();<br /> }<br /><br /> public void defender() {<br /> System.out.println("Interfaz defender ejecutada");<br /> sujeto.moverBrazos();<br /> }<br /><br />}

package extensionobject.paso1;<br /><br />public class MazingerZ implements Sujeto, AccionesBasicas{<br /><br /> private RolSoldado rolSoldado;<br /> private RolFabricante rolFabricante;<br /><br /> public MazingerZ() {<br /> System.out.println("Creada la plantilla de Mazinger Z");<br /> }<br /><br /> public Rol getExtension(String nombreExt) {<br /> Rol retornarValor = null;<br /> if( nombreExt.equals("RolSoldado") ){<br /> if( rolSoldado == null ){<br /> retornarValor = new RolSoldado(this);<br /> }<br /> else{<br /> retornarValor = rolSoldado;<br /> }<br /> }<br /> else if( nombreExt.equals("RolFabricante") ){<br /> if( rolFabricante == null ){<br /> retornarValor = new RolFabricante(this);<br /> }<br /> else{<br /> retornarValor = rolFabricante;<br /> }<br /> }<br /> return retornarValor;<br /> }<br /><br /> public void moverBrazos() {<br /> System.out.println("Mazinger Z mueve los brazos");<br /> }<br /><br /> public void moverPiernas() {<br /> System.out.println("Mazinger Z mueve las piernas");<br /> }<br /><br /> public void moverCabeza() {<br /> System.out.println("Mazinger Z mueve la cabeza");<br /> }<br /><br />}

package extensionobject.paso1;<br /><br />public class ManejarRobots {<br /><br /> public static void main(String args[]){<br /> MazingerZ robot = new MazingerZ();<br /> AccionSoldado robotSoldado = (AccionSoldado) <br /> robot.getExtension("RolSoldado");<br /> robotSoldado.atacar();<br /> AccionFabricante robotFabricante = <br /> (AccionFabricante) robot.getExtension("RolFabricante");<br /> robotFabricante.disenar();<br /> }<br /><br />}

Fíjense como la clase “MazingerZ” implementa el método “getExtension”, que elige la clase que debe devolver de entre una colección de roles (que son variables de la clase). Y los roles ?.

Para ese caso está la clase abstracta Rol (no he implementado nada en el, pero cualquier funcionalidad común a los roles debería implementarse aquí).

public abstract class Rol {<br /><br />}

Pero Cerebro no es tonto, y sabe que en algún momento necesitara cambiar los roles de sus Robots. En algún momento puede llegar a necesitar que los robots que tienen el rol fabricante deban pasar a tener el rol soldado. Sería posible construir un “MazingerZ” con distintos tipos de roles, y que estos puedan ser modificados en cualquier momento?.

Entonces Cerebro luego de estudiar mejor el patrón “Extension Objects” decide refactorizar su código.

package extensionobject.paso2;<br /><br />import extensionobject.paso1.Rol;<br /><br />public interface Sujeto {<br /><br /> Rol getExtension(String nombreExt);<br /> void addExtension(String nombreExt, Rol extension);<br /> void removerExtension(String nombreExt);<br /><br />}

package extensionobject.paso2;<br /><br />import extensionobject.paso1.AccionesBasicas;<br />import extensionobject.paso1.Rol;<br /><br />import java.util.HashMap;<br /><br />public class MazingerZ implements Sujeto, AccionesBasicas {<br /><br /> private HashMap rolesCol;<br /><br /> public MazingerZ(){<br /> System.out.println("Creada la plantilla de Mazinger Z");<br /> rolesCol = new HashMap();<br /> }<br /><br /> public Rol getExtension(String nombreExt) {<br /> return (Rol) rolesCol.get(nombreExt);<br /> }<br /><br /> public void addExtension(String nombreExt, Rol extension) {<br /> rolesCol.put(nombreExt, extension);<br /> }<br /><br /> public void removerExtension(String nombreExt) {<br /> rolesCol.remove(nombreExt);<br /> }<br /> <br /> public void moverBrazos() {<br /> System.out.println("Mazinger Z mueve los brazos");<br /> }<br /><br /> public void moverPiernas() {<br /> System.out.println("Mazinger Z mueve las piernas");<br /> }<br /><br /> public void moverCabeza() {<br /> System.out.println("Mazinger Z mueve la cabeza");<br /> }<br /><br />}

package extensionobject.paso2;<br /><br />import extensionobject.paso1.AccionSoldado;<br />import extensionobject.paso1.RolSoldado;<br />import extensionobject.paso1.RolFabricante;<br />import extensionobject.paso1.AccionFabricante;<br /><br />public class ManejarRobots {<br /><br /> public static void main(String args[]){<br /> MazingerZ robot = new MazingerZ();<br /> robot.addExtension("RolSoldado", <br /> new RolSoldado(robot));<br /> AccionSoldado robotSoldado = (AccionSoldado)<br /> robot.getExtension("RolSoldado");<br /> robotSoldado.atacar();<br /> robot.removerExtension("RolSoldado");<br /> robot.addExtension("RolFabricante", <br /> new RolFabricante(robot) );<br /> AccionFabricante robotFabricante = <br /> ( AccionFabricante ) robot.getExtension<br /> ("RolFabricante");<br /> robotFabricante.construir();<br /> }<br /><br />}

Ahora, los robots construidos por su máquina podrán cambiar su rol en tiempo de ejecución primero pueden ser soldados, luego fabricantes, mas tarde lo que a Cerebro le dé la gana).

Cerebro ha conseguido mantener la abstracción “MazingerZ” limpia de operaciones específicas para un robot. Eso también lo podría haber conseguido gracias a la herencia, definiendo las operaciones para los robots en las subclases, pero eso habría generado una jerarquía difícil de manejar.

Cerebro a dado un paso más en su plan de CONQUISTAR AL MUNDO!!!!!.

PARTE 3

El patron prototype (prototipo) - Parte I

De la literatura relacionada con patrones de diseño, hay dos libros que recuerdo haber leído con mucho agrado (esos libros que cuesta dejar de leerlos). Uno de ellos es el “Head First Design Patterns”, el cual realmente me rompió los esquemas de los libros que hasta el momento había leído por la forma en que presenta cada uno de los patrones. El otro libro es el “Design Patterns for Dummies”, que para este caso su título lo dice todo.

Hace un tiempo atrás, necesitaba hacer una clase de patrones de diseño en una universidad, y fue del primer libro, de donde saque muchas ideas para enseñar algunos patrones básicos.

El primer patrón que veremos será el “Prototype”, pero siguiendo la filosofía del “Head First Design Patterns” en la simpleza de enseñar patrones.

Para lograr esto, el protagonista principal de estos post sera…..

Como todos sabemos, Cerebros es un ratón cuyo único deseo es llevar a cabo su malvado plan para…..DOMINAR AL MUNDO!!!!.

Una mañana, ideo un plan malévolo pero perfecto!!!. Recordando su niñez cuando veía el “Show de los Robots” o “Pipiripao” (uff……que viejo), decidió construir un ejercicito de robots y así dominar el mundo!!!!. Para lograr su objetivo, debía construir una máquina capaz de construir cualquier tipo de robot y que fuera programada en Java.

Así que comenzó a programar su máquina para construir su primer robot:

package prototipo.paso1;<br /><br />public class MazingerZ {<br /><br /> public MazingerZ(){<br /> System.out.println("Construyendo robot Mazinger Z");<br /> }<br /><br />}

package prototipo.paso1;<br /><br />public class MaquinaGeneradora {<br /><br /> public MazingerZ construirMazingerZ() {<br /> return new MazingerZ();<br /> }<br /><br /> public MazingerZ[] cosntruirMuchosMZ(int numeroRobots){<br /> MazingerZ[] mazingerZ = new MazingerZ[numeroRobots];<br /> for (int k = 0; k < numeroRobots; k++) {<br /> mazingerZ[k] = new MazingerZ();<br /> }<br /> return mazingerZ;<br /> }<br /><br />}

package prototipo.paso1;<br /><br />public class ConquistarAlMundo{<br /><br /> public static void main(String[] args){<br /> MaquinaGeneradora mg = new MaquinaGeneradora();<br /> mg.construirMazingerZ();<br /> mg.cosntruirMuchosMZ(20);<br /> }<br /><br />}

Tras construir un ejército de robots, Cerebro de dio cuenta que construir un ejército de robots tipo “El Vengador” unidos a los “Mazinger Z” le ayudaría a dominar el mundo más rápido.

Pero aquí se le presento el primer problema. Su máquina no fue programada para construir “El Vengador”, sino solamente para construir “Mazinger Z”.

Así que Cerebro, como buen programador, decide refactorizar su código para añadir a su máquina la funcionalidad necesaria para construir “El Vengador”.

package prototipo.paso2;<br /><br />public class ElVengador {<br /><br /> public ElVengador(){<br /> System.out.println("Construyendo robot El Vengador");<br /> }<br /><br />}

package prototipo.paso2;<br /><br />import prototipo.paso1.MazingerZ;<br /><br />public class MaquinaGeneradora {<br /><br /> public MazingerZ construirMazingerZ() {<br /> return new MazingerZ();<br /> }<br /><br /> public ElVengador construirElVengador() {<br /> return new ElVengador();<br /> }<br /><br /> public MazingerZ[] cosntruirMuchosMZ(int numeroRobots) {<br /> MazingerZ[] mazingerZ = new MazingerZ[numeroRobots];<br /> for (int k = 0; k < numeroRobots; k++) {<br /> mazingerZ[k] = new MazingerZ();<br /> }<br /> return mazingerZ;<br /> }<br /><br /> public ElVengador[] cosntruirMuchosEV(int numeroRobots) {<br /> ElVengador[] elVengador = new ElVengador[numeroRobots];<br /> for (int k = 0; k < numeroRobots; k++) {<br /> elVengador[k] = new ElVengador();<br /> }<br /> return elVengador;<br /> }<br /><br />}

package prototipo.paso2;<br /><br />public class ConquistarAlMundo{<br /><br /> public static void main(String[] args){<br /> MaquinaGeneradora mg = new MaquinaGeneradora();<br /> mg.construirMazingerZ();<br /> mg.cosntruirMuchosMZ(20);<br /> mg.construirElVengador();<br /> mg.cosntruirMuchosEV(18);<br /> }<br /><br />}

Cerebro está loco, pero no es tonto. Por tanto, enseguida se da cuenta de que puede encontrarse con problemas si decide construir otro tipo de robots como “El Gran Dragón del Espacio” o “Afrodita A”.

Tras pensar cuidadosamente sobre su problema, decide hacer una nueva refactorización a su código.

package prototipo.paso3;<br /><br />import prototipo.paso1.MazingerZ;<br />import prototipo.paso2.ElVengador;<br /><br />public class MaquinaGeneradora {<br /><br /> public Object construirRobot(String tipo){<br /> if( tipo.equals("MazingerZ") ){<br /> return new MazingerZ();<br /> }<br /> else if( tipo.equals("ElVengador") ){<br /> return new ElVengador();<br /> }<br /> return null;<br /> }<br /><br /> public Object[] construirMuchosRobots(String tipo, int numero){<br /> Object robots[] = new Object[numero];<br /> if( tipo.equals("MazingerZ") ){<br /> for( int k=0; k< numero; k++ ){<br /> robots[ k ] = new MazingerZ();<br /> }<br /> }<br /> else if( tipo.equals("ElVengador") ){<br /> for( int k=0; k< numero; k++ ){<br /> robots[ k ] = new ElVengador();<br /> }<br /> }<br /> return robots;<br /> }<br /><br />}
package prototipo.paso3;<br /><br /><br /><br />public class ConquistarAlMundo {<br /><br /><br /><br /> public static void main(String[] args) {<br /><br /> MaquinaGeneradora mg = new MaquinaGeneradora();<br /><br /> mg.construirRobot("MazingerZ");<br /><br /> mg.construirMuchosRobots("MazingerZ", 12);<br /><br /> mg.construirRobot("ElVengador");<br /><br /> mg.construirMuchosRobots("ElVengador", 8);<br /><br /> }<br /><br /><br /><br />}

Tras varios minutos de las típicas risas histéricas de Pinky, Cerebro comienza a darse cuenta que la forma en que ha programado su máquina tiene bastantes puntos débiles.

En primer lugar, el método “construirRobot” devuelve un Object, no un “Mazinger Z” o un “El Vengador”. Por qué?....porque ese método no sabe lo que va a crear a priori. Cerebro se da cuenta que esta no es la mejor solución.

También se da cuenta que si en algún momento quisiera construir algún otro tipo de robot, debería programar nuevamente su máquina, lo cual la transforma, en una maquina difícil de mantener.

Pero entonces, una idea empieza a abrirse paso en su malvado cerebro. Aun no sabe exactamente cómo hacerlo, pero que pasaría si pudiera darle algo a la maquina (un robot del tipo Mazinger Z, El Vengador, Afrodita A, etc…) y pedirle a la misma que le entrege 800 copias del mismo?....brillante!!!. Así, no tendría que preocuparse de cómo funciona la maquina, simplemente esta devolvería tantas copias como necesite del original.

Entonces cerebro recuerda haber estudiado el patrón “Prototype”. Para lograr esto, la maquina no puede saber que tiene que construir ni cómo debe construirlo (la creación de la copia), y tampoco puede ser una responsabilidad de cada uno de los robots (o cosas a copiar). La maquina, simplemente debe recibir un robot y le dirá a este que produzca tantas copias de el mismo como se necesiten y luego las devolverá.

De hecho, Cerebro se ha dado cuenta de que la forma en la que deben crearse las nuevas copias de los robots no ha de ser la misma para todos, sino que en algunos casos le va a interesar utilizar el mecanismo de clonado de Java, y en otros tener un control más fino del mismo.

Así que, la primera tarea de Cerebro será crear una interfaz (que extiende Cloneable, implementando de este modo el método clone()), que será el que implemente cada uno de los robots.

public interface ClonarRobot extends Cloneable {<br /><br /> public ClonarRobot duplicar( );<br /><br />}


También sería posible que todos los robots extendieran de una clase base, y que por lo tanto el tipo que devuelve el método duplicar() fuera esa clase base. Pero de la manera anteriormente comentada el diseño es mucho más flexible.

El método duplicar() será el encargado de crear y devolver una nueva copia de cada robot que lo implemente.

package prototipo.paso4;<br /><br />public interface ClonarRobot extends Cloneable {<br /><br /> ClonarRobot duplicar( );<br /><br />}

package prototipo.paso4;<br /><br />public class ElVengador implements ClonarRobot{<br /><br /> public ElVengador() {<br /> System.out.println("Creada la plantilla de El Vengador");<br /> }<br /><br /> public ClonarRobot duplicar() {<br /> System.out.println("El Vengador se va a clonar a si mismo");<br /> ElVengador elVengador = null;<br /> try {<br /> elVengador = (ElVengador) super.clone();<br /> }<br /> catch (Exception e) {<br /> System.out.println("error al clonar El Vengador");<br /> }<br /> return elVengador;<br /> }<br /><br /> public String toString() {<br /> return "El Vengador - Ya estoy listo para la batalla!!!";<br /> }<br /><br />}

package prototipo.paso4;<br /><br />public class MazingerZ implements ClonarRobot{<br /><br /> public MazingerZ() {<br /> System.out.println("Creada la plantilla de Mazinger Z");<br /> }<br /><br /> public ClonarRobot duplicar() {<br /> System.out.println("Mazinger Z se va a clonar a si mismo");<br /> MazingerZ mazingerZ = null;<br /> try {<br /> mazingerZ = (MazingerZ) super.clone();<br /> }<br /> catch (Exception e) {<br /> System.out.println("error al clonar Mazinger Z");<br /> }<br /> return mazingerZ;<br /> }<br /><br /> public String toString() {<br /> return "Mazinger Z - Ya estoy listo para la batalla!!!";<br /> }<br /><br />}

package prototipo.paso4;<br /><br />public class MaquinaGeneradora {<br /><br /> public Cloneable crearCopia(ClonarRobot plantilla) {<br /> return plantilla.duplicar();<br /> }<br /><br /> public Cloneable[] crearMuchasCopias(int numeroCopias, ClonarRobot plantilla) {<br /> Cloneable[] copias = new Cloneable[numeroCopias];<br /> for (int i = 0; i < numeroCopias; i++) {<br /> copias[i] = plantilla.duplicar();<br /> }<br /> return copias;<br /> }<br /><br />}

package prototipo.paso4;<br /><br />public class ConquistarAlMundo {<br /><br /> public static void mostrar(String texto){<br /> System.out.println("");<br /> System.out.println(texto);<br /> System.out.println("");<br /> }<br /><br /> public static void main(String[] args) {<br /> MaquinaGeneradora mg = new MaquinaGeneradora();<br /> mostrar("Creando plantilla de Mazinger Z y El Vengador");<br /> MazingerZ plantillaMazingerZ = new MazingerZ();<br /> ElVengador plantillaElVengador = new ElVengador();<br /> MazingerZ mazingerZClonado = (MazingerZ) mg.crearCopia(plantillaMazingerZ);<br /> mostrar("Primera Mazinger Z clonado");<br /> System.out.println(mazingerZClonado);<br /> ElVengador elVengadorClonado = (ElVengador) mg.crearCopia(plantillaElVengador);<br /> mostrar("Primer El Vengador clonado");<br /> System.out.println(elVengadorClonado);<br /> mostrar("Creando 10 nuevos Mazinger Z");<br /> Cloneable nuevosMazingerZ[] = mg.crearMuchasCopias(10, plantillaMazingerZ);<br /> mostrar("Creando 10 nuevos El Vengador");<br /> Cloneable nuevosElVengador[] = mg.crearMuchasCopias(10, plantillaElVengador);<br /> mostrar("Inicializando los Mazinger Z");<br /> for(int i=0; i<> System.out.println(nuevosMazingerZ[i]);<br /> }<br /> mostrar("Inicializando los El Vengador");<br /> for(int i=0; i<> System.out.println(nuevosElVengador[i]);<br /> }<br /> }<br /><br />}

Ahora, Cerebro puede seguir construyendo su ejército para conquistar el mundo el mundo con los clones creados por su máquina, sabiendo que puede crear copias de todo lo que le dé la gana, porque le ha dado a su máquina el “don” de crear objetos sin saber de qué tipo deben ser.

Pero Cerebro es un hombre de ciencia, y en su afán por alcanzar el conocimiento absoluto, sigue leyendo la documentación sobre el patrón prototype, y entonces se da cuenta de que también ha separado el código que crea los objetos del código que maneja los detalles de la creación de nuevos objetos.

Esta historia continuara……

Parte 2

Inversion de Control (IoC)

Hace un tiempo atrás convencí a un amigo de que aprendiera Spring, contándole de todas las ventajas que podría lograr utilizando este framework. El comenzó a estudiarlo y como a todos nos ha pasado, le sorprendió la facilidad con la que puede desarrollar aplicaciones.

Hasta ahí todo iba muy bien, pero cuando le pregunte que le pareció la “inversión de control” y la “inyección de dependencia”, me dijo que lo único que entendía era que Spring utilizaba estos patrones…...pero de que se trataba……ni idea!!!!

Así que mi querido amigo XXX (no te voy a echar al agua)…...este post es para ti.

Imaginemos que tenemos una clase “Componente” que necesita usar la clase “Servicio”. Una solución para esto podría ser :

package dukechile.jug.ioc.paso1;<br /><br />public class Servicio {<br /><br /> public String ejecutarServicio(){<br /> return "Simulacion de llamada a un servicio";<br /> }<br /><br />}

package dukechile.jug.ioc.paso1;<br /><br />public class Componente {<br /><br /> private Servicio servicio;<br /><br /> public Componente(){<br /> servicio = new Servicio();<br /> }<br /><br /> public void ejecutarServicio(){<br /> String mensaje = servicio.ejecutarServicio();<br /> System.out.println(mensaje);<br /> }<br /><br />}

package dukechile.jug.ioc.paso1;<br /><br />public class ClaseTest {<br /><br /> public static void main(String[] args) {<br /> Componente componente = new Componente();<br /> componente.ejecutarServicio();<br /> }<br /><br />}

El problema de esto es que estamos acoplando las clases. Qué pasaría si por algún requerimiento, el desarrollador modifica el código, solicitando ahora algún parámetro en el constructor de la clase “Servicio”?. Esto nos llevaría no solo a modificar el código de la clase “Servicio”, sino también el de la clase “Componente”.

O pero aun, tu jefe te dice que no le gusta como esta implementada la clase “Servicio”, así que él, en un acto de iluminación divina, desarrollo la clase “Servicio2” la cual (supuestamente) es mejor a la anterior. Por lo tanto, nuevamente tendremos que modificar nuestra clase “Componente”:

package dukechile.jug.ioc.paso2;<br /><br />public class Servicio2 {<br /><br /> public String ejecutarServicio(){<br /> return "Simulacion de llamada a un servicio optimizada";<br /> }<br /><br />}

package dukechile.jug.ioc.paso2;<br /><br />public class Componente {<br /><br /> //private Servicio servicio;<br /> private Servicio2 servicio2;<br /><br /> public Componente(){<br /> //servicio = new Servicio();<br /> servicio2 = new Servicio2();<br /> }<br /><br /> public void ejecutarServicio(){<br /> //String mensaje = servicio.ejecutarServicio();<br /> String mensaje = servicio2.ejecutarServicio();<br /> System.out.println(mensaje);<br /> }<br /><br />}

package dukechile.jug.ioc.paso2;<br /><br />public class ClaseTest {<br /><br /> public static void main(String[] args) {<br /> Componente componente = new Componente();<br /> componente.ejecutarServicio();<br /> }<br /><br />}

…..y mejor ni pensemos si alguien se pone original (nunca faltan!!!!) y comience a modificar el constructor de la clase “Servicio2”.

Pero como nada es tan terrible, una solución para estos casos es la “Inversión de control”.

El primer cambio que tendremos que hacer a nuestro código, es olvidarnos de usar “new XXX()”, para lo cual definiremos un método “setXXX” que nos pase una referencia de una instancia de la clase “Servicio2” :

package dukechile.jug.ioc.paso3;<br /><br />public class Componente {<br /><br /> private Servicio2 servicio2;<br /><br /> public Componente(){<br /> }<br /><br /> public void setServicio2(Servicio2 servicio2){<br /> this.servicio2 = servicio2;<br /> }<br /><br /> public void ejecutarServicio(){<br /> String mensaje = servicio2.ejecutarServicio();<br /> System.out.println(mensaje);<br /> }<br /><br />}

package dukechile.jug.ioc.paso3;<br /><br />public class Servicio2 {<br /><br /> public String ejecutarServicio(){<br /> return "Simulacion de llamada a un servicio optimizada";<br /> }<br /><br />}

package dukechile.jug.ioc.paso3;<br /><br />public class ClaseTest {<br /><br /> public static void main(String[] args) {<br /> Componente componente = new Componente();<br /> componente.setServicio2(new Servicio2());<br /> }<br /><br />}

Hasta aquí todo va bien, pero que pasaría si nuestro jefe, en un acto de arrepentimiento te dice “evaluando la situación, pienso que debemos volver a usar la clase “Servicio” hasta que nuevo aviso (por no decir, hasta que arregle los errores en mi código)”, y nosotros que ya pensábamos que teníamos casi todo controlado, nuevamente tendremos que volver a cambiar el código de la clase “Componente”, modificando el atributo y el método “setXXX”.

Pero como buenos programadores, sabemos que no va a faltar el jefe original que se le ocurra volver a cambiar el servicio, así que, para evitar problemas a futuro, definiremos una interfaz para el servicio. De ahora en adelante, cualquier clase servicio que se le pase a la clase “Componente”, deberá implementar esta interfaz (ufff….ya no deberemos tocar el código de la clase “Componente”).

package dukechile.jug.ioc.paso4;<br /><br />public class Componente {<br /><br /> private ServicioI servicio;<br /><br /> public Componente(){<br /> }<br /><br /> public void setServicio(ServicioI servicio){<br /> this.servicio = servicio;<br /> }<br /><br /> public void ejecutarServicio(){<br /> String mensaje = servicio.ejecutarServicio();<br /> System.out.println(mensaje);<br /> }<br /><br />}

package dukechile.jug.ioc.paso4;<br /><br />public interface ServicioI {<br /><br /> String ejecutarServicio();<br /><br />}

package dukechile.jug.ioc.paso4;<br /><br />public class Servicio implements ServicioI{<br /><br /> public String ejecutarServicio(){<br /> return "Simulacion de llamada a un servicio";<br /> }<br /><br />}

package dukechile.jug.ioc.paso4;<br /><br />public class Servicio2 implements ServicioI{<br /><br /> public String ejecutarServicio(){<br /> return "Simulacion de llamada a un servicio optimizada";<br /> }<br /><br />}

package dukechile.jug.ioc.paso4;<br /><br />public class ClaseTest {<br /><br /> public static void main(String[] args) {<br /> Componente componente = new Componente();<br /> componente.setServicio(new Servicio());<br /> componente.ejecutarServicio();<br /> componente.setServicio(new Servicio2());<br /> componente.ejecutarServicio();<br /> }<br /><br />}

Como vemos, cambiar el tipo de servicio en la clase “Componente” ya no tiene impacto en nuestro código!!!! (Obviamente..…hasta que no falte el original que cambie la interfaz!!!).

Hasta aquí toda esta correcto, pero nos falta un pequeño elemento, el “Ensamblador”, cuya tarea principal es obtener la información de cómo cada uno de los elementos debe ser inyectado en otros elementos.

Para estos casos, es donde frameworks como PicoContainer o Spring utilizan el patrón “Inversión de Control”, los cuales se encargan de realizar la inyección de los elementos. El como lo hacen, puede ser a través de código o en un archivo de configuración.

Para el caso de la “Inyección de dependencias” existen tres mecanismos:

• Inyección de Interfaz (IoC tipo 1)
• Inyección de Setter (IoC tipo 2)
• Inyección de Constructor (IoC 3)

Que diferencias existen entre los distintos tipos de inyección, va mas allá de este post, pero el señor Martin Fowler lo explica muy bien en este articulo.

La inversión de control no es la única forma de solucionar este problema, también existe el patrón “Service Locator”, pero eso es tema para otro post.