Les había comentado en los anteriores tutoriales que trataría de que los ejemplos aquí mostrados tratarían sobre aplicaciones reales dentro de nuestros desarrollos, y si bien lo que les traigo ahora es un ejemplo práctico, no lo mostraré tal cual, ya que es parte de una solución que estoy aplicando actualmente en el trabajo y por motivos de cuidar mi trasero privacidad hacia la empresa, abordaré el problema con un contexto más teórico. Sin embargo, el patrón al que le dedicamos este tutorial es simple de entender y bastante práctico en su aplicación, por lo que no dudo que encontrarán usos reales para él.
El Patrón Observer
El observador es un patrón de diseño dónde se define una relación entre objetos uno-a-varios. Dicha relación se da entre un objeto observado y un conjunto de objetos observadores, esto es cuando un objeto (el observado) cambia su estado, se notifica a los demás objetos relacionados a él (los observadores) para que éstos se actualicen.
Ejemplo
Les platicaré mas o menos como funciona el contexto, imaginen que definen un objeto que puede tomar varios estados, si fuera un libro por ejemplo tendríamos que puede estar en buen estado, deteriorado, roto, incompleto, etc. Y si hablamos de una biblioteca escolar, cuándo un alumno devuelve un libro en estado, por ejemplo, roto, involucraría no solamente el departamento bibliotecario que reporta la anomalía, también el departamento de control escolar (por mencionar alguno) levantaría una sanción al alumno y el departamento de cobranza sería el encargado de fijar la cuota, sin mencionar que el alumno contaría con una sanción en su historial. Es decir, que son muchos los objetos (biblioteca, control escolar, cobranza, alumno, etc.) que deben realizar operaciones cada vez que cambie el estado del objeto observado. Pues en el trabajo nos topamos con una situación parecida (no tan simple), dónde numerosos objetos dependían del estado en que se encontrará el objeto observado y que debían ser notificados en tiempo de ejecución cada vez que éste cambiará su estatus. Por suerte Java tiene clases especiales (Observer y Observable) para que apliquemos éste patrón de manera sencilla y sin mayores complicaciones.
Para empezar definamos el objeto que será el observado (ObjetoObservado), y que tiene que heredar de la clase abstracta Observable:
Ésta clase tendrá un método que hará el cambio y notificará a los objetos observadores. Lo siguiente es definir la clase Observador que implementará la interfaz Observer. Todas las clases que sean observadoras tendrán que implementar ésta interfaz. La clase Observador tendrá un método para actualizar al objeto dependiente en base al cambio que haya tenido el objeto observado:
Lo que hice a continuación es crear una clase que sirviera como un manejador de objetos observados y observadores. Dicha clase tiene métodos para añadir/eliminar observadores a un objeto observado, setear cambios y notificar a los observadores y uno más para actualizar observadores. La clase es la siguiente:
Ahora desde nuestro código principal crearemos una instancia de PatronObserver que nos permitirá implementar el patrón añadiendo observadores, observados, notificando cambios y actualizando observadores.
Saludos y hasta el próximo tutorial.
No hay comentarios.:
Publicar un comentario