Guia Rápido de padrões: Singleton, Facade e Observer

Índice

  1. Singleton
  2. Facade
  3. Observer

Singleton

Objetivo: Garantir que uma classe tenha apenas uma única instância e fornecer um ponto global de acesso a ela.

Passo a Passo (Receita de Bolo):

  1. Privatize o construtor - Isso impede que outros criem instâncias da classe diretamente.
  2. Crie uma variável estática para armazenar a única instância da classe.
  3. Implemente um método estático público que:

Obs.: Se for necessário implementar outros métodos no singleton, eles podem ser aplicados normalmente como em qualquer outra classe.

Exemplo em PHP:

class ConectorSingleton {

    # Atributo privado e estático com o mesmo nome da classe usado para armazenar o Singleton
    private static ?ConectorSingleton $ConectorSingleton = null;
    private array $configuracoes = []; // Esse array é um atributo opcional que usei pra explicar implementação de métodos adicionais

    # Construtor privado para evitar criação direta
    private function __construct() {}

    # Método estático para obter a instância única
    public static function getInstancia(): ConectorSingleton {
        if (self::$ConectorSingleton === null) {
            self::$ConectorSingleton = new ConectorSingleton();
        }
        return self::$ConectorSingleton;
    }

    # Método para adicionar uma configuração ao conector do bd
    public function setConfiguracao(string $chave, mixed $valor): void {
        $this->configuracoes[$chave] = $valor;
    }

    # Método para obter uma configuração setada
    public function getConfiguracao(string $chave): mixed {
        return $this->configuracoes[$chave] ?? null;
    }

    # Método para remover uma configuração setada
    public function removeConfiguracao(string $chave): void{
        unset($this->configuracoes[$chave]);
    }
}

# Uso
$conectorBD = ConectorSingleton::getInstancia();
$conectorBD->setConfiguracao('db_host', 'localhost');
$conectorBD->setConfiguracao('db_user', 'root');

echo $conectorBD->getConfiguracao('db_host'); // localhost

$cconectorBD2 = ConectorSingleton::getInstancia();
echo $cconectorBD2->getConfiguracao('db_user'); // root

Facade

Objetivo: Fornecer uma interface simplificada para um conjunto de subsistemas complexos. O padrão Facade centraliza a implementação de várias classes e métodos em apenas uma classe.

Passo a Passo (Receita de Bolo):

  1. Identifique os subsistemas:
  2. Crie uma classe "Fachada":
  3. Implemente métodos simples na fachada que:

Exemplo em php


# Primeira classe 
class Estoque {
    public function verificarEstoque(int $produtoId): string{
        return "Produto $produtoId disponível no estoque.\n";
    }
}

# Segunda classe
class Pagamento {
    public function processarPagamento(float $valor): string {
        return "Pagamento de R$ $valor processado.\n";
    }
}

# Terceira classe
class Envio {
    public function organizarEnvio(int $produtoId): string {
        return "Produto $produtoId preparado para envio.\n";
    }
}

# Classe Facade para encapsular as três classes acima, criando uma implementação única que garanta (1) a sequencialidade
# das operações e (2) simplifique a implementação das classes acima. 
class PedidoFacade {
    
    # Um atributo para cada classe que desejamos implementar
    private Estoque $estoque;
    private Pagamento $pagamento;
    private Envio $envio;

    # Construtor que implementa todas as classes
    public function __construct() {
        $this->estoque = new Estoque();
        $this->pagamento = new Pagamento();
        $this->envio = new Envio();
    }

    # Método que realiza todas as operações
    public function processarPedido(int $produtoId, float $valor): string {
        $result = $this->estoque->verificarEstoque($produtoId);
        $result .= $this->pagamento->processarPagamento($valor);
        $result .= $this->envio->organizarEnvio($produtoId);
        return $result;
    }
}

# Uso
$pedido = new PedidoFacade();
echo $pedido->processarPedido(123, 150.00);

Observer

Objetivo: Permitir que objetos observadores sejam notificados automaticamente sempre que o objeto observado sofrer mudanças.

Passo a Passo (Receita de Bolo):

  1. Crie uma interface para os Observadores:
  2. Implemente a interface nos observadores que desejam ser notificados.
  3. Adicione uma lista de observadores no objeto observado.
  4. Implemente métodos para adicionar, remover e notificar observadores.
  5. Sempre que algo mudar no objeto observado, chame o método de notificação.

Exemplo em php:


# Interface que será aplicada nas classes desejadas
interface Observer {
    # Método que será implementado pelas classes que observam notificações
    public function notificar(string $mensagem): void;
}

# Classe que implementará a interface Observer
class Usuario implements Observer {
    private string $nome; // Atributo para armazenar o nome do usuário

    # Construtor para inicializar o nome do usuário
    public function __construct(string $nome) {
        $this->nome = $nome;
    }

    # Implementação do método notificar, definido na interface Observer
    # Esse método será chamado para enviar notificações ao usuário
    public function notificar(string $mensagem): void {
        echo "Notificação para {$this->nome}: {$mensagem}\n";
    }
}

# Classe Blog que será o sujeito "observado" pelos usuários
class Blog {
    private array $inscritos = []; // Lista de objetos que implementam Observer (usuários inscritos)
    private array $artigos = [];  // Lista de artigos publicados no blog

    # Método para inscrever um usuário no blog
    public function inscrever(Observer $usuario): void {
        $this->inscritos[] = $usuario; // Adiciona o usuário na lista de inscritos
    }

    # Método para publicar um novo artigo
    public function publicarArtigo(string $titulo): void {
        $this->artigos[] = $titulo; // Armazena o título do novo artigo
        $this->notificarUsuarios("Novo artigo publicado: $titulo"); // Notifica os inscritos sobre o novo artigo
    }

    # Método privado para notificar todos os usuários inscritos
    private function notificarUsuarios(string $mensagem): void {
        # Itera sobre todos os inscritos e chama o método notificar para cada um
        foreach ($this->inscritos as $usuario) {
            $usuario->notificar($mensagem);
        }
    }
}

// Uso
// Cria dois usuários com os nomes João e Maria
$usuario1 = new Usuario("João");
$usuario2 = new Usuario("Maria");

// Cria uma instância da classe Blog
$blog = new Blog();

// Inscreve os usuários no blog
$blog->inscrever($usuario1);
$blog->inscrever($usuario2);

// Publica um novo artigo e notifica os inscritos
$blog->publicarArtigo("Introdução ao PHP");