28.11.2024

Aula 164: Singleton, Observer e Outros Padrões

Nesta aula, iremos explorar alguns padrões de design fundamentais em Swift: os padrões Singleton e Observer. Ambos são amplamente utilizados e essenciais para construir aplicações escaláveis e de fácil manutenção. Vamos mergulhar nesse assunto!

Padrão Singleton

O padrão Singleton garante que uma classe tenha apenas uma instância e fornece um ponto de acesso global a ela. Este padrão é particularmente útil para gerenciamento de recursos, como configurações compartilhadas, registro de logs ou acesso a um banco de dados.

Implementação do Singleton em Swift

Veja como você pode implementar um Singleton em Swift:

final class Singleton {
    // Inicializador privado para evitar instância externa
    private init() {}

    // Propriedade estática para manter a única instância
    static let shared = Singleton()

    // Método de exemplo para demonstrar funcionalidade
    func someMethod() {
        print("Olá do Singleton!")
    }
}

// Uso
let singletonInstance = Singleton.shared
singletonInstance.someMethod()

Explicação

1. Inicializador Privado: Tornamos o construtor privado para evitar a instância externa.
2. Propriedade Estática: Criamos uma propriedade estática que mantém a instância da nossa classe.
3. Acesso Global: A instância pode ser acessada usando Singleton.shared.

Padrão Observer

O padrão Observer define uma dependência de um-para-muitos entre objetos. Quando um objeto (o sujeito) muda de estado, todos os seus dependentes (os observadores) são notificados e atualizados automaticamente. Este padrão é útil para componentes que precisam comunicar alterações de estado sem um forte acoplamento.

Implementação do Padrão Observer em Swift

Aqui está uma implementação simples do padrão Observer:

import Foundation

// Protocolo para Observadores
protocol Observer: AnyObject {
    func update(data: String)
}

// Classe Sujeito que mantém uma lista de observadores
class Subject {
    private var observers = [Observer]()

    func addObserver(_ observer: Observer) {
        observers.append(observer)
    }

    func removeObserver(_ observer: Observer) {
        if let index = observers.firstIndex(where: { $0 === observer }) {
            observers.remove(at: index)
        }
    }

    func notifyObservers(data: String) {
        for observer in observers {
            observer.update(data: data)
        }
    }
}

// Implementação de Observador Concreto
class ConcreteObserver: Observer {
    func update(data: String) {
        print("Atualização recebida: \(data)")
    }
}

// Uso
let subject = Subject()
let observer1 = ConcreteObserver()
let observer2 = ConcreteObserver()

subject.addObserver(observer1)
subject.addObserver(observer2)

subject.notifyObservers(data: "Novos dados disponíveis!")

subject.removeObserver(observer1)
subject.notifyObservers(data: "Mais dados disponíveis!")

Explicação

1. Protocolo Observer: Este protocolo declara um método update(data:) que os observadores devem implementar para receber atualizações.
2. Classe Subject: Mantém uma lista de observadores e fornece métodos para adicionar, remover e notificar os observadores sobre mudanças.
3. Observador Concreto: Esta classe implementa o protocolo Observer e define o método update para lidar com as notificações.
4. Uso: Criamos uma instância de Subject, adicionamos observadores e notificamos quando novos dados estão disponíveis.

Conclusão

Entender e implementar padrões de design como Singleton e Observer pode aumentar significativamente a estrutura e a manutenção do seu código. O padrão Singleton é perfeito para instâncias compartilhadas, enquanto o padrão Observer é excelente para comunicação desacoplada entre componentes. À medida que você constrói aplicações mais complexas, esses padrões ajudarão a gerenciar relacionamentos entre os componentes de forma eficaz.

Experimente esses padrões em seus próprios projetos para melhor compreender sua utilidade e vantagens!

Video

Navigation