Observer: Sinto que tem alguém me olhando.....

Nesse post vou falar um pouco sobre o Padrão de Projeto Observer, esclarecendo sua função, algumas aplicações e como podemos implementá-lo.

Aprendendo com o Chaves!
O Sr. Madruga diz para o Chaves que está brincando na vila:
-Chaves, você fica aqui brincando, e se o Sr. Barriga chegar para me cobrar o aluguel, você grita: "Já chegou o disco voador!"

Não vamos questionar aqui idoneidade ou o compromisso do Sr. Madruga, mas sim entender o que está acontecendo.

O Sr. Madruga pediu que o Chaves ficasse ali na vila, e observasse pela chegada do Sr. Barriga. Quando isso acontecesse, ele deveria avisar, através de uma frase combinada, que o fato havia acontecido, assim o Sr. Madruga saberia que é hora de se esconder do Sr. Barriga.

Observando essa situação de uma forma mais detalhada, compreendemos a presença de:

• Um evento: a chegada do Sr. Barriga.
• Um observador: o Chaves, que ficará de olho no acontecimento do evento.
• Algo que pode ser observado: O Sr. Barriga, coisa fácil de fazer, dado o seu tamanho :-D
• Um interessado no evento: o Sr. Madruga, para poder se esconder.
• Um alerta: a frase combinada que o Chaves deveria gritar, para poder avisar que o evento aconteceu.

Como isso se relaciona com Desenvolvimento?
Durante o desenvolvimento de um sistema, muitas vezes presenciamos a mesma situação: precisamos ser avisados quando um determinado evento acontecer. Um exemplo disso poderia ser um sistema de controle de estacionamento.

Imagine que ao entrar no estacionamento, você vê um grande monitor que mostra todas as vagas de estacionamento que estão livres. Quando um carro estaciona em uma vaga (ou sai de uma vaga), um sensor dispara um sinal para o sistema, e a tela que fica no portão do estacionamento é atualizada, mostrando que aquela vaga agora está ocupada (ou desocupada).

Bom nesse caso temos os mesmos envolvidos:

• Um evento: quando um carro estaciona ou deixa a vaga.
• Um observador:  o sensor do estacionamento.
• Algo que pode ser observado: o carro entrando ou saindo da vaga.
• Um interessado no evento: a tela que fica no portão de entrada no estacionamento.
• Um alerta: o sinal que o sensor dispara para o sistema.

Esse é apenas um exemplo, no dia-a-dia do desenvolvimento, existem diversas outras situações que você pode precisar fazer algo parecido com isso. Outros exemplos poderiam ser:

• Saber quando um elemento de uma tabela é selecionado.
• Saber quando um botão é clicado.
• Atualizar o gráfico de uma tela quando os dados do gráfico são alterados.

Enfim, as aplicações são muitas. E lidar com essas situações se tornou algo tão comum na vida dos desenvolvedores que eles decidiram padronizar uma solução para esse problema. Por isso se dizemos que isso é um Padrão de Projeto (mas isso é assunto para outro post), e o nome desse padrão é Observer, também chamado como Listener, dependendo da aplicação, mas o objetivo é o mesmo.

Legal!!! Como eu faço isso?

Bom, agora que você já está entendo o objetivo desse padrão de projeto, vamos para a parte prática.

Sempre que você precisar implementar esse padrão de Observador, o básico que você precisará será uma interface que permita identificar que uma determinada classe quer observar algum evento. Algo parecido com:

public interface Observador {
    public void avisar(Evento evento);
}

Além disso, você precisará que a classe que será observada, possa armazenar uma lista de observadores, e possua um método que seja capaz de avisar todos os observadores de que um evento aconteceu. Algo como:

public class Observavel {
    private List observadores;
    public Observavel() {
        this.observadores = new LinkedList();
    }

    public void adicionarObservador(Observador observador) {
        this.observadores.add(observador);
    }

    public void removerObservador(Observador observador) {
        this.observadores.remove(observador);
    }

    public void dispararEvento(Evento evento) {
        for (Observador observador : this.observadores)
            observador.avisar(evento);
        }
    }
}

Isso é o básico que você irá precisar. Aqui está um projeto do Eclipse com a implementação de nosso sistema de estacionamento usando esse padrão.

Mas espere ai! Se isso é um padrão tão estabelecido, será que não tem algo pronto para fazer isso? Mas é claro!!! A linguagem Java já disponibiliza uma implementação dessa classe e dessa interface para facilitar as coisas para você. Utilize:

• java.util.Observer: a interface que define que uma classe é uma observadora de um evento.
• java.util.Observable: uma classe que é observável, permitindo que sejam adicionados e removidos observadores.

É isso por hoje, obrigado e não esqueçam de comentar :-D