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

Tutorial de Tomcat en Cluster

Lo primero que necesitaremos será descargar el servidor Web Apache para poder hacer el balanceo de carga (Load Balancing) y la compartición de carga (Load Sharing).

Para esto, descargaremos el archivo apache_2.2.9-win32-x86-no_ssl-r2.msi desde aquí. Una vez descargado, procedemos a la instalación.

Ya instalado el servidor Web Apache, deberemos proceder a instalar Tomcat y definir el tipo de cluster a implementar.

Existen dos tipos de cluster que podemos construir en Tomcat: cluster vertical (en una sola maquina) o cluster horizontal (en muchas maquinas).


Cluster vertical

El primer paso será la instalación de Tomcat, para lo que deberemos bajar el archivo apache-tomcat-6.0.9.exe desde aquí.

Una vez descargado el archivo, procederemos instalar Tomcat. Para este ejemplo, vamos a simular que el cluster está compuesto por tres nodos, por lo tanto, necesitaremos instalar tres instancias de Tomcat las cuales llamaremos: TomcatNodo1, TomcatNodo2 y TomcatNodo3.

El paso que realizaremos a continuación deberemos repetirlo para cada nodo.







Una vez instalado los tres nodos, deberemos realizar una pequeña modificación al archivo server.xml de cada uno de los nodos. Este archivo se encuentra en la carpeta "conf" de cada uno de los nodos.

Para cada uno de los server.xml deberemos realizar los siguientes cambios:

Cambiar los puertos

<br /><server port="XXXX" shutdown="SHUTDOWN"><br /><br /> <connector port="XXXX" protocol="HTTP/1.1" connectiontimeout="20000" redirectport="8443"><br /><br /> <connector port="XXXX" protocol="AJP/1.3" redirectport="8443">

Agregamos el “jvmRoute” para cada caso.

<br /><engine name="Catalina" defaulthost="localhost" jvmroute="tomcatNodoX"><br /><br />

Descomentamos el tag “cluster”

<br /><cluster classname="org.apache.catalina.ha.tcp.SimpleTcpCluster"><br /><br />

Nodo1

<br /><!-- Note: A "Server" is not itself a "Container", so you may not define subcomponents such as "Valves" at this level. Documentation at /docs/config/server.html --><br /><br /><server port="8015" shutdown="SHUTDOWN"><br /><br /><br /><br /> <!--APR library loader. Documentation at /docs/apr.html --><br /><br /> <listener classname="org.apache.catalina.core.AprLifecycleListener" sslengine="on"><br /><br /> <!--Initialize Jasper prior to webapps are loaded. Documentation at /docs/jasper-howto.html --><br /><br /> <listener classname="org.apache.catalina.core.JasperListener"><br /><br /> <!-- JMX Support for the Tomcat server. Documentation at /docs/non-existent.html --><br /><br /> <listener classname="org.apache.catalina.mbeans.ServerLifecycleListener"><br /><br /> <listener classname="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"><br /><br /><br /><br /> <!-- Global JNDI resources Documentation at /docs/jndi-resources-howto.html --><br /><br /> <globalnamingresources><br /><br /> <!-- Editable user database that can also be used by UserDatabaseRealm to authenticate users --><br /><br /> <resource name="UserDatabase" auth="Container" type="org.apache.catalina.UserDatabase" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" pathname="conf/tomcat-users.xml"><br /><br /> </globalnamingresources><br /><br /><br /><br /> <!-- A "Service" is a collection of one or more "Connectors" that share a single "Container" Note: A "Service" is not itself a "Container", so you may not define subcomponents such as "Valves" at this level. Documentation at /docs/config/service.html --><br /><br /> <service name="Catalina"><br /><br /><br /><br /> <!-- A "Connector" represents an endpoint by which requests are received and responses are returned. Documentation at : Java HTTP Connector: /docs/config/http.html (blocking & non-blocking) Java AJP Connector: /docs/config/ajp.html APR (HTTP/AJP) Connector: /docs/apr.html Define a non-SSL HTTP/1.1 Connector on port 8080 --><br /><br /> <connector port="8081" protocol="HTTP/1.1" maxthreads="150" connectiontimeout="20000" redirectport="8443"><br /><br /><br /><br /> <!-- Define a SSL HTTP/1.1 Connector on port 8443 This connector uses the JSSE configuration, when using APR, the connector should be using the OpenSSL style configuration described in the APR documentation --><br /><br /> <!-- <connector port="8443" protocol="HTTP/1.1" sslenabled="true" maxthreads="150" scheme="https" secure="true" clientauth="false" sslprotocol="TLS"><br /><br /> --><br /><br /><br /><br /> <!-- Define an AJP 1.3 Connector on port 8009 --><br /><br /> <connector port="8109" protocol="AJP/1.3" redirectport="8443"><br /><br /><br /><br /><br /><br /> <!-- An Engine represents the entry point (within Catalina) that processes every request. The Engine implementation for Tomcat stand alone analyzes the HTTP headers included with the request, and passes them on to the appropriate Host (virtual host). Documentation at /docs/config/engine.html --><br /><br /><br /><br /> <!-- You should set jvmRoute to support load-balancing via AJP ie : --><br /><br /> <engine name="Standalone" defaulthost="localhost" jvmroute="tomcatNodo1"> <br /><br /> <br /><br /> <engine name="Catalina" defaulthost="localhost"><br /><br /><br /><br /> <!--For clustering, please take a look at documentation at: /docs/cluster-howto.html (simple how to) /docs/config/cluster.html (reference documentation) --><br /><br /> <br /><br /> <cluster classname="org.apache.catalina.ha.tcp.SimpleTcpCluster"><br /><br /> <br /><br /><br /><br /> <!-- The request dumper valve dumps useful debugging information about the request and response data received and sent by Tomcat. Documentation at: /docs/config/valve.html --><br /><br /> <!-- <valve classname="org.apache.catalina.valves.RequestDumperValve"><br /><br /> --><br /><br /><br /><br /> <!-- This Realm uses the UserDatabase configured in the global JNDI resources under the key "UserDatabase". Any edits that are performed against this UserDatabase are immediately available for use by the Realm. --><br /><br /> <realm classname="org.apache.catalina.realm.UserDatabaseRealm" resourcename="UserDatabase"><br /><br /><br /><br /> <!-- Define the default virtual host Note: XML Schema validation will not work with Xerces 2.2. --><br /><br /> <host name="localhost" appbase="webapps" unpackwars="true" autodeploy="true" xmlvalidation="false" xmlnamespaceaware="false"><br /><br /><br /><br /> <!-- SingleSignOn valve, share authentication between web applications Documentation at: /docs/config/valve.html --><br /><br /> <!-- <valve classname="org.apache.catalina.authenticator.SingleSignOn"><br /><br /> --><br /><br /><br /><br /> <!-- Access log processes all example. Documentation at: /docs/config/valve.html --><br /><br /> <!-- <valve classname="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log." suffix=".txt" pattern="common" resolvehosts="false"><br /><br /> --><br /><br /><br /><br /> </host><br /><br /> </engine><br /><br /> </service><br /><br /></server><br /><br />

Nodo2

<br /><!-- Note: A "Server" is not itself a "Container", so you may not define subcomponents such as "Valves" at this level. Documentation at /docs/config/server.html --><br /><br /><server port="8205" shutdown="SHUTDOWN"><br /><br /><br /><br /> <!--APR library loader. Documentation at /docs/apr.html --><br /><br /> <listener classname="org.apache.catalina.core.AprLifecycleListener" sslengine="on"><br /><br /> <!--Initialize Jasper prior to webapps are loaded. Documentation at /docs/jasper-howto.html --><br /><br /> <listener classname="org.apache.catalina.core.JasperListener"><br /><br /> <!-- JMX Support for the Tomcat server. Documentation at /docs/non-existent.html --><br /><br /> <listener classname="org.apache.catalina.mbeans.ServerLifecycleListener"><br /><br /> <listener classname="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"><br /><br /><br /><br /> <!-- Global JNDI resources Documentation at /docs/jndi-resources-howto.html --><br /><br /> <globalnamingresources><br /><br /> <!-- Editable user database that can also be used by UserDatabaseRealm to authenticate users --><br /><br /> <resource name="UserDatabase" auth="Container" type="org.apache.catalina.UserDatabase" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" pathname="conf/tomcat-users.xml"><br /><br /> </globalnamingresources><br /><br /><br /><br /> <!-- A "Service" is a collection of one or more "Connectors" that share a single "Container" Note: A "Service" is not itself a "Container", so you may not define subcomponents such as "Valves" at this level. Documentation at /docs/config/service.html --><br /><br /> <service name="Catalina"><br /><br /><br /><br /> <!-- A "Connector" represents an endpoint by which requests are received and responses are returned. Documentation at : Java HTTP Connector: /docs/config/http.html (blocking & non-blocking) Java AJP Connector: /docs/config/ajp.html APR (HTTP/AJP) Connector: /docs/apr.html Define a non-SSL HTTP/1.1 Connector on port 8080 --><br /><br /> <connector port="8082" protocol="HTTP/1.1" maxthreads="150" connectiontimeout="20000" redirectport="8443"><br /><br /><br /><br /> <!-- Define a SSL HTTP/1.1 Connector on port 8443 This connector uses the JSSE configuration, when using APR, the connector should be using the OpenSSL style configuration described in the APR documentation --><br /><br /> <!-- <connector port="8443" protocol="HTTP/1.1" sslenabled="true" maxthreads="150" scheme="https" secure="true" clientauth="false" sslprotocol="TLS"><br /><br /> --><br /><br /><br /><br /> <!-- Define an AJP 1.3 Connector on port 8009 --><br /><br /> <connector port="8209" protocol="AJP/1.3" redirectport="8443"><br /><br /><br /><br /><br /><br /> <!-- An Engine represents the entry point (within Catalina) that processes every request. The Engine implementation for Tomcat stand alone analyzes the HTTP headers included with the request, and passes them on to the appropriate Host (virtual host). Documentation at /docs/config/engine.html --><br /><br /><br /><br /> <!-- You should set jvmRoute to support load-balancing via AJP ie : --> <br /><br /> <engine name="Standalone" defaulthost="localhost" jvmroute="tomcatNodo2"> <br /><br /> <br /><br /> <engine name="Catalina" defaulthost="localhost"><br /><br /><br /><br /> <!--For clustering, please take a look at documentation at: /docs/cluster-howto.html (simple how to) /docs/config/cluster.html (reference documentation) --><br /><br /> <br /><br /> <cluster classname="org.apache.catalina.ha.tcp.SimpleTcpCluster"><br /><br /> <br /><br /><br /><br /> <!-- The request dumper valve dumps useful debugging information about the request and response data received and sent by Tomcat. Documentation at: /docs/config/valve.html --><br /><br /> <!-- <valve classname="org.apache.catalina.valves.RequestDumperValve"><br /><br /> --><br /><br /><br /><br /> <!-- This Realm uses the UserDatabase configured in the global JNDI resources under the key "UserDatabase". Any edits that are performed against this UserDatabase are immediately available for use by the Realm. --><br /><br /> <realm classname="org.apache.catalina.realm.UserDatabaseRealm" resourcename="UserDatabase"><br /><br /><br /><br /> <!-- Define the default virtual host Note: XML Schema validation will not work with Xerces 2.2. --><br /><br /> <host name="localhost" appbase="webapps" unpackwars="true" autodeploy="true" xmlvalidation="false" xmlnamespaceaware="false"><br /><br /><br /><br /> <!-- SingleSignOn valve, share authentication between web applications Documentation at: /docs/config/valve.html --><br /><br /> <!-- <valve classname="org.apache.catalina.authenticator.SingleSignOn"><br /><br /> --><br /><br /><br /><br /> <!-- Access log processes all example. Documentation at: /docs/config/valve.html --><br /><br /> <!-- <valve classname="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log." suffix=".txt" pattern="common" resolvehosts="false"><br /><br /> --><br /><br /><br /><br /> </host><br /><br /> </engine><br /><br /> </service><br /><br /></server><br /><br />

Nodo3

<br /><!-- Note: A "Server" is not itself a "Container", so you may not define subcomponents such as "Valves" at this level. Documentation at /docs/config/server.html --><br /><br /><server port="8305" shutdown="SHUTDOWN"><br /><br /><br /><br /> <!--APR library loader. Documentation at /docs/apr.html --><br /><br /> <listener classname="org.apache.catalina.core.AprLifecycleListener" sslengine="on"><br /><br /> <!--Initialize Jasper prior to webapps are loaded. Documentation at /docs/jasper-howto.html --><br /><br /> <listener classname="org.apache.catalina.core.JasperListener"><br /><br /> <!-- JMX Support for the Tomcat server. Documentation at /docs/non-existent.html --><br /><br /> <listener classname="org.apache.catalina.mbeans.ServerLifecycleListener"><br /><br /> <listener classname="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"><br /><br /><br /><br /> <!-- Global JNDI resources Documentation at /docs/jndi-resources-howto.html --><br /><br /> <globalnamingresources><br /><br /> <!-- Editable user database that can also be used by UserDatabaseRealm to authenticate users --><br /><br /> <resource name="UserDatabase" auth="Container" type="org.apache.catalina.UserDatabase" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" pathname="conf/tomcat-users.xml"><br /><br /> </globalnamingresources><br /><br /><br /><br /> <!-- A "Service" is a collection of one or more "Connectors" that share a single "Container" Note: A "Service" is not itself a "Container", so you may not define subcomponents such as "Valves" at this level. Documentation at /docs/config/service.html --><br /><br /> <service name="Catalina"><br /><br /><br /><br /> <!-- A "Connector" represents an endpoint by which requests are received and responses are returned. Documentation at : Java HTTP Connector: /docs/config/http.html (blocking & non-blocking) Java AJP Connector: /docs/config/ajp.html APR (HTTP/AJP) Connector: /docs/apr.html Define a non-SSL HTTP/1.1 Connector on port 8080 --><br /><br /> <connector port="8083" protocol="HTTP/1.1" maxthreads="150" connectiontimeout="20000" redirectport="8443"><br /><br /><br /><br /> <!-- Define a SSL HTTP/1.1 Connector on port 8443 This connector uses the JSSE configuration, when using APR, the connector should be using the OpenSSL style configuration described in the APR documentation --><br /><br /> <!-- <connector port="8443" protocol="HTTP/1.1" sslenabled="true" maxthreads="150" scheme="https" secure="true" clientauth="false" sslprotocol="TLS"><br /><br /> --><br /><br /><br /><br /> <!-- Define an AJP 1.3 Connector on port 8009 --><br /><br /> <connector port="8309" protocol="AJP/1.3" redirectport="8443"><br /><br /><br /><br /><br /><br /> <!-- An Engine represents the entry point (within Catalina) that processes every request. The Engine implementation for Tomcat stand alone analyzes the HTTP headers included with the request, and passes them on to the appropriate Host (virtual host). Documentation at /docs/config/engine.html --><br /><br /><br /><br /> <!-- You should set jvmRoute to support load-balancing via AJP ie : --> <br /><br /> <engine name="Standalone" defaulthost="localhost" jvmroute="tomcatNodo3"> <br /><br /> <br /><br /> <engine name="Catalina" defaulthost="localhost"><br /><br /><br /><br /> <!--For clustering, please take a look at documentation at: /docs/cluster-howto.html (simple how to) /docs/config/cluster.html (reference documentation) --><br /><br /> <br /><br /> <cluster classname="org.apache.catalina.ha.tcp.SimpleTcpCluster"><br /><br /> <br /><br /><br /><br /> <!-- The request dumper valve dumps useful debugging information about the request and response data received and sent by Tomcat. Documentation at: /docs/config/valve.html --><br /><br /> <!-- <valve classname="org.apache.catalina.valves.RequestDumperValve"><br /><br /> --><br /><br /><br /><br /> <!-- This Realm uses the UserDatabase configured in the global JNDI resources under the key "UserDatabase". Any edits that are performed against this UserDatabase are immediately available for use by the Realm. --><br /><br /> <realm classname="org.apache.catalina.realm.UserDatabaseRealm" resourcename="UserDatabase"><br /><br /><br /><br /> <!-- Define the default virtual host Note: XML Schema validation will not work with Xerces 2.2. --><br /><br /> <host name="localhost" appbase="webapps" unpackwars="true" autodeploy="true" xmlvalidation="false" xmlnamespaceaware="false"><br /><br /><br /><br /> <!-- SingleSignOn valve, share authentication between web applications Documentation at: /docs/config/valve.html --><br /><br /> <!-- <valve classname="org.apache.catalina.authenticator.SingleSignOn"><br /><br /> --><br /><br /><br /><br /> <!-- Access log processes all example. Documentation at: /docs/config/valve.html --><br /><br /> <!-- <valve classname="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log." suffix=".txt" pattern="common" resolvehosts="false"><br /><br /> --><br /><br /><br /><br /> </host><br /><br /> </engine><br /><br /> </service><br /><br /></server><br /><br />


Con estos cambios ya tenemos configurado nuestro cluster vertical.


Cluster Horizontal

La configuración de un cluster horizontal es un poco más fácil ya que no es necesario realizar cambios a los puertos.

Para cada uno de los archivos server.xml se debe realizar los siguientes cambios:

Agregamos el “jvmRoute” para cada caso (igual que para el cluster vertical)

<br /><engine name="Catalina" defaulthost="localhost" jvmroute="tomcatNodoX"><br /><br />

Descomentamos el tag “cluster” (igual que para el cluster vertical)

<br /><cluster classname="org.apache.catalina.ha.tcp.SimpleTcpCluster"><br /><br />


Configuración del cluster con Apache

Una vez configurado el tipo de cluster (Horizontal o Vertical), vamos a construir una pequeña aplicación de ejemplo.

El primer paso será definir en el web.xml de la aplicación el tag <distributable /> para activar el intercambio de la sesión a través de la instancia del cluster.

<br /><?xml version="1.0" encoding="ISO-8859-1"?><br /><br /><web-app xmlns="http://java.sun.com/xml/ns/javaee" xsi="http://www.w3.org/2001/XMLSchema-instance" schemalocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5"><br /><br /> <distributable> <br /><br /></web-app><br /><br />

Ahora necesitaremos integrar el servidor web Apache con Tomcat instalando el modulo mod_jk. Para esto, deberemos descargar el archivo mod_jk-1.2.26-httpd-2.2.4.so desde aquí y dejarlo en la carpeta “modules” de Apache.

Ya instalado el mod_jk, deberemos editar el archivo httpd.conf que está en la carpeta “conf” con las siguientes líneas:

<br />LoadModule jk_module modules/mod_jk-1.2.26-httpd-2.2.4.so<br /><br />JkWorkersFile "C:\Archivos de programa\Apache Software Foundation\Apache2.2\conf\workers.properties"<br /><br />JkLogFile "logs/mod_jk.log"<br /><br />JkLogLevel error<br /><br />JkMount /cluster loadbalancer<br /><br />JkMount /cluster/* loadbalancer<br /><br />

Ahora deberemos crear el archivo workers.properties dentro de la carpeta “conf” del Apache. En este archivo definiremos las propiedades para cada una de las instancias de Tomcat a ejecutar.

En el caso de que nuestro cluster sea vertical, el archivo de propiedades deberá contener lo siguiente:

<br />workers.tomcat_home=/tomcatNodo1<br /><br />workers.java_home=$JAVA_HOME<br /><br />ps=/<br /><br />worker.list=tomcatNodo1,tomcatNodo2,tomcatNodo3,loadbalancer<br /><br /><br /><br />worker.tomcatNodo1.port=8109<br /><br />worker.tomcatNodo1.host=localhost<br /><br />worker.tomcatNodo1.type=ajp13<br /><br />worker.tomcatNodo1.lbfactor=1<br /><br /><br /><br />worker.tomcatNodo2.port=8209<br /><br />worker.tomcatNodo2.host=localhost<br /><br />worker.tomcatNodo2.type=ajp13<br /><br />worker.tomcatNodo2.lbfactor=1<br /><br /><br /><br />worker.tomcatNodo3.port=8309<br /><br />worker.tomcatNodo3.host=localhost<br /><br />worker.tomcatNodo3.type=ajp13<br /><br />worker.tomcatNodo3.lbfactor=1<br /><br /><br /><br />worker.loadbalancer.type=lb<br /><br />worker.loadbalancer.balanced_workers=tomcatNodo1,tomcatNodo2,tomcatNodo3<br /><br />worker.loadbalancer.sticky_session=1<br /><br />

Para el caso de que el cluster sea horizontal deberemos definir el host para cada uno de los nodos del cluster:

<br />workers.tomcat_home=/tomcatNodo1<br /><br />workers.java_home=$JAVA_HOME<br /><br />ps=/<br /><br />worker.list=tomcatNodo1,tomcatNodo2,tomcatNodo3,loadbalancer<br /><br /><br /><br />worker.tomcatNodo1.port=8009<br /><br />worker.tomcatNodo1.host=192.168.1.1<br /><br />worker.tomcatNodo1.type=ajp13<br /><br />worker.tomcatNodo1.lbfactor=1<br /><br /><br /><br />worker.tomcatNodo2.port=8009<br /><br />worker.tomcatNodo2.host=192.168.1.2<br /><br />worker.tomcatNodo2.type=ajp13<br /><br />worker.tomcatNodo2.lbfactor=1<br /><br /><br /><br />worker.tomcatNodo3.port=8009<br /><br />worker.tomcatNodo3.host=192.168.1.3<br /><br />worker.tomcatNodo3.type=ajp13<br /><br />worker.tomcatNodo3.lbfactor=1<br /><br /><br /><br />worker.loadbalancer.type=lb<br /><br />worker.loadbalancer.balanced_workers=tomcatNodo1,tomcatNodo2,tomcatNodo3<br /><br />worker.loadbalancer.sticky_session=1<br /><br />

Uno de los atributos más importantes es “Ibfactor”, el cual define el factor para el balanceo de carga, restringiendo el numero de “request” a enviar a una instancia particular de Tomcat.

Por último, crearemos unas páginas JSP para cada uno de los nodos, con los cuales validaremos que el cluster este funcionado correctamente.


TomcatNodo1

<br /><% session.setAttribute("dukechile","dukechile"); %><br /><br /><html><br /><br /><head><br /><br /><title>DukeChile - Culster</title><br /><br /></head><br /><br /><br /><br /><body><br /><br /><table width="100%" border="0" cellspacing="0" cellpadding="0"><br /><br /> <tr bgcolor="#CCCCCC"><br /><br /> <td width="13%">Tomcat Nodo 1</td><br /><br /> <td width="87%"> </td><br /><br /> </tr><br /><br /> <tr><br /><br /> <td>Session ID :</td><br /><br /> <td><%=session.getId()%></td><br /><br /> </tr><br /><br /></table><br /><br /></body><br /><br /></html><br /><br />

TomcatNodo2

<br /><% session.setAttribute("dukechile","dukechile"); %><br /><br /><html><br /><br /><head><br /><br /><title>DukeChile - Culster</title><br /><br /></head><br /><br /><br /><br /><body><br /><br /><table width="100%" border="0" cellspacing="0" cellpadding="0"><br /><br /> <tr bgcolor="#CCCCCC"><br /><br /> <td width="13%">Tomcat Nodo 2</td><br /><br /> <td width="87%"> </td><br /><br /> </tr><br /><br /> <tr><br /><br /> <td>Session ID :</td><br /><br /> <td><%=session.getId()%></td><br /><br /> </tr><br /><br /></table><br /><br /></body><br /><br /></html><br /><br />

TomcatNodo3

<br /><% session.setAttribute("dukechile","dukechile"); %><br /><br /><html><br /><br /><head><br /><br /><title>DukeChile - Culster</title><br /><br /></head><br /><br /><br /><br /><body><br /><br /><table width="100%" border="0" cellspacing="0" cellpadding="0"><br /><br /> <tr bgcolor="#CCCCCC"><br /><br /> <td width="13%">Tomcat Nodo 3</td><br /><br /> <td width="87%"> </td><br /><br /> </tr><br /><br /> <tr><br /><br /> <td>Session ID :</td><br /><br /> <td><%=session.getId()%></td><br /><br /> </tr><br /><br /></table><br /><br /></body><br /><br /></html><br /><br />


Por último, se debe reiniciar el Apache y luego iniciar cada una de las instancias del Tomcat.

Una vez los nodos estén iniciados, ejecutaremos la página cluster.jsp y validaremos el ID de la sesión asignada además del nombre del nodo que atendió la petición.

Recargamos nuevamente la pagina, y validamos que el ID de la sesión siga siendo la misma, con esto, validamos que el cluster este funcionado correctamente.

Si necesitan ajustar mejor la configuración del cluster, les recomiendo el libro “PROFESIONAL APACHE TOMCAT 6”.

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