Padrão Observer No padrão Observer temos dois objectos: um, designado Sujeito (Subject) que possui uma dada informação que pode variar ao longo da execução do programa, e outro, designado Observador (Observer) que está interessado em ser notificado sempre que essa informação varie. O padrão Observer diz-nos como estruturar as classes e objectos de modo a que o Sujeito e o Observador tenham baixo acoplamento, minimizando a interdependência entre estes dois objetos. Os objectos Observadores registam-se (subscrevem ) no objecto Sujeito para receberem actualizações quando os dados do objecto Sujeito mudarem. Quando os dados no objecto Sujeito mudam, os observadores são notificados. O padrão Observer define uma relação de dependência entre o sujeito e os observadores, de um-para-muitos, tal que quando um objecto (sujeito) muda de estado, todos os seus dependentes (observadores) são notificados e actualizados automaticamente. A relação é entre um sujeito e muitos observadores. interface IObservavel: public interface IObservavel { void registarobservador(iobservador o); void removerobservador(iobservador o); void notificarobservadores(); // regista um IObservador // remove um IObservador // notifica todos os Observadores // quando o estado do Sujeito muda classe Sujeito: import java.util.arraylist; public class Sujeito implements IObservavel { private ArrayList observadores = new ArrayList(); //dados que podem variar; // regista um IObservador public void registarobservador(iobservador o) { observadores.add(o); // remove um IObservador public void removerobservador(iobservador o) { int i = observadores.indexof(o); if (i>=0) observadores.remove(i); // notifica todos os Observadores quando o estado do Sujeito muda public void notificarobservadores() { for (int i = 0; i < observadores.size(); i++) { IObservador observador = (IObservador) observadores.get(i); observador.actualizar(temperatura); // simula ocorrencia de variacoes dos dados public void iniciarvariacaotemperatura() { while (true) { try { Thread.sleep(5000); catch (InterruptedException e) { int variacao = 1 + (int) (5 * Math.random()); int sinalvariacao = (Math.random() < 0.5)? -1 : 1; variacao = sinalvariacao * variacao; mudatemperatura(variacao);
private void mudatemperatura(int variacao) { this.temperatura += variacao; notificarobservadores(); interface IObservador: public interface IObservador { void actualizar(int temperatura); classe Observador1: public class Observador1 implements IObservador { public void actualizar(int temperatura) { this.temperatura = temperatura; System.out.println("Observador1: temperatuta actual= " + temperatura); classe Observador2: public class Observador2 implements IObservador { public void actualizar(int temperatura) { this.temperatura = temperatura; System.out.println("Observador2: temperatuta actual= " + temperatura); classe Main: public class Main { public static void main(string[] args) { Sujeito sujeito = new Sujeito(); IObservavel suj = sujeito; IObservador obs1 = new Observador1(); IObservador obs2 = new Observador2(); suj.registarobservador(obs1); suj.registarobservador(obs2); sujeito.iniciavariacaotemperatura(); A classe do objeto Sujeito não conhece os objetos Observadores concretos que notifica. Apenas sabe que implementam a interface IObservador, o que lhe permite conhecer uma interface comum a todos os observadores para lhes comunicar alterações no seu estado. O objeto sujeito apenas depende de uma lista de objetos que implementam a interface IObservador. Em qualquer altura (mesmo em runtime) podemos adicionar ou remover observadores.
Não é necessário modificar a classe do objeto Sujeito para adicionar ou remover observadores. A classe do objeto Sujeito implementa a interface IObservavel, o que garante que o objecto Sujeito pode registar observadores, remover observadores e notificar observadores. Para registar ou remover um observador num objeto Sujeito usase a interface IObservador. Deste modo um objeto Sujeito, sempre que o seu estado muda, notifica um objeto observador, mas apenas existe um fraco acoplamento entre estes dois objetos. As classes dos objetos Observadores também não conhecem o objeto Sujeito. No padrão Observer os objectos sujeito e observadores estão fracamente acoplados, isto é, podem interatuar mas têm pouco conhecimento uns dos outros. Mudanças quer na classe Sujeito quer numa classe Observador não afetarão a outra, desde que estas classes implementem as respectivas interfaces. O baixo acoplamento entre estas duas classes permite-nos fazer mudanças em qualquer uma, desde que os objectos Sujeito e Observador cumpram o contrato especificado nas respetivas interfaces. Padrão Observer da API do Java A linguagem Java tem suporte para o padrão Observer incorporado no package java.util: classe Observable (semelhante ao interface IObservavel), e interface Observer (semelhante ao interface IObservador). Observable é uma classe e não uma interface, portanto a classe Sujeito deve estender a superclasse java.util.observable. A classe Observable da API do Java já implementa todos os métodos necessários pra fornecer o comportamento observador/observável. A classe Sujeito a criar, subclasse de Observable, só necessita de aceder ao estado interno do objecto Observável, para sinalizar que o estado mudou (setchanged) e enviar notificação para todos os observadores registados (notifyobservers). public class java.util.observable { // adiciona um observador ao conjunto dos observadores deste objeto public synchronized void addobserver(observer o) // remove um observador ao conjunto dos observadores deste objeto public synchronized void deleteobserver(observer o) // coloca uma flag interna que indica que o estado deste objeto Observable mudou protected synchronized void setchanged() // coloca uma flag interna que indica que o estado deste objeto Observable não mudou protected synchronized void clearchanged() // verifica a flag interna para ver se o estado deste Observable mudou e notifica todos os // observadores; o argumento arg indica o que mudou public void notifyobservers(object arg) // verifica a flag interna e notifica todos os observadores se o objeto mudou public void notifyobservers()...
O método notifyobservers(object arg) verifica se o estado deste Observable mudou, como indicado pelo método haschanged, notifica todos os observadores e em seguida invoca o método clearchanged para colocar uma flag interna para indicar que este objecto não mudou. Cada objecto observador tem o seu método update com dois argumentos: este objeto sujeito e o argumento arg. O argumento arg pode ser usado para indicar que atributo do sujeito que mudou. O método notifyobservers() é semelhante ao de cima mas não envia o argumento arg. Neste caso o observador não recebe indicação sobre qual o atributo do sujeito que mudou. A interface Observer declara o seguinte método: update(observable obs, Object arg) Uma classe implementa a interface Observer quando quer ser informada de mudanças em objetos Observable. O método notifyobservers da classe Observable notifica todos os objectos Observer registados invocando para cada um o método update(observable obs, Object arg). O 1.º argumento do método update serve para o observer poder interrogar o objecto observable para determinar o seu novo estado. classe Sujeito: public class Sujeito extends Observable { private int temperatura = 20; //dados do sujeito que podem variar // simula ocorrencia de variacoes da temperatura public void iniciavariacaotemperatura() { while (true) { try { Thread.sleep(5000); catch (InterruptedException e) { int variacao = 1 + (int) (5 * Math.random()); int sinalvariacao = (Math.random() < 0.5)? -1 : 1; variacao = sinalvariacao * variacao; mudatemperatura(variacao); private void mudatemperatura(int variacao) { this.temperatura += variacao; setchanged(); notifyobservers(temperatura); classe Observador1: import java.util.observer; public class Observador1 implements Observer { public void update(observable sujeito, Object temperatura) { this.temperatura = (Integer)temperatura; System.out.println("Observador1: temperatuta actual= " + temperatura);
classe Observador2: import java.util.observer; public class Observador2 implements Observer { public void update(observable sujeito, Object temperatura) { this.temperatura = (Integer)temperatura; System.out.println("Observador2: temperatuta actual= " + temperatura); classe Main: public class Main { public static void main(string[] args) { Sujeito sujeito = new Sujeito(); Observable suj = sujeito; Observer obs1 = new Observador1(); Observer obs2 = new Observador2(); suj.addobserver(obs1); suj.addobserver(obs2); sujeito.iniciavariacaotemperatura();