Lição: 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
- Inicializador Privado: Tornamos o construtor privado para evitar a instância externa.
- Propriedade Estática: Criamos uma propriedade estática que mantém a instância da nossa classe.
- 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
- Protocolo Observer: Este protocolo declara um método
update(data:)
que os observadores devem implementar para receber atualizações. - Classe Subject: Mantém uma lista de observadores e fornece métodos para adicionar, remover e notificar os observadores sobre mudanças.
- Observador Concreto: Esta classe implementa o protocolo
Observer
e define o métodoupdate
para lidar com as notificações. - 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!