Singleton ou Observable? A Escolha Errada Pode Custar Sua Promoção!

Os padrões de projeto são fundamentais na criação de software bem estruturado e fácil de manter. Entre eles, o Singleton e o Observable são frequentemente utilizados em cenários que exigem controle de estado global e comunicação entre diferentes partes do sistema. Neste artigo, vamos explorar como esses dois padrões funcionam, quando utilizá-los, suas diferenças e fornecer exemplos práticos de como implementá-los.

O que é o Singleton?

O Singleton Pattern é um padrão de design criacional que assegura que uma classe tenha apenas uma instância e fornece um ponto global de acesso a essa instância. Esse padrão é útil quando você precisa de um objeto único em toda a aplicação, como em configurações globais, conexão com banco de dados, ou gerenciamento de logs.

Como Funciona o Singleton?

A principal característica do Singleton é que ele restringe a instância da classe a um único objeto, garantindo que todas as requisições de instância retornem o mesmo objeto. Para isso, o padrão normalmente utiliza um método estático que cria a instância apenas quando ela é solicitada pela primeira vez, garantindo a criação única e o uso do objeto em todo o sistema.

No diagrama abaixo, a sequência mostra como a instância do Singleton é criada e acessada, garantindo que seja única.

O diagrama de sequência do Observable demonstra como o padrão funciona com múltiplos observadores. O Subject (ou objeto observado) notifica todos os Observers registrados quando ocorre uma mudança de estado. Cada Observer reage à notificação, realizando as ações necessárias com base nas informações recebidas. O processo de notificação é propagado de forma que todos os observadores sejam atualizados simultaneamente, mantendo-os sincronizados com o estado do Subject. Esse padrão é útil quando há múltiplos componentes ou partes do sistema que precisam ser informados sobre mudanças no estado de um objeto.

Exemplo de Uso - Observable em TypeScript

// Interface Observer

interface Observer {

    update(message: string): void;

}



// Classe Subject

class Observable {

    private observers: Observer[] = [];



    // Método para adicionar observers

    public addObserver(observer: Observer): void {

        this.observers.push(observer);

    }



    // Método para remover observers

    public removeObserver(observer: Observer): void {

        const index = this.observers.indexOf(observer);

        if (index !== -1) {

            this.observers.splice(index, 1);

        }

    }



    // Método para notificar observers

    public notifyObservers(message: string): void {

        this.observers.forEach(observer => observer.update(message));

    }

}



// Classe Observer concreta

class ConcreteObserver implements Observer {

    private name: string;



    constructor(name: string) {

        this.name = name;

    }



    public update(message: string): void {

        console.log(`${this.name} recebeu a mensagem: ${message}`);

    }

}



// Uso do Observable

const observable = new Observable();



const observer1 = new ConcreteObserver("Observer 1");

const observer2 = new ConcreteObserver("Observer 2");



observable.addObserver(observer1);

observable.addObserver(observer2);



observable.notifyObservers("Mudança no sistema!");



observable.removeObserver(observer1);



observable.notifyObservers("Nova mudança!");

Quando Usar o Observable?

• 
  Eventos em interfaces gráficas: para reagir a cliques de botões, mudanças de campos, ou atualizações de tela.


• 
  Notificação de mudanças de estado: quando diversos componentes precisam ser informados sobre alterações em um objeto.


• 
  Modelagem de fluxo de dados reativo: em sistemas onde há propagação de dados ou eventos entre múltiplos sistemas, como em aplicações baseadas em eventos.

Diferenças entre Singleton e Observable

Embora ambos os padrões sirvam para gerenciar objetos de forma controlada, suas finalidades e comportamentos são bem diferentes:

Conclusão

Os padrões Singleton e Observable são fundamentais em diversas situações no desenvolvimento de software. O Singleton é ideal quando precisamos garantir uma única instância de uma classe em toda a aplicação, enquanto o Observable é útil para notificar e gerenciar interações entre múltiplos objetos com base nas mudanças de estado.

Ao escolher entre esses padrões, considere as necessidades do seu projeto. Use o Singleton quando a unicidade de uma instância for crucial para a aplicação, e utilize o Observable quando o seu sistema precisar reagir a mudanças de estado ou eventos.