Observer Pattern em Java: Notificações e Comunicação Eficiente

Introdução

O Observer Pattern (Padrão Observador) é um padrão de design comportamental que define uma dependência um-para-muitos entre objetos, de modo que quando um objeto muda de estado, todos os seus dependentes são notificados e atualizados automaticamente. Este padrão é fundamental em sistemas onde diferentes componentes precisam reagir a mudanças de estado de forma desacoplada.

Neste post, exploraremos o conceito do Observer Pattern, suas vantagens e como implementá-lo em Java com exemplos práticos de sistemas de notificação e atualizações em tempo real.

O que é o Observer Pattern?

O Observer Pattern estabelece uma relação de dependência entre objetos onde um objeto (Subject/Observable) mantém uma lista de dependentes (Observers) e os notifica automaticamente sobre mudanças de estado. Isso permite que múltiplos objetos sejam informados sobre mudanças sem que o objeto que mudou precise conhecer os detalhes específicos dos objetos dependentes.

Principais componentes:

Subject (Assunto): Interface que define métodos para adicionar, remover e notificar observadores.
ConcreteSubject (Assunto Concreto): Implementa a interface Subject e armazena o estado de interesse dos observadores.
Observer (Observador): Interface que define o método de atualização que será chamado quando o subject mudar.
ConcreteObserver (Observador Concreto): Implementa a interface Observer e define como reagir às mudanças do subject.

Quando usar o Observer Pattern?

Quando uma mudança em um objeto requer mudanças em outros objetos, mas você não sabe quantos objetos precisam ser alterados.
Para implementar sistemas de notificação e eventos.
Quando você deseja desacoplar o objeto que envia notificações dos objetos que as recebem.
Para criar sistemas de modelo-visão (MVC) onde as visões precisam ser atualizadas quando o modelo muda.
Em sistemas de publicação-assinatura (pub-sub) onde múltiplos assinantes devem ser notificados sobre eventos.

Exemplo Prático em Java

Vamos implementar um sistema de notícias onde diferentes tipos de assinantes podem se inscrever para receber atualizações sobre diferentes categorias de notícias:

1. Criando a Interface Observer

public interface Observer {
    void update(String news, String category);
}

2. Criando a Interface Subject

public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String news, String category);
}

3. Implementando o Subject Concreto

import java.util.ArrayList;
import java.util.List;

public class NewsAgency implements Subject {
    private List<Observer> observers;
    private String latestNews;
    private String category;
    
    public NewsAgency() {
        this.observers = new ArrayList<>();
    }
    
    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
        System.out.println("Novo observador adicionado!");
    }
    
    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
        System.out.println("Observador removido!");
    }
    
    @Override
    public void notifyObservers(String news, String category) {
        System.out.println("Notificando " + observers.size() + " observadores sobre: " + category);
        for (Observer observer : observers) {
            observer.update(news, category);
        }
    }
    
    public void publishNews(String news, String category) {
        this.latestNews = news;
        this.category = category;
        notifyObservers(news, category);
    }
    
    // Getters
    public String getLatestNews() { return latestNews; }
    public String getCategory() { return category; }
}

4. Implementando os Observers Concretos

// Observer para notícias de tecnologia
public class TechEnthusiast implements Observer {
    private String name;
    
    public TechEnthusiast(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String news, String category) {
        if ("TECNOLOGIA".equals(category)) {
            System.out.println(name + " recebeu notícia de TECNOLOGIA: " + news);
        }
    }
    
    public String getName() { return name; }
}

// Observer para notícias de esportes
public class SportsLover implements Observer {
    private String name;
    
    public SportsLover(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String news, String category) {
        if ("ESPORTES".equals(category)) {
            System.out.println(name + " recebeu notícia de ESPORTES: " + news);
        }
    }
    
    public String getName() { return name; }
}

// Observer universal que recebe todas as notícias
public class NewsReader implements Observer {
    private String name;
    
    public NewsReader(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String news, String category) {
        System.out.println(name + " recebeu notícia de " + category + ": " + news);
    }
    
    public String getName() { return name; }
}

5. Exemplo de Uso

public class ObserverPatternDemo {
    public static void main(String[] args) {
        // Criando a agência de notícias
        NewsAgency agency = new NewsAgency();
        
        // Criando observadores
        TechEnthusiast techObserver = new TechEnthusiast("João");
        SportsLover sportsObserver = new SportsLover("Maria");
        NewsReader generalObserver = new NewsReader("Carlos");
        
        // Adicionando observadores
        agency.addObserver(techObserver);
        agency.addObserver(sportsObserver);
        agency.addObserver(generalObserver);
        
        System.out.println("\n=== Publicando notícias ===");
        
        // Publicando notícias
        agency.publishNews("Lançamento do novo iPhone 16", "TECNOLOGIA");
        System.out.println();
        
        agency.publishNews("Brasil vence a Copa do Mundo", "ESPORTES");
        System.out.println();
        
        agency.publishNews("Nova descoberta em inteligência artificial", "TECNOLOGIA");
        System.out.println();
        
        // Removendo um observador
        agency.removeObserver(techObserver);
        System.out.println("\n=== Após remover observador de tecnologia ===");
        
        agency.publishNews("Lançamento do framework Spring Boot 4.0", "TECNOLOGIA");
    }
}

6. Resultado da Execução

Novo observador adicionado!
Novo observador adicionado!
Novo observador adicionado!

=== Publicando notícias ===
Notificando 3 observadores sobre: TECNOLOGIA
João recebeu notícia de TECNOLOGIA: Lançamento do novo iPhone 16
Carlos recebeu notícia de TECNOLOGIA: Lançamento do novo iPhone 16

Notificando 3 observadores sobre: ESPORTES
Maria recebeu notícia de ESPORTES: Brasil vence a Copa do Mundo
Carlos recebeu notícia de ESPORTES: Brasil vence a Copa do Mundo

Notificando 3 observadores sobre: TECNOLOGIA
João recebeu notícia de TECNOLOGIA: Nova descoberta em inteligência artificial
Carlos recebeu notícia de TECNOLOGIA: Nova descoberta em inteligência artificial

Observador removido!

=== Após remover observador de tecnologia ===
Notificando 2 observadores sobre: TECNOLOGIA
Carlos recebeu notícia de TECNOLOGIA: Lançamento do framework Spring Boot 4.0

Vantagens do Observer Pattern

Desacoplamento: O subject não precisa conhecer os detalhes dos observers, apenas que eles implementam a interface Observer.
Flexibilidade: Novos observers podem ser adicionados sem modificar o subject.
Reutilização: Os observers podem ser reutilizados com diferentes subjects.
Comunicação dinâmica: Objects podem se registrar e desregistrar dinamicamente.
Princípio Aberto/Fechado: O sistema está aberto para extensão (novos observers) mas fechado para modificação (subject não precisa mudar).

Quando evitar o Observer Pattern?

Dependências circulares: Quando observers também são subjects, pode criar dependências circulares complexas.
Ordem de notificação: Quando a ordem de notificação dos observers é importante.
Performance crítica: Em sistemas onde cada notificação tem custo computacional alto.
Debugging complexo: O fluxo de notificações pode tornar o debugging mais difícil.

Observer Pattern no Java

O Java fornece suporte nativo para o Observer Pattern através das classes java.util.Observer e java.util.Observable. No entanto, essas classes foram marcadas como @Deprecated desde o Java 9, sendo recomendado usar implementações customizadas ou APIs mais modernas como java.util.concurrent.Flow.

Exemplo com Java Flow API (Java 9+)

import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;

public class ModernObserverExample {
    public static void main(String[] args) {
        SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
        
        // Criando subscriber
        Flow.Subscriber<String> subscriber = new Flow.Subscriber<String>() {
            private Flow.Subscription subscription;
            
            @Override
            public void onSubscribe(Flow.Subscription subscription) {
                this.subscription = subscription;
                subscription.request(1);
            }
            
            @Override
            public void onNext(String item) {
                System.out.println("Recebido: " + item);
                subscription.request(1);
            }
            
            @Override
            public void onError(Throwable throwable) {
                throwable.printStackTrace();
            }
            
            @Override
            public void onComplete() {
                System.out.println("Concluído!");
            }
        };
        
        publisher.subscribe(subscriber);
        publisher.submit("Primeira mensagem");
        publisher.submit("Segunda mensagem");
        publisher.close();
    }
}

Padrões Relacionados

Mediator: Ambos promovem o desacoplamento, mas Mediator centraliza a comunicação enquanto Observer distribui notificações.
Command: Pode ser usado junto com Observer para implementar sistemas de undo/redo.
Model-View-Controller (MVC): Observer é fundamental na implementação do padrão MVC.
Publish-Subscribe: É uma variação do Observer Pattern para sistemas distribuídos.

Conclusão

O Observer Pattern é uma ferramenta poderosa para implementar sistemas de notificação e comunicação eficiente entre objetos. Ele promove o desacoplamento, flexibilidade e reutilização, tornando o código mais maintível e extensível.

Embora seja importante considerar suas limitações em cenários com muitos observers ou quando a ordem de notificação é crítica, o Observer Pattern continua sendo uma escolha excelente para a maioria dos sistemas que precisam de comunicação reativa entre componentes.

Se você trabalha com interfaces de usuário, sistemas de eventos ou qualquer aplicação que precise reagir a mudanças de estado, o Observer Pattern pode ser a solução ideal para seu projeto!

Gostou deste post? Continue acompanhando para mais conteúdos sobre padrões de design e desenvolvimento em Java!

🔗 Repositório de Exemplos

Aqui o link para nosso laboratório: https://github.com/Nosbielc/nosbielc-dev-demos