Observers con Java Core

Este pequeño articulo pretende mostrar las facilidades que ofrece Java para implementar el patrón Observer ([+] info http://en.wikipedia.org/wiki/Observer_pattern).

Sin entrar en detalles acerca del patrón, en la mayoría de los contextos buscamos tener un objeto observado, el cual cada vez que cambia de estado o sucede algo importante, sin saber a quien enviara un mensaje, notificando que su nuevo estado al resto de los objetos que observan.

En Java, contamos con dos clases para implementar este patrón, la primera es la clase: java.util.Observable, esta clase tiene varios métodos ya implementados, de los cuales los mas importantes son:

notifyObservers()
notifyObservers(Object arg)
setChanged

El primero y el segundo hacen exactamente lo mismo, invocan a los observadores, la diferencia fundamental recae en que el primero pasara null como parámetro a los observadores.

El tercer método, es aun mas importante, pues si invocamos a cualquiera de los métodos notify sin antes haber invocado a setChanged, el Observable no sabrá que su estado a cambiado y por lo tanto no llamara a ningún observador.

Por ultimo, el metodo: addObserver (Observer observer), permite agregar un nuevo observador, lo cual nos permite contar con N observadores para un objeto.

Ahora bien, asociado a la clase Observable, necesitamos la interface Observer; esta clase nos permite observar los cambios del objeto observable como anteriormente señalábamos, para ello debemos simplemente implementar el método:

update(Observable observable, Object parameter)

Aquí el primer parámetro es el objeto observable que nos esta notificando que cambio propiamente, el segundo el es argumento pasado por el objeto observable cuando su estado cambia y el notifyObservers es invocado.

Como pueden darse cuenta, este par de simples clases nos permiten implementar el patrón de una forma sencilla y estándar dentro del core de Java. Adicionalmente vale la pena comentar que en ambientes Web, Java EE proporciona Listener para Observar los cambios en objetos como el SevletContext (scope application), HttpSession (scope session), HttpServletRequest (scope request), etc.

Ejemplo:

import java.text.MessageFormat;

import java.util.HashMap;

import java.util.Map;

import java.util.Observable;

import java.util.Observer;

public class MyContextObservable extends Observable {

private Map attributes = new HashMap();

public enum ContextOperation {

SET, DELETE;

}

public void setAttribute(String key, Object o) {

this.attributes.put(key, o);

this.notifyChange(ContextOperation.SET, key, o);

} // setAttribute

public void deleteAttribute (String key) {

Object o = this.attributes.remove(key);

if(null != o) {

this.notifyChange(ContextOperation.DELETE, key, o);

}

} // deleteAttribute.

private void notifyChange(ContextOperation operation, String key, Object o) {

this.setChanged();

this.notifyObservers(new Object[] { operation, key, o });

} // notifyChange.

public static void main(String[] args) {

MyContextObservable myContextObservable = new MyContextObservable ();

myContextObservable.addObserver(new DummyObserver ());

myContextObservable.setAttribute("one", "First attribute");

myContextObservable.setAttribute("two", "Second attribute");

myContextObservable.deleteAttribute("one");

}

} // MyContextObservable.

class DummyObserver implements Observer {

@Override

public void update(Observable o, Object arg) {

MessageFormat messageFormat = new MessageFormat ("Message {0}, key {1}, value {2}");

Object[] params = (Object[])arg;

if ((null != params) && (params.length > 1)) {

System.out.println(messageFormat.format(params));

}

} // update

} // DummyObserver.

Salida:

Message SET, key one, value First attribute

Message SET, key two, value Second attribute

Message DELETE, key one, value First attribute

Un saludo,
J