Responsive Web Development

UA16 — PHP: Padrões de Projeto

Design patterns são soluções consagradas para problemas recorrentes de organização de código. MVC, Singleton e Factory são os padrões centrais ensinados no curso e amplamente usados em frameworks PHP.

O que são Design Patterns?

Padrões de projeto (design patterns) são soluções reutilizáveis para problemas comuns de organização e arquitetura de software. Não existe um padrão ideal para todos os casos — cada um tem finalidade e características específicas. Os mais cobrados no curso são MVC, Singleton e Factory.

Padrão MVC — Model-View-Controller

Separa a aplicação em três camadas com responsabilidades distintas:

Fluxo de login com MVC

// Estrutura de pastas básica
/exemplo_mvc/
├── index.php         ← ponto de entrada, dispara o Controller
├── Controller/
│   └── controller.php ← recebe dados, chama Model, envia para View
├── Model/
│   └── model.php      ← valida usuário e senha, regras de negócio
└── View/
    └── view.php       ← exibe formulário de login e resultado

Vantagens do MVC

• Desenvolvimento paralelo: programadores e designers podem trabalhar simultaneamente em camadas diferentes.
• Reúso de código: componentes de uma camada podem ser reutilizados em outras partes do sistema.
• Manutenção facilitada: código dividido em partes específicas — mais fácil localizar e corrigir problemas.
• Compreensão facilitada: cada arquivo tem uma responsabilidade clara.

Padrão Singleton

Garante que uma classe seja instanciada uma única vez em toda a execução — o mesmo objeto é retornado sempre que requisitado. Usado principalmente em: conexão com banco de dados, classes de configuração, gerenciadores de log.

// conexao.php — Singleton para conexão com banco
class Conexao {
    private static $instancia = null;  // armazena a única instância

    private function __construct() {}  // private: impede new Conexao()

    public static function getInstance() {
        if (self::$instancia === null) {
            self::$instancia = new PDO(
                "mysql:host=localhost;dbname=ua16",
                "root", ""
            );
        }
        return self::$instancia;
    }
}

// Uso: nunca new Conexao() — sempre via ::getInstance()
$pdo = Conexao::getInstance();
$stmt = $pdo->query("SELECT * FROM alunos");
echo $stmt->fetch()['nome'];

Regras do Singleton

1. Construtor da classe deve ser private — impede instanciação direta com new.
2. Método getInstance() deve ser sempre utilizado para obter a instância.
3. Requisição deve usar :: (acesso estático): NomeClasse::getInstance().

Padrão Factory

Cria objetos de forma dinâmica sem que o chamador precise conhecer a classe concreta — a classe “fábrica” decide qual classe instanciar com base em um parâmetro de entrada.

// Interface define o contrato
interface Veiculo {
    public function modelo(): string;
}

// Classes concretas implementam a interface
class Renault implements Veiculo {
    public function modelo(): string { return "Renault Sandero"; }
}
class Ford implements Veiculo {
    public function modelo(): string { return "Ford Ka"; }
}

// Classe Factory decide qual instanciar
class VeiculoFactory {
    public static function criar(string $marca): Veiculo {
        return match($marca) {
            "Renault"   => new Renault(),
            "Ford"      => new Ford(),
            default    => throw new \InvalidArgumentException("Marca desconhecida"),
        };
    }
}

// Uso: o chamador não sabe nem precisa saber qual classe é criada
$v = VeiculoFactory::criar("Ford");
echo $v->modelo(); // Ford Ka

Benefícios do Factory

• Se a classe Veiculo for renomeada ou alterada, muda-se apenas ela e a VeiculoFactory.
• Se a criação do objeto for complexa, essa complexidade fica isolada na Factory.
• O chamador depende da interface, não da implementação concreta.

Referências bibliográficas desta UA

• Barreto, J. S. Desenvolvimento de Sistemas com PHP. Porto Alegre: SAGAH, 2018.