Observer (patrón de diseño)

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

Observador (en inglés: Observer) es un patrón de diseño que define una dependencia del tipo uno-a-muchos entre objetos, de manera que cuando uno de los objetos cambia su estado, notifica este cambio a todos los dependientes. Se trata de un patrón de comportamiento (existen de 3 tipos: Creación, Estructurales y de Comportamiento), es decir, está relacionado con algoritmos de funcionamiento y asignación de responsabilidades a clases y objetos. Los patrones de comportamiento describen no solamente estructuras de relación entre objetos o clases sino también esquemas de comunicación entre ellos y se pueden clasificar en función de que trabajen con clases (Método Plantilla) u objetos (Cadena de Responsabilidad, Comando, Iterador, Recuerdo, Observador, Estado, Estrategia, Visitante).

La variación de la encapsulación es la base de muchos patrones de comportamiento, por lo que cuando un aspecto de un programa cambia frecuentemente, estos patrones definen un objeto que encapsula dicho aspecto. Los patrones definen una clase abstracta que describe la encapsulación del objeto.

Este patrón también se conoce como el patrón de publicación-inscripción o modelo-patrón. Estos nombres sugieren las ideas básicas del patrón, que son: el objeto de datos, que se le puede llamar Sujeto a partir de ahora, contiene atributos mediante los cuales cualquier objeto Observador o vista se puede suscribir a él pasándole una referencia a sí mismo. El Sujeto mantiene así una lista de las referencias a sus observadores. Los observadores a su vez están obligados a implementar unos métodos determinados mediante los cuales el Sujeto es capaz de notificar a sus observadores suscritos los cambios que sufre para que todos ellos tengan la oportunidad de refrescar el contenido representado. De manera que cuando se produce un cambio en el Sujeto, ejecutado, por ejemplo, por alguno de los observadores, el objeto de datos puede recorrer la lista de observadores avisando a cada uno. Este patrón suele observarse en los frameworks de interfaces gráficas orientados a objetos, en los que la forma de capturar los eventos es suscribir listeners a los objetos que pueden disparar eventos.

El patrón Observer es la clave del patrón de arquitectura Modelo Vista Controlador (MVC).[1] De hecho el patrón fue implementado por primera vez en Smalltalk's MVC basado en un framework de interfaz.[2] Este patrón está implementado en numerosos librerías y sistemas, incluyendo todos los toolkits de GUI.

Patrones relacionados: Publicador-Subscriptor, Mediator, Singleton.

Objetivo[editar]

Definir una dependencia uno-a-muchos entre objetos, de tal forma que cuando el objeto cambie de estado, todos sus objetos dependientes sean notificados automáticamente. Se trata de desacoplar la clase de los objetos clientes del objeto, aumentando la modularidad del lenguaje, creando las mínimas dependencias y evitando bucles de actualización (espera activa o polling). En definitiva, normalmente, usaremos el patrón Observador cuando un elemento “quiere” estar pendiente de otro, sin tener que estar encuestando de forma permanente si éste ha cambiado o no.

Motivación[editar]

Si se necesita consistencia entre clases relacionadas, pero con independencia, es decir, con un bajo acoplamiento.

Aplicabilidad[editar]

Puede pensarse en aplicar este patrón cuando una modificación en el estado de un objeto requiere cambios de otros, y no deseamos que se conozca el número de objetos que deben ser cambiados. También cuando queremos que un objeto sea capaz de notificar a otros objetos sin hacer ninguna suposición acerca de los objetos notificados y cuando una abstracción tiene dos aspectos diferentes, que dependen uno del otro; si encapsulamos estos aspectos en objetos separados permitiremos su variación y reutilización de modo independiente.

Estructura[editar]

Estructura patrón Observador

Participantes[editar]

Tendremos sujetos concretos cuyos cambios pueden resultar interesantes a otros y observadores a los que al menos les interesa estar pendientes de un elemento y en un momento dado, reaccionar ante sus notificaciones de cambio. Todos los sujetos tienen en común que un conjunto de objetos quieren estar pendientes de ellos. Cualquier elemento que quiera ser observado tiene que permitir indicar:

  1. “Estoy interesado en tus cambios”.
  2. “Ya no estoy interesado en tus cambios”.

El observable tiene que tener, además, un mecanismo de aviso a los interesados.

A continuación tenemos a los participantes de forma desglosada:

  • Sujeto (Subject):
El sujeto concreto proporciona una interfaz para agregar (attach) y eliminar (detach) observadores. El Sujeto conoce a todos sus observadores.
  • Observador (Observer):
Define el método que usa el sujeto para notificar cambios en su estado (update/notify).
  • Sujeto Concreto (ConcreteSubject):
Mantiene el estado de interés para los observadores concretos y los notifica cuando cambia su estado. No tienen porque ser elementos de la misma jerarquía.
  • Observador Concreto (ConcreteObserver):
Mantiene una referencia al sujeto concreto e implementa la interfaz de actualización, es decir, guardan la referencia del objeto que observan, así en caso de ser notificados de algún cambio, pueden preguntar sobre este cambio.

Colaboraciones[editar]

La colaboración más importante en este patrón es entre el sujeto y sus observadores, ya que en el momento en el que el sujeto sufre un cambio, este notifica a sus observadores.

Diagrama de secuencia

Consecuencias[editar]

Las consecuencias de aplicar este patrón pueden ser tanto beneficiosas como pueden perjudicar algunos aspectos. Por una parte abstrae el acoplamiento entre el sujeto y el observador, lo cual es beneficioso ya que conseguimos una mayor independencia y además el sujeto no necesita especificar los observadores afectados por un cambio. Por otro lado, con el uso de este patrón ocurre que vamos a desconocer las consecuencias de una actualización, lo cual, dependiendo del problema, puede afectarnos en mayor o menor medida (por ejemplo, al rendimiento).

Implementación[editar]

A continuación vamos a ver una serie de opciones o problemas que se pueden presentar a la hora de implementar este patrón:

  • Opción 1:
Para evitar que el observador concreto tenga una asociación con el sujeto concreto, podríamos hacer que la relación entre sujeto y observador fuese bidireccional, evitando así asociaciones concretas, el problema es que dejaría de ser una interfaz. El que deje de ser una interfaz puede producir problemas si el lenguaje de programación no soporta la herencia múltiple.
Se podría eliminar la bidireccionalidad de la asociación pasando el sujeto como parámeto al método actualizary ya no tendríamos que referenciar el objeto observado. Esto podría causar problemas si observamos varios objetos, tanto de la misma clase como de distintas, ya que no elimina dependencias, y para hacer operaciones específicas sobre el objeto actualizado nos obliga a hacer en la implementación.
  • Opción 2:
Si hay muchos sujetos sin observador, la estructura de los observadores está desaprovechada, para solucionarlo podemos tener un intermediario que centralice el almacenamiento de la asociación de cada sujeto con sus observadores. Para esta solución creamos ese gestor de observadores usando el patrón Singleton(Instancia única), ya que nos proporciona una única referencia y no una por cada sujeto. El gestor aunque mejora el aprovechamiento del espacio, hace que se reduzca el rendimiento y se pierde eficiencia en el método notificar.
  • Opción 3:
El responsable de iniciar la comunicación es el sujeto concreto, pero se puede dar un problema cuando el objeto concreto está siendo actualizado de forma continua ya que debido a esto tendríamos que realizar muchas actualizaciones en muy poco tiempo. La solución sería suspender temporalmente las llamadas al método de actualización/notificación; por ejemplo, haciendo que el cliente pueda activar o desactivar las notificaciones y notificar todos los cambios cuando las vuelva a habilitar. El patrón Estado sería una posible solución para diseñar esta variante de no notificar si no se han dado cambios o hacerlo en caso de que si.
  • Opción 4 (Referencias inválidas):
A la hora de implementar este patrón debemos de ser cuidadosos cuando un elemento observable desaparece. En ciertos lenguajes será el gestor de memoria el que cada cierto tiempo debe de limpiará las referencias liberadas, pero si un observable que sigue siendo observado puede no liberarse nunca. Para solucionar este problema puede crearse una función “destruir (destroy) ” que notifique al gestor que el elemento observable va a desaparecer y si no estamos usando la variante del gestor el observable directamente des-registrará a sus observadores. Antes de esto hay que eliminar las referencias a este elemento, por tanto, hay que eliminar a los observadores antes de eliminar al observable, ya que así evitaremos tanto que aparezcan referencias inválidas al objeto una vez éste haya sido eliminado, como que se produzcan operaciones inválidas intentando invocarlo.
Podemos avisar a los observadores creando un método actualizar especial, en el que tendríamos dos opciones:
  1. El observador también muere.
  2. El observador sigue vivo, pero apunta a nulo.
  • Opción 5:
Ya que debemos asegurar la consistencia del estado del sujeto antes de iniciar una notificación, siempre notificaremos al final, ya que aunque en entorno multihilo notificamos antes de hacer los cambios, puede que los observadores soliciten información al observable cuando aún se van a hacer más cambios y se darían problemas de consistencia si se accede a un estado que aún no es el definitivo. De esta forma, los observadores ya no accederán a sujetos en estado inconsistente.

Por ejemplo:

Secuencia incorrecta:
                        a                                               
                        b                                               
                        c                                               
                        notificar()                             
                        d                                       
                        e                                               
                        f                                               
Secuencia correcta:
                        a
                        b
                        c
                        d
                        e
                        f
                        notificar()

Jerarquía con varios tipos des observadores: en este caso el hilo redefine cambios, no los notifica.

Jerarquía de varios observadores


  • Opción 6:
En mecanismos de notificación tradicionalmente hay dos opciones, la pull que es la que propone el patrón observador y la push hacia la que nos moveríamos si incluimos información como parámetros en el actualizar. El problema de hacer esto es que la interfaz del observador se vuelve más específica y por tanto menos genérica y reutilizable.

PULL: los objetos avisan de que han cambiado y el observador pregunta cuál ha sido el cambio.

PUSH: minimiza (eficiencia) que cuando algo cambia e informamos a todos los interesados, se realicen el menor número de llamadas posibles.

Dependiendo del problema ante el que nos encontremos, debemos de valorar que implementación se ajusta mejor para resolverlo de la forma más eficiente y efectiva o si las variantes anteriores pueden combinarse entre sí dependiendo de las características de escenario concreto. Por ejemplo, la opción 2 podría aplicarse cuando nos interesa aplicar en un sujeto concreto n métodos seguidos y no queremos notificar hasta que todos finalicen su ejecución.

Java[editar]

Soporte Java para el patrón Observador:

  Clase java.util.Observable                               
  addObserver(o Observer)                                     
  deleteObserver(o Observer)
  notifyObserver()
  notifyObservers(Object data)
  Interface java.util.Observer
  void update (Observable o, Object data)

Ejemplos[editar]

Ejemplo 1 en Java[editar]

 /*Esta clase abstracta representa los objetos susceptibles de ser
*observados. Incorpora metodos para agregar y eliminar observadores
*y un metodo de notificacion. La asociacion Observable-Observadores
*se implementa mediante un vector de observadores
*/
 
import java.util.ArrayList;
 
public abstract class Observable {
 
    //El constructor crea el vector con la asociacion Observable-Observador
    public Observable() {
        _observadores = new ArrayList<Observador>();
    }
 
    //Agregar y eliminar sencillamente operan sobre vector _observadores...
    public void agregarObservador(Observador o) {
        _observadores.add(o);
    }
 
    public void eliminarObservador(Observador o) {
        _observadores.remove(o);
    }
 
    //Notificacion: Para cada observador se invoca el método actualizar().
    public void notificarObservadores() {
        for (Observador o:_observadores) {
            o.actualizar();
        }
    }
 
    //Este atributo privado mantiene el vector con los observadores
    private ArrayList<Observador> _observadores;
}


/*Los observadores deben implementar la siguiente interfaz, es decir,
*tienen un metodo actualizar() para reaccionar a cambios del sujeto
*/
public interface Observador {
    public void actualizar();
}


/*Ejemplo de sujeto observable. Es una clase que mantiene un valor entero en
*el rango 0..maximo, donde maximo se establece en la construccion. La clase
*dispone de metodos para modificar el valor y para acceder al estado
*(valor, maximo). Extiende la clase observable heredando su
*/
 
public class Contador extends Observable {
 
    /*El constructor inicializa el estado del objeto: el maximo y el
    *valor inicial, siempre en el rango 0..maximo. Adicionalmente,
    *inicializa la parte de Observable que tiene un Contador...
    */
    public Contador(int valor, int maximo) {
        super();
        _maximo = maximo;
        _valor = enRango(valor);
    }
 
    //Este metodo privado asegura que un valor n esta entre 0..maximo
    private int enRango(int n) {
        if (n < 0) {
            return 0;
        } else if (n > _maximo) {
            return _maximo;
        } else {
            return n;
        }
    }
 
    //Estos dos metodos permiten el acceso al estado del contador
    public int valor() {
        return _valor;
    }
 
    public int maximo() {
        return _maximo;
    }
 
    /*Este metodo afecta al estado: primero se modifica de forma consistente
    *el estado y despues se notifica a los observadores del cambio
    */
    public void incrementarContador(int n) {
        _valor = enRango(_valor+n);
        notificarObservadores();
    }
 
    //Atributos privados que mantienen el estado del contador
    private int _valor, _maximo;
}


 
// Observador muy simple que ni siquiera consulta el estado del sujeto...
 
public class Detector implements Observador {
 
    public void actualizar() {
        System.out.println("Detector recibe actualizar!");
    }
 
}


//Un ejemplo de observador concreto de la clase contador.
 
public class Medidor implements Observador {
 
    //El constructor de Medidor establece la asociacion entre Medidor-Contador
    public Medidor(Contador contador) {
        _contador = contador;
    }
 
    /*Tras ser notificado de un cambio, un observador Medidor accede
    *al estado del Contador utilizando la asociacion
    */
 
    public void actualizar() {
        int porcentaje = _contador.valor() * 100 / _contador.maximo();
        System.out.println("Porcentaje del contador es " + porcentaje + "%");
    }
 
    //Mantiene la asociacion con el contador
    private Contador _contador;
}


//Un ejemplo de observador concreto de la clase contador.
 
public class ValorContador implements Observador {
 
    //El constructor establece la asociacion entre ValorContador-Contador
    public ValorContador(Contador contador) {
        _contador = contador;
    }
 
    /*Tras ser notificado de un cambio, un observador ValorContador accede
    *al estado del Contador utilizando la asociacion
    */
    public void actualizar() {
        System.out.println("Valor del contador es " + _contador.valor() );
    }
 
    //Mantiene asociacion con el sujeto observable
    private Contador _contador;
}


public class Main {
 
    public static void main(String... argv) {
 
        Contador c = new Contador(0,255);
 
        Detector d = new Detector();
        c.agregarObservador(d);
        c.incrementarContador(5);
 
        ValorContador v = new ValorContador(c);
        c.agregarObservador(v);
        c.incrementarContador(5);
 
        Medidor m = new Medidor(c);
        c.agregarObservador(m);
        c.eliminarObservador(d);
        c.incrementarContador(19);
    }
}

Ejemplo 2 en Python[editar]

Otro ejemplo sería un programa que leyese del teclado y cada línea se trataría como un evento. Cuando una línea fuere obtenida, se llamaría al método que notificaría a los observadores, tal que todos los observadores fueren avisados de la ocurrencia del evento mediante sus métodos de actualización (update).

A continuación el ejemplo, escrito en lenguaje Python, muestra este patrón.

class Listener:
     def __init__(self, name, subject):
         self.name = name
         subject.register(self)
 
     def notify(self, event):
         print self.name, "received event", event


class Subject:
     def __init__(self):
         self.listeners = []
 
     def register(self, listener):
         self.listeners.append(listener)
 
     def unregister(self, listener):
         self.listeners.remove(listener)
 
     def notify_listeners(self, event):
         for listener in self.listeners:
             listener.notify(event)


subject = Subject()
listenerA = Listener("<listener A>", subject)
listenerB = Listener("<listener B>", subject)
# El objeto Subject ahora tiene dos "escuchadores" registrados
subject.notify_listeners ("<event 1>")
# La salida obtenida es :
# <listener A> received event <event 1>
# <listener B> received event <event 1>


Diagramas correspondientes al ejemplo 1[editar]

Diagrama de clases
Diagrama de objetos

Enlaces externos[editar]

Wikilibros

  1. «Model-View-Controller». MSDN. Consultado el 01/06/2013.
  2. Gang Of Four