└── README.md


/README.md:
--------------------------------------------------------------------------------
  1 | # PicPay Design Patterns em PHP 8
  2 | Repo do código exemplo da Talk Design Patterns em PHP 8 por Leonardo Tumadjian
  3 | 
  4 | Com carinho ao pessoal do PicPay 💚
  5 | 
  6 | Simples implementação:
  7 | 
  8 | ```php
  9 | // Implementação de persistencia genérica em banco:
 10 | 
 11 | // Usabilidade básica sem implementação
 12 | $dataMapper = new Persistence();
 13 | 
 14 | $obj1 = new StdClass();
 15 | $obj2 = new StdClass();
 16 | 
 17 | $dataMapper->persist($obj1);
 18 | $dataMapper->delete($obj2);
 19 | 
 20 | $dataMapper->flush();
 21 | ```
 22 | 
 23 | Implementação com Design Patterns (Client):
 24 | 
 25 | ```php
 26 | // Usabilidade com Design Patterns
 27 | // FactoryMethod > Proxy > TemplateMethod(interface) > Strategy > Decorator
 28 | 
 29 | // 1. Escolhemos a decoração via $config['persistenceClass']
 30 | // 2. Usamos o factory para criar a instância Proxy
 31 | // 3. Proxy recebe PersistenceStrategy com sua classe de tipo de persistencia
 32 | $dataMapper = PersistenceFactory::create($config['persistenceClass']);
 33 | 
 34 | $obj1 = new StdClass();
 35 | $obj2 = new StdClass();
 36 | 
 37 | // 4. O método invocado depende da escolha da decoração
 38 | // em $config
 39 | // ex: "MongoDB"
 40 | $dataMapper->persist($obj1);
 41 | $dataMapper->delete($obj2);
 42 | 
 43 | $dataMapper->flush();
 44 | ```
 45 | 
 46 | Interface PersistenceTemplate (pode-se usar interface segregation)
 47 | ```php
 48 | interface PersistenceTemplate
 49 | {
 50 |     public function persist(object $object): void;
 51 |     public function delete(object $object): void;
 52 |     public function flush(): bool;
 53 | }
 54 | ```
 55 | 
 56 | Strategy implementado
 57 | ```php
 58 | // Implementação da classe Strategy
 59 | class PersistenceStrategy implements PersistenceTemplate
 60 | {
 61 |     // property promotion PHP 8
 62 |     // Strategy define objetos do tipo PersistenceTemplate
 63 |     // Decorado por composição
 64 |     public function __construct(
 65 |         protected PersistenceTemplate $persistence
 66 |     ) {}
 67 | 
 68 |     public function persist(object $object): void
 69 |     {
 70 |         $this->persistence->persist($object);
 71 |     }
 72 | 
 73 |     public function delete(object $object): void
 74 |     {
 75 |         $this->persistence->delete($object);
 76 |     }
 77 | 
 78 |     public function flush(): bool
 79 |     {
 80 |         return $this->persistence->flush();
 81 |     }
 82 | }
 83 | ```
 84 | 
 85 | Implementação de persistencia em MongoDB(classe exclusiva) pode ter segregação de interfaces (ex: PersistenceTemplate, FilterTemplate)
 86 | ```php
 87 | // Implementação da classe Strategy
 88 | class MongoDB implements PersistenceTemplate
 89 | {    
 90 |     public function persist(object $object): void
 91 |     {
 92 |         // implementação de persistencia e update Mongo
 93 |     }
 94 | 
 95 |     public function delete(object $object): void
 96 |     {
 97 |         // implementação de delete Mongo
 98 |     }
 99 | 
100 |     public function flush(): bool
101 |     {
102 |         return true;
103 |     }
104 | }
105 | ```
106 | 
107 | Criando o Factory Method que instancia o objeto Proxy de PersistenceStrategy
108 | obs: o Proxy é opcional
109 | ```php
110 | // Factory Method pode ser trocado por 
111 | // Dependency Injection Container em Controller ou UseCase
112 | class PersistenceFactory
113 | {
114 |     public static function create(string $class)
115 |     {
116 |         if (false === class_exists($class)) {
117 |             throw new \Exception('Class do not exist');
118 |         }
119 |         // Trabalhando com o Proxy implementado, melhor aplicado em Dependency Injection Container
120 |         return new PersistenceProxy(new PersistenceStrategy(new $class));
121 |     }
122 | }
123 | ```
124 | Implementação do Proxy Cache como exemplo, o mesmo poderia segmentar
125 | Cache X ElasticSearch
126 | ```php
127 | // Persistence Proxy
128 | // Uma classe para receber o strategy e adicionar mais
129 | // lógica ao Strategy de forma global a todos objetos
130 | class PersistenceProxy implements PersistenceTemplate
131 | {
132 |     // Proxy para lógica pré e post executions
133 |     public function __construct(
134 |         protected PersistenceStrategy $persistenceStrategy
135 |     ) {}
136 | 
137 |     public function persist(object $object): void
138 |     {
139 |         // Crie lógica aqui antes de persistir
140 |         // ...
141 |         $this->persistenceStrategy->persist($object);
142 |         // Lógica depois: renova o cache
143 |         // ...
144 |     }
145 | 
146 |     public function delete(object $object): void
147 |     {
148 |         $this->persistenceStrategy->delete($object);
149 |         // remove elemento do cache / renova cache
150 |     }
151 | 
152 |     public function flush(): bool
153 |     {
154 |         return $this->persistenceStrategy->flush();
155 |     }
156 | }
157 | ```
158 | 


--------------------------------------------------------------------------------