Make it SOLID!

MMaakkee iitt
SSOOLLIIDD!!
LLuuííss OOttáávviioo CCoobbuuccccii OObblloonncczzyykk
@@llccoobbuuccccii

LLuuííss OOttáávviioo
CCoobbuuccccii OObblloonncczzyykk
@@llccoobbuuccccii

PPrriinnccííppiiooss
ee vvaalloorreess

“Working software is the primary
measure of progress.”
ee vvaalloorreess

“Welcome changing requirements,
even late in development.”
ee vvaalloorreess

“Continuous attention to technical excellence
and good design enhances agility.”
ee vvaalloorreess

NNoossssaass
rreessppoonnssaabbiilliiddaaddeess??

NNoossssaass
Traduzir desejos

NNoossssaass
Traduzir desejos
Escolher linguagem

Traduzir desejos
Escolher linguagem Libs/frameworks
NNoossssaass

Libs/frameworks
NNoossssaass
Traduzir desejos
Escolher linguagem
Definir arquitetura

Garantir qualidade
Libs/frameworks
NNoossssaass
Traduzir desejos
Escolher linguagem
Definir arquitetura

CCooiissaass qquuee nnuunnccaa
ooccoorrrreemm...... nnéé??

Precisamos criar um
Usuário com nome e idade

class UserCreator
{
public function create($name, $age) { /*... */ }
}

public function __construct() {
$this->conn = new PDO(
'mysql:host=127.0.0.1;dbname=awesome',
'root',
'ImAGenius'
);
}

public function create($name, $age) {
$stm = $this->conn->prepare('...');
$stm->execute([$name, $age]);
}

Agora, temos que logar no
arquivo /tmp/users.log, adicionando
o responsável pelo cadastro

class UserCreator
{
public function create($name, $age, $responsible) { /*... */ }
}

public function __construct() {
// (…)
$this->logger = new FileLogger();
}

public function create($name, $age, $responsible) {
$stm = $this->conn->prepare('...');
$stm->execute([$name, $age]);
$this->logger->log(/* … */);
}

Meu, num dá pra imprimir
o último usuário criado?

class UserCreator
{
public function create($name, $age, $responsible) { /*... */ }
public function print() { /* … */ }
}

RReessuullttaaddoo
Será que “APENAS
funcionar” é suficiente?

RReessuullttaaddoo
((rreeaall))

BBaadd ssmmeellllss
Rigidez
Fragilidade

BBaadd ssmmeellllss
Rigidez
Fragilidade
Imobilidade

BBaadd ssmmeellllss
Rigidez
Fragilidade
Imobilidade
Complexidade
desnecessária

PPrriinncciipplleess ooff OOOODD

Class design

Class design
Package cohesion

Class design
Package cohesion
Package coupling

Class design
Package cohesion
Package coupling
SS..OO..LL..II..DD..

SS..OO..LL..II..DD.. pprriinncciipplleess
Single Responsibility principle
Open/Closed principle
Liskov substitution principle
Interface segregation principle
Dependency inversion principle

SSiinnggllee RReessppoonnssiibbiilliittyy
One does not simply
have more than a reason
to modify a class...

A class should have one,
and only one, reason
to change.

class UserRepository
{}

{
public function findByAge($age) { /* … */ }
public function findByName($name) { /* … */ }
}

{
public function pdfReport() { /* … */ }
}

{
}
class UserReport
{
public function generate() { /* … */ }
}

OOppeenn//cclloosseedd
Should be able to extend
behaviors, without modifying
the class

class Authenticator
{}

class Authenticator
{
public function authenticate($login, $passwd) { /* … */ }
}

class Authenticator
{
private function findUser($login) { /* finds on DB */ }
private function matchPasswd(User $user, $passwd) { /* … */ }
}

class Authenticator
{
private function findUser($login) { /* finds on DB */ }
}
E se precisarmos buscar
em outro lugar?

class Authenticator
{
protected function findUser($login) { /* finds on DB */ }
}
Assim podemos sobrescrever
o método de busca...

LLiisskkoovv ssuubbssttiittuuttiioonn
Derived classes must be
substitutable for their base
classes

class Rectangle
{
public function setX($x) { /* … */ }
public function setY($y) { /* … */ }
public function getArea() { /* … */ }
}

function getArea($x, $y, Rectangle $object)
{
$object->setX($x);
$object->setY($y);
return $object->getArea();
}
getArea(5, 10, new Rectangle());

class Square extends Rectangle
{
public function setX($x) { /* also setY() */ }
public function setY($y) { /* also setX() */ }
}

function getArea($x, $y, Rectangle $object)
{
$object->setX($x);
$object->setY($y);
return $object->getArea();
}
getArea(5, 10, new Square());

Contravariance of method arguments in subtypes
Covariance of return types in subtypes

Preconditions cannot be strengthened in subtypes
Postconditions cannot be weakened in subtypes

Preconditions cannot be strengthened in subtypes
Postconditions cannot be weakened in subtypes
No new exceptions! Don't violate history constraint

IInntteerrffaaccee sseeggrreeggaattiioonn
Make fine grained interfaces
that are client specific

interface UserManager
{}

{
public function create($name, $email);
public function remove($id);
public function find($id);
public function findByName($name);
}

class UserController
{
public function find($id) { /* … */ }
/** @return UserManager */
public function getManager();
}

{
public function create($name, $email);
public function remove($id);
}
interface UserLocator
{
public function find($id);
public function findByName($name);
}

DDeeppeennddeennccyy IInnvveerrssiioonn
Depend on abstractions,
not on concretions

public function __construct(
DatabasePersister $persister,
FileNotifier $notifier
) {
$this->persister = $persister;
$this->notifier = $notifier;
}

public function __construct(Persister $persister, Notifier $notifier)
{
$this->persister = $persister;
$this->notifier = $notifier;
}

SSOOLLIIDD pprriinncciipplleess

Classes mais coesas

Classes mais coesas
Menos acoplamento

Classes mais coesas
Menos acoplamento
Menos mudanças
em código estável

Classes mais coesas
Menos acoplamento
Menos mudanças
em código estável
Testes mais fáceis

OObbrriiggaaddoo!!
@@llccoobbuuccccii

Make it SOLID!

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Make it SOLID!

Similar to Make it SOLID! (20)

Recently uploaded

Recently uploaded (20)

Make it SOLID!