Aprendendo

Padrões de
Projeto em PHP

William Sanders

Novatec
Authorized Portuguese translation of the English edition of titled Learning PHP Design Patterns ISBN 9781449344917
© 2013 William B. Sanders. This translation is published and sold by permission of O'Reilly Media, Inc., the owner of
all rights to publish and sell the same.

Tradução em português autorizada da edição em inglês da obra Learning PHP Design Patterns ISBN 9781449344917
© 2013 William B. Sanders. Esta tradução é publicada e vendida com a permissão da O'Reilly Media, Inc., detentora de
todos os direitos para publicação e venda desta obra.
© Novatec Editora Ltda. 2013.
Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra, mesmo
parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora.
Editor: Rubens Prates
Tradução: Lúcia A. Kinoshita
Revisão gramatical: Naomi Yokoyama Edelbuttel
Editoração eletrônica: Carolina Kuwabata

ISBN: 978-85-7522-343-7
Histórico de impressões:
Maio/2013 Primeira edição
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110
02460-000 – São Paulo, SP – Brasil
Tel.: +55 11 2959-6529
Fax: +55 11 2950-8869
E-mail: novatec@novatec.com.br
Site: www.novatec.com.br
Twitter: twitter.com/novateceditora
Facebook: facebook.com/novatec
LinkedIn: linkedin.com/in/novatec
VC20130517
 Sumário

Prefácio........................................................................................................................................13

Parte I ■ Familiarizando-se com os fundamentos dos padrões de projeto.......... 20

Capítulo 1 ■ PHP e programação orientada a objetos......................................................................23
Introdução à programação intermediária e avançada........................................... 23
Por que programação orientada a objetos?.......................................................... 24
Facilitando a resolução de problemas............................................................. 24
Modularização............................................................................................. 25
Classes e objetos................................................................................................ 26
Princípio da responsabilidade única.............................................................. 26
Funções construtoras em PHP....................................................................... 28
O Client como uma classe solicitante.................................................................. 28
E a velocidade?................................................................................................... 32
Velocidade de desenvolvimento e de alterações............................................... 32
Velocidade das equipes................................................................................. 33
O que há de errado com programação sequencial e procedural?........................... 33
Programação sequencial................................................................................ 34
Programação procedural............................................................................... 34
Pague agora ou pague depois......................................................................... 35

Capítulo 2 ■ Conceitos básicos de POO............................................................................................37

Abstração.......................................................................................................... 37
Classes abstratas........................................................................................... 39
Propriedades e métodos abstratos..................................................................40
Interfaces...................................................................................................... 42
Interfaces e constantes...................................................................................44
Indução de tipos: quase tipagem de dados..................................................... 45
Encapsulamento................................................................................................48
Encapsulamento no dia a dia........................................................................48
Protegendo o encapsulamento por meio da visibilidade.................................. 49
Getters e setters............................................................................................ 52
Herança............................................................................................................. 54

7
8 Aprendendo padrões de projeto em PHP

Polimorfismo..................................................................................................... 56
Um nome e várias implementações................................................................ 58
Polimorfismo embutido em padrões de projeto.............................................. 59
Vá com calma....................................................................................................60

Capítulo 3 ■ Conceitos básicos de padrões de projeto......................................................................61

MVC reduz o acoplamento e muda o foco da programação..................................61
Princípios básicos dos padrões de projeto............................................................ 63
Primeiro princípio dos padrões de projeto.....................................................64
Usando tipos de dados de interface em indução de tipos................................66
Classes abstratas e suas interfaces.................................................................. 67
Segundo princípio dos padrões de projeto...................................................... 70
Composição básica usando um cliente........................................................... 70
Delegação: a diferença entre IS-A (É) e HAS-A (TEM).................................... 74
Padrões de projeto como uma grande “cola”........................................................ 75
Organização dos padrões de projeto.............................................................. 75
Selecionando um padrão de projeto.................................................................... 76
O que provoca revisão em projetos?...............................................................77
O que varia?.................................................................................................77
Qual é a diferença entre padrões de projeto e frameworks?.............................. 78

Capítulo 4 ■ Usando UMLs com padrões de projeto.........................................................................80

Por que Unified Modeling Language (UML)?......................................................80
Diagramas de classes...........................................................................................81
Símbolos para os participantes........................................................................... 83
Notações sobre relacionamentos......................................................................... 85
Relações de associação.................................................................................. 85
Relação de agregação.................................................................................... 87
Relações de herança e de implementação....................................................... 89
Relação de criação.........................................................................................91
Relações múltiplas........................................................................................ 92
Diagrama de objetos.......................................................................................... 93
Diagramas de interação...................................................................................... 94
A função dos diagramas e das notações na programação orientada a objetos........ 95
Ferramentas para UMLs.....................................................................................96
Outras UMLs.................................................................................................... 97

Parte II ■ Padrões de projeto de criação........................................................... 98

Capítulo 5 ■ Padrão de projeto Factory Method............................................................................100
O que é o padrão Factory Method?................................................................... 100
Quando usar o Factory Method......................................................................... 101
Exemplo minimalista........................................................................................102
Sumário 9

Tarefa da factory..........................................................................................102
O cliente..................................................................................................... 105
Acomodando alterações em classes................................................................... 106
Acrescentando elementos gráficos............................................................... 106
Coordenando produtos............................................................................... 108
Alterando o produto do tipo texto............................................................... 109
Alterando o produto do tipo imagem.............................................................111
Acrescentando novos produtos e solicitações com parâmetro..........................111
Uma factory e vários produtos...................................................................... 112
As novas factories........................................................................................ 113
Os novos produtos....................................................................................... 114
O Client com parâmetros............................................................................. 116
Classes auxiliares......................................................................................... 117
Diagrama de arquivos.................................................................................. 119
Alterações em produtos: deixe a interface em paz! ........................................ 119

Capítulo 6 ■ Padrão de projeto Prototype.....................................................................................122

O que é o padrão de projeto Prototype?.............................................................122
Quando usar o padrão Prototype.......................................................................123
Função para clonagem.......................................................................................124
O construtor não é executado novamente na clonagem..................................126
A função construtora não deve realizar nenhuma tarefa importante...............127
Exemplo minimalista de Prototype....................................................................127
Estudando as drosófilas...............................................................................128
Acrescentando POO ao Prototype......................................................................132
Organização moderna dos negócios..............................................................132
Encapsulamento na interface........................................................................133
Implementações da interface........................................................................134
O cliente na organização............................................................................. 138
Fazendo alterações, adicionando recursos......................................................140
Instanciação dinâmica de objetos................................................................. 141
Prototype nos domínios do PHP........................................................................143

Parte III ■ Padrões de projeto estruturais....................................................... 145

Capítulo 7 ■ Padrão Adapter........................................................................................................147
O que é o padrão Adapter?................................................................................147
Quando usar o padrão Adapter..........................................................................148
O padrão Adapter com herança........................................................................ 150
Exemplo mínimo de uma classe Adapter: câmbio de moeda.......................... 151
O padrão Adapter com composição...................................................................155
De desktops a celulares............................................................................... 156
Os Adapters e as alterações.......................................................................... 165
10 Aprendendo padrões de projeto em PHP

Capítulo 8 ■ Padrão de projeto Decorator.....................................................................................166

O que é o padrão Decorator?............................................................................ 166
Quando usar o padrão Decorator..................................................................... 168
Decorator minimalista..................................................................................... 168
Interface Component...................................................................................169
Interface Decorator......................................................................................169
Componente concreto.................................................................................. 171
Decoradores concretos................................................................................. 171
O cliente......................................................................................................173
O que dizer dos encapsuladores?.......................................................................175
Primitivos em encapsuladores......................................................................175
Encapsuladores embutidos no PHP..............................................................175
Encapsuladores em padrões de projeto..........................................................176
Decorators com vários componentes..................................................................177
Vários componentes concretos......................................................................178
Decoradores concretos com vários estados e valores......................................178
Serviço de encontros para desenvolvedores....................................................178
Interface de usuário (UI) em HTML..................................................................185
Classe cliente passando dados HTML.......................................................... 190
Atribua um nome de variável a uma instância de objeto................................ 191
Acrescentando uma decoração......................................................................192

Parte IV ■ Padrões de projeto comportamentais............................................ 193

Capítulo 9 ■ Padrão Template Method..........................................................................................195
O que é o padrão Template Method?..................................................................195
Quando usar o Template Method...................................................................... 196
Usando o Template Method com imagens e legendas: um exemplo mínimo........197
A classe abstrata..........................................................................................197
A classe concreta..........................................................................................198
O cliente.......................................................................................................... 199
Princípio de Hollywood................................................................................... 200
Usando o Template Method com outros padrões de projeto............................... 202
Carga de trabalho reduzida do cliente.......................................................... 203
Participantes do Template Method............................................................... 204
Participantes do Factory Method...................................................................... 205
O gancho no padrão de projeto Template Method............................................. 207
Preparando o gancho...................................................................................210
Implementando o gancho............................................................................ 211
O cliente e o ajuste no gancho......................................................................212
O pequeno e poderoso Template Method........................................................... 214
Sumário 11

Capítulo 10 ■ Padrão de projeto State..........................................................................................215

O que é o padrão State?.....................................................................................215
Quando usar o padrão State?.............................................................................216
Máquina de estados..........................................................................................218
Lâmpada acesa, lâmpada apagada: o padrão de projeto State mínimo.................219
O contexto manda.......................................................................................219
Os estados.................................................................................................. 222
A solicitação do cliente por intermédio de Context....................................... 224
Adicionando estados........................................................................................ 225
Alterando a interface................................................................................... 226
Alterando os estados................................................................................... 226
Atualizando a classe Context....................................................................... 229
Um Client atualizado................................................................................... 231
O navegador: mais opções e células....................................................................232
Definindo um diagrama de estados para matriz........................................... 233
Definindo a interface.................................................................................. 234
O Context.................................................................................................. 234
Os estados.................................................................................................. 236
O cliente escolhe um caminho..................................................................... 242
O padrão State e o PHP.................................................................................... 245

Parte V ■ MySQL e padrões de projeto em PHP............................................... 246

Capítulo 11 ■ Uma classe universal para conexões e um padrão Proxy para segurança...................248
Uma interface e uma classe simples para MySQL............................................... 248
A interface frutífera..................................................................................... 249
Classe universal para conexão MySQL e variáveis estáticas........................... 250
Cliente fácil................................................................................................. 251
Proxy de proteção para login.............................................................................252
Criando o cadastramento de dados para login............................................. 254
Implementando o Proxy de login................................................................. 258
O Proxy e a segurança no mundo real............................................................... 264

Capítulo 12 ■ A flexibilidade do padrão de projeto Strategy..........................................................267

Algoritmos de encapsulamento......................................................................... 267
Diferenciando o padrão de projeto Strategy do padrão State......................... 268
Sem instruções condicionais, por favor......................................................... 269
Uma família de algoritmos.......................................................................... 270
Um padrão Strategy minimalista...................................................................... 270
O Client e os scripts de acionamento........................................................... 272
A classe Context e a interface Strategy.......................................................... 276
As estratégias concretas............................................................................... 277
12 Aprendendo padrões de projeto em PHP

Padrão Strategy expandido com dados seguros e algoritmos parametrizados...... 280

Uma classe auxiliar para dados seguros........................................................281
Acrescentando um parâmetro em um método de algoritmo.......................... 283
Tabela para pesquisa................................................................................... 284
Módulos para entrada de dados.................................................................. 285
O cliente pede ajuda....................................................................................291
A alteração pequena, porém significativa, na classe Context.......................... 293
As estratégias concretas............................................................................... 294
Padrão Strategy flexível..................................................................................... 300

Capítulo 13 ■ Padrão de projeto Chain of Responsibility................................................................302

Passando a responsabilidade............................................................................ 302
Chain of Responsibility em um Help Desk usando MySQL............................... 304
Criando e carregando a tabela de respostas.................................................. 304
Chain of Responsibility no Help Desk..........................................................310
Chain of Responsibility automatizado e o Factory Method.................................315
O Chain of Responsibility e as solicitações determinadas por datas...............316
O Factory Method finaliza a tarefa............................................................... 322
Facilidade para atualização............................................................................... 327

Capítulo 14 ■ Implementando um CMS para múltiplos dispositivos usando o padrão Observer.......328

Interfaces prontas para o Observer.................................................................... 328
Quando usar o padrão Observer?..................................................................... 330
Usando SPL com o padrão Observer.................................................................. 331
SplSubject................................................................................................... 331
SplObserver.................................................................................................332
SplObjectStorage.........................................................................................332
O sujeito concreto com a SPL...................................................................... 333
O observador concreto com a SPL................................................................ 334
O cliente com a SPL.....................................................................................335
PHP sem amarras e o padrão Observer............................................................. 336
A classe abstrata Subject e a implementação de ConcreteSubject ...................337
Observer e os vários observadores concretos................................................ 338
O cliente..................................................................................................... 340
Criando um CMS simples................................................................................ 342
Utilitários do CMS..................................................................................... 342
O observador para múltiplos dispositivos.................................................... 348
Pensando nos moldes da POO...........................................................................361