Artigos Java O Padrão de Projeto Observer

De que se trata o artigo: O padrão de projeto Observer é responsável por observar e notificar a mudança de estado entre objetos distintos através de uma dependência um-para-muitos. Este padrão possui duas formas de implementação: uma delas é fazendo uso das classes nativas do JDK, enquanto a outra parte do princípio que o programador desenvolva suas próprias classes. Por fim, o artigo apresenta um pequeno projeto onde há a união do padrão Observer com o MVC.


Em que situação o tema é útil: O tema é útil a todo programador que desconhece o uso do padrão Observer e deseja saber como aplicá-lo. Também é indicado para quem tem interesse em utilizar o padrão Observer em conjunto com o padrão MVC.

Resumo DevMan: O uso de padrões de projeto é considerado uma boa prática no desenvolvimento de sistemas de software. Empregar padrões é sinônimo de organização e reutilização. Neste contexto, o Observer tem como objetivo manter o estado de objetos sempre atualizados através do conceito de observadores e observados. Além disso, este padrão pode muito bem ser usado em conjunto com outros, bem como com o padrão MVC.

Em meados da década de 70 o Engenheiro Civil ChristopherAlexander documentou os padrões mais utilizados no ramo da Engenharia Civil, e este feito o fez ser considerado o inventor dos padrões de projeto (Design Patterns). Tempos depois a área da informática adotou tal técnica e termo, e assim, deu início aos seus próprios padrões de projeto. Alguns desses padrões já são bastante conhecidos, como: o DAO, utilizado para separar as regras de persistência de dados das classes de negócios; o MVC, que possui a finalidade de dividir as tarefas dentro da aplicação, criando um baixo acoplamento e uma alta coesão das classes; entre vários outros.

Entre esses padrões, existe um denominado Observer. Este padrão define a dependência um-para-muitos entre objetos. Dessa forma, quando um objeto mudar seu estado, todos os seus dependentes serão avisados e atualizados automaticamente. O processo funciona mais ou menos da seguinte maneira: uma classe é marcada como observada e outras classes são marcadas como observadoras. Quando o objeto observado sofre uma alteração, ele envia uma mensagem do tipo “fui modificado” para seus observadores e estes são atualizados para o estado atual com tais alterações. A implementação do Padrão Observer pode ser realizada de duas formas distintas, uma sendo toda ela desenvolvida pelo programador, e a outra utilizando a própria implementação disponível nas classes do JDK, especificamente no pacote java.util.

Outro ponto que será abordado no artigo é a união entre padrões de projeto. Para isso, vamos demonstrar como desenvolver um projeto que utilize ao mesmo tempo os padrões Observer e MVC.

O uso de um padrão de projeto tem como princípio organizar e facilitar o desenvolvimento de sistemas. O Observer é um padrão que serve para manter o estado dos objetos sempre atualizados e pode, inclusive, ser adotado em conjunto com o padrão MVC.

Definindo o Padrão Observer

Como saber quando usar o padrão Observer? Essa é uma dúvida recorrente não somente para o padrão Observer, mas para qualquer outro padrão de projeto. Para saber quando usar um padrão específico é necessário conhecer o problema que deve ser resolvido e então buscar um padrão que possa solucioná-lo. O Observer pode ser usado quando existe no projeto a necessidade de fazer com que um conjunto de objetos seja notificado e atualizado automaticamente após um determinado evento no sistema. Este conjunto de objetos, que pode pertencer a classes distintas, observa e é notificado quando o estado de um outro objeto, que seja comum a eles, é alterado.

Este padrão de projeto utiliza basicamente duas classes: a que será observada (Subject ou Observable) e a observadora (Observer). As classes observadoras devem implementar uma interface específica, já a classe que será observada implementa uma interface ou estende uma superclasse.

A vantagem encontrada neste padrão é que tanto os observadores quanto os sujeitos (observados) podem ser reutilizados, já que existe um baixo acoplamento entre eles, devido ao uso de interfaces e classes abstratas, o que é um bom princípio de design. Com isso, é possível aumentar o número de observadores sem precisar modificar a classe observada. O observador pode ser implementado de forma que, quando receber uma notificação de mudança de estado do objeto observado, ele tenha autonomia em considerá-la ou ignorá-la.

A desvantagem é que usar este padrão de forma indiscriminada pode causar sério impacto na performance do sistema. Quando todos notificam todos a cada mudança, o sistema acaba ficando inundado de requisições, o que poderá levar a um desempenho mais lento.

Métodos que definem o padrão

O Observer é formado por métodos que possuem padrões de nomenclatura e comportamentos específicos. É importante seguir estes padrões para que implementações diferentes do Observer possam ser facilmente identificadas por desenvolvedores que não as codificaram. Os métodos listados a seguir estão presentes na implementação nativa do JDK:

  • addObserver(Observer o) – adiciona o observador, recebido como parâmetro, a uma lista de observadores que devem implementar a Interface Observer;
  • removeObserver(Observer o) – remove o objeto observador, recebido como parâmetro, da lista de observadores;
  • hasChanget() – retorna true quando o método setChange() é invocado, e false quando o método clearChange() for invocado;
  • setChange() – este método é invocado quando o objeto for modificado, alertando o método hasChanged() a retornar true;
  • clearChange() – sua função é alertar que as alterações já foram realizadas e então o método hasChanged() passa a retornar false. Geralmente esse método é invocado por notifyObservers() após este realizar sua função;
  • notifyObservers() e notifyObservers(Object o) – notifica os observadores que houve alteração nos objetos observados. O método ...
    Quer ler esse conteúdo completo? Tenha acesso completo