SOLID PRINCIPLES

SOLID PRINCIPLES
LUCIANO QUEIROZ

SOLID
PRINCIPLES
Robert Martin aka Uncle Bob

SINGLE RESPONSIBILITY PRINCIPLE
“A CLASS SHOULD HAVE ONE,  
AND ONLY ONE, REASON TO
CHANGE.”
SOLID PRINCIPLES

<?php
class ConfirmationMailMailer
{
private $templating;
private $mailer;
public function __construct(
ITemplatingEngine $templating,
IMailer $mailer
) {
$this->templating = $templating;
$this->mailer = $mailer;
}
public function sendTo(User $user)
{
$message = $this->createMessageFor($user);
$this->sendMessage($message);
}
private function createMessageFor(User $user)
{
$subject = 'Confirm your email address';
$body = $this->templating
->render(
'confirmationMail.html.tpl', [
'confirmationCode' => $user->getConfirmationCode()
]
);
$message = new Message($subject, $body);
$message->setTo($user->getEmailAdress());
return $message;
}
private function sendMessage(IMessage $message)
{
$this->mailer->send($message);
}

SOLID PRINCIPLES
INITIAL SITUATION
ConfirmationMailMailer.php
IMailer.php
usesuses
ITemplatingEngine.php

SOLID PRINCIPLES
RESPONSIBILITIES
▸ Create Conﬁrmation Message
▸ Send Conﬁrmation Message to user

SINGLE RESPONSIBILITY PRINCIPLE
“RESPONSIBILITIES ARE
REASONS TO CHANGE”
SOLID PRINCIPLES

SOLID PRINCIPLES
SINGLE RESPONSIBILITY PRINCIPLE VIOLATIONS
▸ Many instance variables
▸ Many public methods
▸ Each method use variables from other instance
▸ Speciﬁc tasks are done by private methods

<?php
class ConfirmationMailFactory
{
private $templating;
public function __construct(ITemplatingEngine $templating)
{
$this->templating = $templating;
}
public function createMessageFor(User $user)
{
$subject = 'Confirm your email address';
$body = $this->templating
->render(
'confirmationMail.html.tpl', [
'confirmationCode' => $user->getConfirmationCode()
]
);
$message = new Message($subject, $body);
$message->setTo($user->getEmailAdress());
return $message;
}
}

<?php
class ConfirmationMailMailer
{
private $confirmationMailFactory;
private $mailer;
ConfirmationMailFactory $confirmationMailFactory,
IMailer $mailer
) {
$this->confirmationMailFactory = $confirmationMailFactory;
$this->mailer = $mailer;
}
public function sendTo(User $user)
{
$message = $this->confirmationMailFactory->createMessageFor($user);
$this->sendMessage($message);
}
private function sendMessage(IMessage $message)
{
$this->mailer->send($message);
}
}

SOLID PRINCIPLES
REFACTORED
ConfirmationMailMailer.php IMailer.phpuses
ConfirmationMailFactory.php
uses
ITemplatingEngine.phpuses

SOLID PRINCIPLES
SINGLE RESPONSIBILITY PRINCIPLE ADVANTAGES
▸ Smaller classes
▸ Classes easier to understand
▸ Classes easier to test
▸ Classes simpler to maintain

OPEN/CLOSED PRINCIPLE
“YOU SHOULD BE ABLE TO
EXTEND A CLASS`S BEHAVIOR,
WITHOUT MODIFYING IT.”
SOLID PRINCIPLES

<?php
class GenericEncoder
{
public function encodeToFormat($data, $format)
{
if ($format === 'json') {
$encoder = new JsonEncoder();
} elseif ($format === 'xml') {
$encoder = new XmlEncoder();
} else {
throw new InvalidArgumentException('Unknown format');
}
$data = $this->prepareData($data, $format);
return $encoder->encode($data);
}
private function prepareData($data, $format)
{
switch ($format) {
case 'json':
$data = $this->forceArrayKeys($data);
$data = $this->fixKeys($data);
break;
case 'xml':
$data = $this->fixAttributes($data);
break;
default:
throw new InvalidArgumentException(
'Format not supported'
);
}
return $data;
}
}

SOLID PRINCIPLES
INITIAL SITUATION
GenericEncoder.php
XmlEncoder.php
uses
uses
JsonEncoder.php

<?php
{
{
if (…) {
…
} elseif (…) {
…
} elseif ($format === 'yaml') {
$encoder = new YamlEncoder();
} else {
}
}
…
}

SOLID PRINCIPLES
NEW REQUIREMENT SITUATION
GenericEncoder.php
XmlEncoder.php
uses
uses
JsonEncoder.php
YamlEncoder.php
uses

OPEN/CLOSED PRINCIPLE
“A UNIT OF CODE CAN BE
CONSIDERED ‘OPEN’ FOR EXTENSION
WHEN ITS BEHAVIOR CAN BE EASILY
CHANGED WITHOUT MODIFYING IT”
SOLID PRINCIPLES

SOLID PRINCIPLES
OPEN/CLOSED PRINCIPLE VIOLATIONS
▸ Conditions to determine a strategy
▸ Conditions using the same variables or constants are
recurring inside the class or related classes
▸ Contains hard-coded references to other classes or class
names
▸ Objects are being created using the new operator

<?php
interface EncoderInterface
{
public function encode($data);
}
class JsonEncoder implements EncoderInterface
{
public function encode($data)
{
// TODO: Implement encode() method.
}
}
class XmlEncoder implements EncoderInterface
{
{
}
}
class YamlEncoder implements EncoderInterface
{
{
}
}

SOLID PRINCIPLES
INTRODUCING ENCODER INTERFACE
GenericEncoder.php
XmlEncoder.php
uses
JsonEncoder.phpYamlEncoder.php
implements
EncoderInterface.php
implements
implements

<?php
class EncoderFactory
{
public function createForFormat($format)
{
if ($format === 'json') {
return new JsonEncoder();
} elseif ($format === 'xml') {
return new XmlEncoder();
} elseif ($format === 'yaml') {
return new YamlEncoder();
}
}
}

<?php
{
private $encoderFactory;
public function __construct(EncoderFactory $encoderFactory)
{
$this->encoderFactory = $encoderFactory;
}
{
$encoder = $this->encoderFactory->createForFormat($format);
$data = $this->prepareData($data, $format);
}
}

ABSTRACT FACTORY
OPEN FOR EXTENSION

<?php
interface EncoderFactoryInterface
{
/**
* Create an encoder for the given format
*
* @param string $format
* @return EncoderInterface
*/
}
class EncoderFactory implements EncoderFactoryInterface
{
...
}
{
EncoderFactoryInterface $encoderFactory
) {
...
}
...
}

INTRODUCING DEPENDENCY INVERSION PRINCIPLE
SOLID PRINCIPLES
GenericEncoder.php
XmlEncoder.php
uses
JsonEncoder.phpYamlEncoder.php
implements
EncoderInterface.php
implements
implements
EncoderFactoryInterface.php
uses
creates

<?php
class EncoderFactory implements EncoderFactoryInterface
{
private $factories = [];
/**
* Register a callable that returns an instance of
* EncoderInterface for the given format.
*
* @param string $format
* @param callable $factory
*/
public function addEncoderFactory($format, callable $factory)
{
$this->factories[$format] = $factory;
}
{
$factory = $this->factories[$format];
$encoder = $factory;
return $encoder;
}
}

<?php
$encoderFactory = new EncoderFactory();
$encoderFactory->addEncoderFactory(
'xml',
function () {
return new XmlEncoder();
}
);
$encoderFactory->addEncoderFactory(
'json',
function () {
return new JsonEncoder();
}
);
$genericEncoder = new GenericEncoder($encoderFactory);
$data = ...
$jsonEncodedData = $genericEncoder->encode($data, 'json');

<?php
{
private function prepareData($data, $format)
{
switch ($format) {
case 'json':
$data = $this->forceArray($data);
break;
case 'xml':
$data = $this->fixAttributes($data);
break
default:
# code...
break;
}
return $data;
}
}

<?php
{
) {
$this->encoderFactory;
}
{
$data = $encoder->prepareData($data);
}
}

<?php
{
{
...
}
public function prepareData($data)
{
return $data;
}
}

<?php
{
{
$data = $this->prepareData($data);
return json_encode($data);
}
private function prepareData($data)
{
return $data;
}
}

<?php
interface EncoderInterface
{
public function encode($data);
}

<?php
{
) {
$this->encoderFactory;
}
{
}
}

LISKOV SUBSTITUTION PRINCIPLE
“DERIVED CLASSES MUST
BE SUBSTITUTABLE FOR
THEIR BASE CLASSES”
SOLID PRINCIPLES

SOLID PRINCIPLES
WE NEED TO UNDERSTAND
▸ Derived classes
▸ Being substitutable

<?php
/**
* A concrete class, all methods are implemented, but can be
* overridden by derived classes
*/
class ConcreteClass
{
public function implementedMethod()
{
}
}
/**
* An abstract class, some methods need to be implemented by
* by derived classes
*/
abstract class AbstractClass
{
abstract public function abstractMethod();
public function implementedMethod()
{
}
}
/**
* An interface, all methods need to be implemented by derived
* classes
*/
interface AnInterface
{
public function abstractMethod();
}

“A DERIVED CLASS DOES NOT
HAVE AN IMPLEMENTATION
FOR ALL METHODS”
SOLID PRINCIPLES

<?php
interface FileInterface
{
public function rename($name);
public function changeOwner($user, $group);
}

<?php
class DropboxFile implements FileInterface
{
public function rename($name)
{
...
}
public function changeOwner($user, $group)
{
throw new BadMethodCallException(
"Not implemented for Dropbox files"
);
}
}

<?php
{
{
...
}
{
throw new BadMethodCallException(
"Not implemented for Dropbox files"
);
}
}
//ask the user to check if $file is an instance of DropboxFile
if (!($file instanceof DropboxFile)) {
$file->changeOwner(...);
}

<?php
{
...
{
//let's do nothing :)
}
}

INTERFACE SEGREGATION PRINCIPLE
“MAKE FINE-GRAINED
INTERFACES THAT ARE
CLIENT SPECIFIC”
SOLID PRINCIPLES

<?php
interface FileInterface
{
public function rename($name);
}
interface FileWithOwnerInterface extends FileInterface
{
public function changeOwner($user, $group);
}

<?php
{
{
...
}
}
class LocalFile implements FileWithOwnerInterface
{
{
...
}
{
...
}
}

SOLID PRINCIPLES
NEW HIERARCHY OF FILE CLASSES
DropboxFile.php
extends
LocalFile.php
implements
FileInterface.php
implements
FileWithOwnerInterface.php

“DIFFERENT SUBSTITUTES
RETURN THINGS OF
DIFFERENT TYPES”
SOLID PRINCIPLES

<?php
interface RouterInterface
{
public function getRoutes() : RouterCollection;
}
class SimpleRouter implements RouterInterface
{
public function getRoutes()
{
$routes = [];
//add Route objects to $routes
$routes[] = ...;
return $routes
}
}
class AdvancedRouter implements RouterInterface
{
public function getRoutes()
{
$routeCollection = new RouteCollection();
...
return $routeCollection;
}
}

<?php
interface RouterInterface
{
public function getRoutes() : RouterCollection;
}
class SimpleRouter implements RouterInterface
{
public function getRoutes() : RouteCollection
{
$routes = [];
//add Route objects to $routes2
$routes[] = ...;
return $routes
}
}
class AdvancedRouter implements RouterInterface
{
public function getRoutes() : RouteCollection
{
$routeCollection = new RouteCollection();
...
return $routeCollection;
}
}

“A DERIVED CLASS IS LESS
PERMISSIVE WITH REGARD
TO METHOD ARGUMENTS”
SOLID PRINCIPLES

<?php
interface MassMailerInterface
{
public function sendMail(
TransportInterface $transport,
MessageInterface $message,
RecipientsInterface $recipients
);
}

<?php
class SmtpMassMailer implements MassMailerInterface
{
TransportInterface $transport,
) {
if (!($transport instanceof SmtpTransport)) {
throw new InvalidArgumentException(
'SmtpMassMailer only works with SMTP'
);
}
}
}

“NOT EVERY KIND OF MAIL
TRANSPORT IS SUITABLE
FOR MASS MAILING”
SOLID PRINCIPLES

SOLID PRINCIPLES
NEW CLASS DIAGRAM
SmtpTransport.php
TransportInterface.php
extends
TransportWithMassMailSupportInterface.php
implements

<?php
interface MassMailerInterface
{
TransportWithMassMailSupportInterface $transport,
);
}

<?php
class SmtpMassMailer implements MassMailerInterface
{
TransportWithMassMailSupportInterface $transport,
) {
…
}
}

SOLID PRINCIPLES
A GOOD SUBSTITUTE
▸ Provides an implementation for all the methods of the
base class.
▸ Returns the type of things the base class prescribes.
▸ Doesn’t put extra constraints on arguments for methods.

DEPENDENCY INVERSION PRINCIPLE
“DEPEND ON ABSTRACTIONS,
NOT CONCRETIONS”
SOLID PRINCIPLES

SOLID PRINCIPLES
FIZZ BUZZ ASSIGNMENT
▸ Generate a list of integers, from 1 to n.
▸ Numbers that are divisible by 3 should be replace with
“Fizz”
▸ Numbers that are divisible by 5 should be replaced with
“Buzz”
▸ Numbers that are both divisible by 3 and by 5 should be
replaced with “FizzBuzz”

<?php
class FizzBuzz
{
public static function generateList($limit)
{
$list = [];
for ($number = 1; $number <= $limit; $number++) {
$list[] = self::generateElement($number);
}
return $list;
}
private static function generateElement($number)
{
if ($number % 3 === 0 && $number % 5 === 0) {
return 'FizzBuzz';
}
if ($number % 3 === 0) {
return 'Fizz';
}
if ($number % 5 === 0) {
return 'Buzz';
}
return $number;
}
}

SOLID PRINCIPLES
THEN…
▸ It should be possible to add another rule, without
modifying the FizzBuzz class.

MAKING FIZZBUZZ
OPEN FOR EXTENSION

<?php
class FizzBuzz
{
{
...
}
{
$fizzBuzzRule = new FizzBuzzRule();
if ($fizzBuzzRule->matches($number)) {
return $fizzBuzzRule->getReplacement();
}
$fizzRule = new FizzRule();
if ($fizzRule->matches($number)) {
return $fizzRule->getReplacement();
}
$buzzRule = new BuzzRule();
if ($buzzRule->matches($number)) {
return $buzzRule->getReplacement();
}
return $number;
}
}

<?php
interface RuleInterface
{
public function matches($number);
public function getReplacement();
}

<?php
class FizzBuzz
{
private $rules = [];
public function addRule(RuleInterface $rule) {
$this->rules[] = $rule;
}
{
...
}
{
foreach ($this->rules as $rule) {
if ($rule->matches($number)) {
return $rule->getReplacement();
}
}
return $number;
}
}

<?php
class FizzBuzzRule implements RuleInterface
{
...
}
class FizzRule implements RuleInterface
{
...
}
class BuzzRule implements RuleInterface
{
...
}

<?php
$fizzBuzz = new FizzBuzz();
$fizzBuzz->addRule(new FizzBuzzRule());
$fizzBuzz->addRule(new FizzRule());
$fizzBuzz->addRule(new BuzzRule());
...
$list = $fizzBuzz->generateList(100);

SOLID PRINCIPLES
HAVING CONCRETE DEPENDENCIES
FizzBuzz.php
FizzRule.php
BuzzRule.php
FizzBuzzRule.php

SOLID PRINCIPLES
HAVING ABSTRACT DEPENDENCIES
FizzBuzz.php RuleInterface.php
BuzzRule.phpFizzBuzzRule.php FizzRule.php

DEPENDENCY INVERSION PRINCIPLE VIOLATION
“MIXING DIFFERENT
LEVELS OF ABSTRACTION”
SOLID PRINCIPLES

<?php
use DoctrineDBALConnection;
class Authentication
{
private $connection;
public function __construct(Connection $connection)
{
$this->connection = $connection;
}
public function checkCredentials($username, $password)
{
$user = $this->connection->fetchAssoc(
'SELECT * FROM users WHERE username = ?',
[$username]
);
if ($user === null) {
throw new InvalidCredentialsException(
"User not found."
);
}
//validate password
...
}
}

SOLID PRINCIPLES
AUTHENTICATION CLASS DEPENDS ON CONNECTION
Authentication.php Connection.php

<?php
{
private $userRepository;
public function __construct(UserRepository $userRepository)
{
$this->userRepository = $userRepository;
}
public function checkCredentials($username, $password)
{
$user = $this->userRepository->ofUsername($username);
if ($user === null) {
throw new InvalidCredentialsException(
"User not found."
);
}
//validate password
...
}
}

<?php
class UserRepository
{
private $connection;
public function __construct(Connection $connection)
{
$this->connection = $connection;
}
public function ofUsername($username)
{
return $this->connection->fetchAssoc(
'SELECT * FROM users WHERE username = ?',
[$username]
);
}
}

SOLID PRINCIPLES
AUTHENTICATION CLASS DEPENDS ON USER REPOSITORY
Authentication.php UserRepository.php Connection.php

<?php
interface UserRepositoryInterface
{
public function ofUsername($username);
}

<?php
class DoctrineDbalUserRepository implements UserRepositoryInterface
{
...
}
class TextFileUserRepository implements UserRepositoryInterface
{
...
}
class InMemoryUserRepository implements UserRepositoryInterface
{
...
}
class MongoDbUserRepository implements UserRepositoryInterface
{
...
}

<?php
{
private $userRepository;
public function __construct(UserRepositoryInterface $userRepository)
{
$this->userRepository = $userRepository;
}
}

SOLID PRINCIPLES
AUTHENTICATION CLASS DEPENDS ON USER REPOSITORY INTERFACE
Authentication.php UserRepositoryInterface.php
TextFileUserRepository.php DoctrineDbalUserRepository.php Connection.php

SOLID PRINCIPLES

More Related Content

What's hot

Viewers also liked

Similar to SOLID PRINCIPLES

Recently uploaded

SOLID PRINCIPLES