Padrões comportamentais: Strategy, Observer e Command
Modele comportamento e comunicação com padrões comportamentais.
Padrões comportamentais: Strategy, Observer e Command é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.
Modelando comportamentos
Os padrões comportamentais orientam como os objetos colaboram e distribuem responsabilidades. Vamos nos concentrar em três que aparecem constantemente em sistemas PHP reais:
- Strategy — trocar um algoritmo em tempo de execução.
- Observer — transmitir eventos aos ouvintes interessados.
- Command — transformar uma solicitação em um objeto que você pode colocar em fila, registrar ou desfazer.
Strategy: a ideia
O padrão Strategy define uma família de algoritmos intercambiáveis por trás de uma única interface e permite que o cliente escolha um deles em tempo de execução. Ele substitui o switch extenso abaixo pelo polimorfismo: o contexto delega para a estratégia que estiver mantendo.
<?php
// The smell Strategy removes: branching on a type code
function price(string $type, float $base): float {
switch ($type) {
case 'standard': return $base + 5;
case 'express': return $base + 15;
default: throw new InvalidArgumentException($type);
}
}
echo price('express', 10), PHP_EOL; // 25
Strategy no código
Aqui, o custo de envio depende da transportadora escolhida. Cada estratégia encapsula um algoritmo de precificação; o contexto permanece inalterado quando você adiciona uma transportadora.
<?php
interface ShippingStrategy { public function cost(float $weight): float; }
final class Standard implements ShippingStrategy {
public function cost(float $w): float { return 5 + $w * 0.5; }
}
final class Express implements ShippingStrategy {
public function cost(float $w): float { return 15 + $w * 1.2; }
}
final class Cart {
public function __construct(private ShippingStrategy $strategy) {}
public function setStrategy(ShippingStrategy $s): void { $this->strategy = $s; }
public function quote(float $weight): float { return $this->strategy->cost($weight); }
}
$cart = new Cart(new Standard());
echo $cart->quote(10), PHP_EOL; // 10
$cart->setStrategy(new Express());
echo $cart->quote(10), PHP_EOL; // 27
Strategy com funções anônimas
No PHP, uma estratégia nem sempre precisa ser uma classe. Para casos leves, um callable ou a sintaxe de funções chamáveis de primeira classe é uma estratégia perfeitamente válida. Use classes completas quando o algoritmo tiver seu próprio estado ou dependências; use funções anônimas para escolhas simples e sem estado.
<?php
$strategies = [
'asc' => fn(array $a) => sort($a) ? $a : $a,
'desc' => fn(array $a) => rsort($a) ? $a : $a,
];
$data = [3, 1, 2];
print_r($strategies['desc']($data)); // [3,2,1]
Observer: a ideia
O padrão Observer permite que um objeto observado notifique muitos observadores quando seu estado muda, sem saber quem eles são. Isso desacopla a origem de um evento de seus manipuladores e fundamenta sistemas de eventos, ganchos e atualizações reativas.
Observer no código
O objeto observado mantém uma lista de observadores e chama update() em cada um. Novos ouvintes podem se conectar sem alterar a lógica do objeto observado.
<?php
interface Observer { public function update(string $event): void; }
final class OrderSubject {
private array $observers = [];
public function subscribe(Observer $o): void { $this->observers[] = $o; }
public function placed(string $id): void {
foreach ($this->observers as $o) { $o->update("order $id placed"); }
}
}
final class EmailObserver implements Observer {
public function update(string $e): void { echo "email: $e" . PHP_EOL; }
}
final class AuditObserver implements Observer {
public function update(string $e): void { echo "audit: $e" . PHP_EOL; }
}
$subject = new OrderSubject();
$subject->subscribe(new EmailObserver());
$subject->subscribe(new AuditObserver());
$subject->placed('42');
Observer versus PSR-14
O PHP moderno frequentemente expressa o Observer por meio de despachantes de eventos PSR-14: um despachante encaminha um objeto de evento aos ouvintes registrados. O modelo mental é o mesmo (objeto observado = evento, observadores = ouvintes), mas um despachante os desacopla ainda mais e oferece suporte a eventos interrompíveis. SplObserver/SplSubject existem na SPL, mas hoje são raramente usados.
Command: a ideia
O padrão Command encapsula uma solicitação como um objeto: a ação, seu receptor e seus parâmetros. Como a solicitação agora é um dado, você pode colocá-la em fila, registrá-la, repeti-la ou desfazê-la. O comando mais simples apenas transforma uma intenção em um valor, como mostrado abaixo.
<?php
final class SendEmail {
public function __construct(
public readonly string $to,
public readonly string $subject
) {}
}
// The request is now data you can store, serialize, or enqueue
$cmd = new SendEmail('user@example.com', 'Welcome');
echo json_encode($cmd), PHP_EOL;
Command no código
Cada comando implementa execute(). Um invocador os mantém e executa, desacoplado do que eles fazem. Adicionar undo() transforma isso em uma pilha completa de desfazer.
<?php
interface Command { public function execute(): string; }
final class Light { public bool $on = false; }
final class TurnOn implements Command {
public function __construct(private Light $light) {}
public function execute(): string { $this->light->on = true; return 'light on'; }
}
final class TurnOff implements Command {
public function __construct(private Light $light) {}
public function execute(): string { $this->light->on = false; return 'light off'; }
}
final class Invoker {
private array $queue = [];
public function add(Command $c): void { $this->queue[] = $c; }
public function run(): void {
foreach ($this->queue as $c) { echo $c->execute(), PHP_EOL; }
}
}
$light = new Light();
$inv = new Invoker();
$inv->add(new TurnOn($light));
$inv->add(new TurnOff($light));
$inv->run();
Barramentos de comandos
Os frameworks constroem um barramento de comandos com base nesse padrão: um objeto de transferência de dados de comando é despachado para exatamente um manipulador. Uma camada intermediária ao redor do barramento pode adicionar transações, validação e registro de maneira uniforme. Como os comandos são objetos simples e serializáveis, o mesmo manipulador pode ser executado de forma síncrona ou enviado a um processador de fila.
Escolhendo entre eles
- Strategy: uma operação, vários algoritmos intercambiáveis, escolhidos pelo chamador.
- Observer: um evento, várias reações independentes; a origem desconhece os manipuladores.
- Command: transformar uma solicitação em um objeto para que ela possa ser colocada em fila, registrada, repetida ou desfeita.
Eles combinam bem: um manipulador de comandos pode escolher uma estratégia e emitir eventos para observadores.
Verificação rápida
Associe o requisito ao padrão.
Recapitulação
Você modelou comportamentos com três padrões: Strategy para trocar algoritmos em tempo de execução (classes ou funções anônimas), Observer para transmitir mudanças de estado a ouvintes desacoplados (a base dos despachantes PSR-14) e Command para transformar solicitações em objetos que você pode colocar em fila, registrar e desfazer (a base dos barramentos de comandos). Juntos, eles mantêm a colaboração flexível e as responsabilidades claras.
Perguntas Frequentes
A aula “Padrões comportamentais: Strategy, Observer e Command” é grátis?
Sim — o texto completo de “Padrões comportamentais: Strategy, Observer e Command” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.
O que vou aprender em “Padrões comportamentais: Strategy, Observer e Command”?
Modele comportamento e comunicação com padrões comportamentais. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar PHP Academy?
Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Padrões comportamentais: Strategy, Observer e Command”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de PHP Academy?
Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Princípios SOLID na prática
- Padrões de criação: Factory, Builder e Singleton
- Padrões estruturais: Adapter, Decorator e Facade
- Padrões comportamentais: Strategy, Observer e Command