SOLID in Practice

SOLID In Practice
@jessicamauerhan | http://bit.ly/solid-oop

@jessicamauerhan
Software Engineer
@HelpScout
jessicamauerhan@gmail.com
jmauerhan.wordpress.com

What is SOLID?
● Five principles for Object
Oriented Programming
● Guidelines which can help
ensure system is easy to
maintain
● Primarily focused on
communication between
dependencies or
collaborators

Let ϕ(픁) be a property provable
about objects 픁 of type T.
Then ϕ(퐲) should be true for
objects 퐲 of type S where S is a
subtype of T

Class Rectangle
{
protected $length;
protected $height;
public function area()
{
return $this-length * $this-area();
}
public function setLength($length)
{
$this-length = $length;
}
public function setHeight($height)
{
$this-height = $height;
}
}
Class Square extends Rectangle
{
public function setLength($length)
{
$this-length = $length;
$this-height = $length;
}
public function setHeight($height)
{
$this-length = $height;
$this-height = $height;
}
}

S.O.L.I.D.
● Single Responsibility
● Open/Closed
● Liskov Substitution
● Interface Segregation
● Dependency Inversion

User Registration
● Collect User Input
● Validate User Input
● Persist User Data
● Send Confirmation Email

Class UserRegistration
{
public function register(Request $request): Response
{
//Collect user input
if (!$request-has('email') || !$request-has('password')) {
return new Response('register', ['error' = 'Please provide an email and a password']);
}
$user = new User();
$user-email = $request-get('email');
$user-password = $request-get('password');
}
}

{
{
}
$user = new User();
}
private function emailIsRegistered(string $email): bool
{
$dsn = 'host='.$_ENV['DB_HOST'].' dbname='.$_ENV['DB_DB'].' password='.$_ENV['DB_PASS'].' user='.$_ENV['DB_USER'];
$db = pg_connect($dsn);
$result = pg_query($db, SELECT id FROM users WHERE (email='{$email}'));
$rows = pg_num_rows($result);
return $rows 0;
}
}

{
{
}
$user = new User();
//Validate user input
if ($this-emailIsRegistered($user-getEmail())) {
return new Response('register', ['error' = 'Your email address is already registered']);
}
}
{
return $rows 0;
}
}

{
{
}
$user = new User();
}
//Persist User
$this-saveUser($user);
}
private function emailIsRegistered(string $email): bool { [...] }
private function saveUser(User $user)
{
pg_query($db, INSERT INTO users(email, password) VALUES('{$user-email}', '{$user-password}'));
}
}

{
{
[...]
}
{
return $rows 0;
}
{
pg_query($db, INSERT INTO users(email, password) VALUES('{$user-email}', '{$user-password}'));
}
}

{
{
[...]
}
{
$rows = DB::query(SELECT count(id) FROM users WHERE (email='{$email}'));
return $rows 0;
}
{
DB::query(INSERT INTO users(email, password) VALUES('{$user-email}', '{$user-password}'));
}
}

{
{
}
$user = new User();
}
//Persist User
//Send Confirmation Email
$this-sendConfirmationEmail($user-getEmail());
return new Response('register', ['success' = 'You are registered! Please check your email!']);
}
private function sendConfirmationEmail(string $email)
{
$subject = Confirm Email;
$message = Please aclick here/a to confirm your email!;
$headers = From: mysite@email.com;
mail($email, $subject, $message, $headers);
}

{
public function register(Request $request): Response {
}
$user = new User();
}
//Persist User
//Send Confirmation Email
$this-sendConfirmationEmail($user-getEmail());
return new Response('register', ['success' = 'You are registered! Please check your email!']);
}
private function sendConfirmationEmail(string $email) {
$subject = Confirm Email;
$message = Please aclick here/a to confirm your email!;
$headers = From: mysite@email.com;
mail($email, $subject, $message, $headers);
}
private function saveUser(User $user) {
DB::query(INSERT INTO users(email, password) VALUES('{$user-email}', '{$user-password}'));
}
private function emailIsRegistered(string $email): bool {
return $rows 0;
}
}

Dependency Injection
● Collaborators are supplied to
class from outside - aka
injected into it
Service Location
● Collaborators are retrieved or
instantiated from inside the
class using them

{
public function register(Request $request): Response { [...] }
private function sendConfirmationEmail(string $email) { [...] }
{
$sql = INSERT INTO users(email, password) VALUES('{$user-email}', '{$user-password}')
DB::query($sql);
}
{
return $rows 0;
}
}

{
private $db;
public function __construct(Database $db)
{
$this-db = $db;
}
private function sendConfirmationEmail(string $email) { [...] }
{
$sql = INSERT INTO users(email, password) VALUES('{$user-email}', '{$user-password}')
$this-db-query($sql);
}
{
$rows = $this-db-query(SELECT count(id) FROM users WHERE (email='{$email}'));
return $rows 0;
}
}

{
private $db;
private $mailer;
public function __construct(Database $db, Mailer $mailer)
{
$this-db = $db;
$this-mailer = $mailer;
}
private function sendConfirmationEmail(string $email)
{
//Convert our email to Mandrill's email
$mandrillEmail = [
'to' = ['email' = $email-getTo()],
'from_email' = $email-getFrom(),
'subject' = $email-getSubject(),
'text' = $email-getMessage()
];
$this-mandrill-send($mandrillEmail);
}
private function saveUser(User $user) { [...] }
private function emailIsRegistered(string $email): bool { [...] }

Single Responsibility Principle

{
private $factory;
public function __construct(UserFactory $factory)
{
$this-factory = $factory;
}
{
try {
$user = $this-factory-createUser($request);
} catch (UnableToParseUser $exception) {
return new InvalidRequestResponse($exception-getErrors());
}
}
}
interface UserFactory
{
/**
* @throws UnableToParseUser
*/
public function createRegisteringUser(Request $request): User;
}

{
/**
*/
}
interface UserValidator
{
public function isValid(User $user): bool;
public function getInvalidProperties(User $user):array;
}
{
private $factory, $validator;
public function __construct(UserFactory $factory, UserValidator $validator)
{
$this-validator = $validator;
}
{
try {
}
if ($this-validator-isValid($user) === false) {
$invalidProperties = $this-validator
-getInvalidProperties($user);
return new InvalidUserResponse($invalidProperties);
}
}
}

{
private $factory, $validator, $repository;
public function __construct(UserFactory $factory, UserValidator $validator,
UserRepository $repository)
{
$this-repository = $repository;
}
{
try {
}
}
try {
$this-repository-create($user);
return UserCreatedResponse($user);
} catch (UnableToCreateUser $exception) {
return UnableToCreateUserResponse($user);
}
}
}
{
/**
*/
}
{
}
interface UserRepository
{
/**
* @throws UnableToCreateUser
*/
public function create(User $user): bool;
}
{
/**
*/
}
{
}

{
private $factory, $validator, $repository, $emailer;
UserRepository $repository, ConfirmationEmailer $emailer)
{
$this-emailer = $emailer;
}
{
try {
}
}
try {
$this-emailer-sendConfirmationEmail($user);
} catch (MailerException $mailerException) {
return UnableToSendConfirmationEmailResponse($user);
}
}
}
{
/**
*/
}
{
}
{
/**
*/
}
interface ConfirmationEmailer
{
/**
* @throws MailerException
*/
public function send(string $to);
}
{
/**
*/
}
{
}
{
/**
*/
}
{
/**
*/
}
{
}

{
private $factory;
public function __construct(UserFactory $factory)
{
}
{
try {
}
}
}
{
private $factory, $validator;
public function __construct(UserFactory $factory, UserValidator $validator)
{
}
{
try {
}
}
}
}
{
private $factory, $validator, $repository;
UserRepository $repository)
{
}
{
try {
}
}
try {
}
}
}
{
private $factory, $validator, $repository, $emailer;
UserRepository $repository, ConfirmationEmailer $emailer)
{
$this-emailer = $emailer;
}
{
try {
}
}
try {
$this-emailer-sendConfirmationEmail($user);
} catch (MailerException $mailerException) {
return UnableToSendConfirmationEmailResponse($user);
}
}
}
{
/**
*/
}
{
}
{
/**
*/
}
{
/**
*/
}

{
/**
*/
public function createUser(Request $request): User;
}

{
/**
*/
public function createUser(Request $request): User;
}
class RegisterFormUserFactory implements UserFactory
{
/**
*/
public function createUser(Request $request): User
{
if(!$request-has('email') || !$request-has('password')){
throw new UnableToParseUser();
}
$email = $request-get('email');
$password = $request-get('password');
return new User($email, $password);
}
}

{
}

{
}
class NewUserValidator implements UserValidator
{
/** @var UserRepository */
private $userRepository;
public function __construct(UserRepository $userRepository)
{
$this-userRepository = $userRepository;
}
public function isValid(User $user): bool
{
$emailExists = $this-userRepository-emailExists($user-getEmail());
if ($emailExists === true) {
return false;
}
return true;
}
}

{
/**
* @param User $user
* @return bool
*
*/
/**
* @param string $email
* @return bool
*
* @throws DataSourceError
*/
public function emailExists(string $email): bool;
}

class PdoUserRepository implements UserRepository
{
/** @var Pdo */
private $pdo;
public function __construct(Pdo $pdo) {
$this-pdo = $pdo;
}
public function create(User $user): bool {
try {
$statement = $this-pdo-prepare(INSERT INTO users(email, password) VALUES(:email, :password));
$statement-execute(['email' = $user-getEmail(), 'password' = $user-getPassword()]);
} catch (PDOException $PDOException) {
throw new UnableToCreateUser($user-getEmail());
}
return true;
}
public function emailExists(string $email): bool {
try {
$statement = $this-pdo-prepare(SELECT count(id) AS numRows FROM users WHERE email = :email);
$statement-execute([email = $email]);
$result = $statement-fetchColumn();
return ($result 0);
} catch (PDOException $PDOException) {
throw new DataSourceError();
}
}
}

{
/**
*/
}

{
/**
*/
}
class MandrillConfirmationEmailer implements ConfirmationEmailer
{
private $mandrill;
public function __construct(Mandrill $mandrill)
{
$this-mandrill = $mandrill;
}
public function send(User $user)
{
$message = Please aclick here/a to confirm your account.;
$from = app@example.com;
$subject = Confirm your account;
$email = [
'to' = [['EmailTemplate' = $user-getEmail()]],
'from_email' = $from,
'subject' = $subject,
'text' = $message
];
$this-mandrill-send($email);
}
}

{
public function send(string $to); /** @throws MailerException */
}

{
}
interface Mailer
{
public function send(Email $email);
}

{
}
interface Mailer
{
}
class Email
{
private $to, $from, $subject, $message;
public function __construct(string $to, string $from,
string $subject, string $message) {
$this-to = $to;
$this-from = $from;
$this-subject = $subject;
$this-message = $message;
}
public function getTo(): string {
return $this-to;
}
public function getFrom(): string {
return $this-from;
}
public function getSubject(): string {
return $this-subject;
}
public function getMessage(): string {
return $this-message;
}
}

{
}
interface Mailer
{
}
class Email
{
$this-to = $to;
$this-from = $from;
}
return $this-to;
}
return $this-from;
}
}
}
}
class ConfirmationEmailService implements ConfirmationEmailer
{
private $mailer;
private $from = 'mysite@example.com';
private $subject = 'Confirm Email';
private $message = 'Please click here to confirm your email';
public function __construct(Mailer $mailer) {
}
public function send(string $to) {
$email = new Email($to, $this-from,
$this-subject, $this-message);
$this-mailer-send($email);
}
}

{
}
interface Mailer
{
}
class Email
{
$this-to = $to;
$this-from = $from;
}
return $this-to;
}
return $this-from;
}
}
}
}
{
private $mailer;
}
}
}
class MandrillMailer implements Mailer
{
private $mandrill;
public function __construct(Mandrill $mandrill) {
$this-mandrill = $mandrill;
}
public function send(Email $email) {
//Convert our email to Mandrill's email
$mandrillMail = ['to' = ['email' = $email-getTo()],
'from_email' = $email-getFrom(),
'subject' = $email-getSubject(),
'text' = $email-getMessage()];
$this-mandrill-send($mandrillEmail);
}
}

{
}
interface Mailer
{
}
class Email
{
$this-to = $to;
$this-from = $from;
}
return $this-to;
}
return $this-from;
}
}
}
}
{
private $mailer;
}
}
}
class SendGridMailer implements Mailer
{
private $sendgrid;
public function __construct(SendGrid $sendgrid) {
$this-sedngrid = $sendgrid;
}
public function send(Email $email) {
//Convert our email to SendGrid's email
$sgEmail = new SendGridEmail($email-getTo(),
$email-getFrom(),
$email-getSubject(),
$email-getMessage());
$this-sendgrid-queue($sgEmail);
}
}

class AccountOverdueListener
{
private $mailer;
public function __construct(Mailer $mailer)
{
}
public function handle(OverdueEvent $event)
{
$account = $event-getAccount();
$email = new OverdueEmail($account-getEmailAddress(), $account-getAmountDue());
}
}

class AccountOverdueListener
{
private $mailer;
private $texter;
public function __construct(Mailer $mailer, Texter $texter)
{
$this-texter = $texter;
}
public function handle(OverdueEvent $event)
{
$notifications = $account-getEnabledNotifications();
foreach ($notifications AS $notificationType) {
if ($notificationType === 'email') {
} elseif ($notificationType === 'text') {
$text = new OverdueText($account-getPhoneNumber(), $account-getAmountDue());
$this-texter-send($text);
}
}
}
}

class AccountOverdueEmailListener
{
public function handle(Mailer $mailer, OverdueEvent $event)
{
$mailer-send($email);
}
}
class AccountOverdueTextListener
{
public function handle(Texter $texter, OverdueEvent $event)
{
$text = new OverdueText($account-getPhoneNumber(), $account-getAmountDue());
$texter-send($text);
}
}

Class PercentageDiscount
{
private $discount;
public function __construct(int $discount)
{
$this-discount = $discount;
}
public function calculateAmountOff(Item $item)
{
return ($this-discount / 100) * $item-getCost();
}
}

{
private $discount;
{
}
{
}
}
Class BuyItemsToGetDiscount extends PercentageDiscount
{
private $type;
private $countItemsRequired = 2;
public function setEligibleType(string $type)
{
$this-type = $type;
}
{
if ($this-hasEnoughItems() $item-isType($this-type)) {
}
return 'Error: Not enough items';
}
public function hasEnoughItems(array $items): bool
{
$found = 0;
foreach ($items AS $item) {
if ($item-isType($this-type)) {
$found++;
}
if ($found == $this-countItemsRequired) {
return true;
}
}
return false;
}
}

{
private $discount;
{
}
public function calculateAmountOff(Item $item): float
{
}
}
{
private $type;
public function setEligibleType(string $type)
{
$this-type = $type;
}
{
}
throw new NotEnoughItems();
}
{
$found = 0;
$found++;
}
return true;
}
}
return false;
}
}

{
private $discount;
{
}
{
}
}
{
private $type;
public function __construct($discount, $type)
{
$this-type = $type;
parent::__construct($discount);
}
{
}
return 0;
}
{
$found = 0;
$found++;
}
return true;
}
}
return false;
}

Interface Discount
{
/** @throws DiscountException */
public function calculateAmountOff(Item $item): float;
}
Class DiscountException extends Exception
{
}
Class PercentageDiscount implements Discount
{
private $discount;
{
}
{
}
}
{
private $type;
public function __construct($discount, $type)
{
$this-type = $type;
parent::__construct($discount);
}
{
}
throw new DiscountException ();
}
{
$found = 0;
$found++;
}
return true;
}
}
return false;
}

Interface Item
{
public function getName(): string;
public function getPrice(): float;
public function getShippingWeight(): float;
public function getShippingCost(): float;
}

Interface Item
{
}
class Cart
{
private $items;
private $total;
public function addItem(Item $item)
{
$this-items[] = $item;
}
public function calculateTotal()
{
$subtotal = 0;
$shippingTotal = 0;
foreach ($this-items AS $item) {
$subtotal += $item-getPrice();
$shippingTotal += $item-getShippingCost();
}
return $subtotal + $shippingTotal;
}
}

Interface Item
{
public function getWorkerAssigned(): Worker;
public function assignWorker(Worker $worker);
public function getServiceScheduledDate(): DateTime;
public function getServiceCompletedDate(): DateTime;
public function isCompleted(): bool;
}
Class Cart { [...] }
Class ServiceManager
{
private $services;
public function addService(Item $item)
{
$this-services[] = $item;
}
public function getCompletedServices()
{
$completed = [];
foreach ($this-services AS $service) {
if ($service-isCompleted()) {
$completed[] = $service;
}
}
return $completed;
}
}

Interface Item
{
}
Interface Buyable
{
}
Interface Product
{
}
Interface Service
{
}

Interface Buyable
{
}
Interface Product
{
}
Interface Service
{
}
Class BuyableItem implements Buyable
{
protected $name, $price;
public function __construct(string $name,
float $price)
{
$this-name = $name;
$this-price = $price;
}
public function getName(): string
{
return $this-name;
}
public function getPrice(): float
{
return $this-price;
}
}

Interface Buyable
{
}
Interface Product
{
}
Interface Service
{
}
Class BuyableItem implements Buyable { [...] }
Class BuyableProduct extends BuyableItem implements
Product
{
protected $shippingCost, $shippingWeight;
public function __construct(string $name,
float $price,
float $shippingCost,
float $shippingWeight)
{
$this-shippingCost = $shippingCost;
$this-shippingWeight = $shippingWeight;
parent::__construct($name, $price);
}
public function getShippingCost(): float {
return $this-getShippingCost();
}
public function getShippingWeight(): float {
return $this-shippingWeight;
}
}

S.O.L.I.D.
● Single Responsibility - Registration Class delegating to Collaborators
● Open/Closed - Adding new Notifiers without always editing Listener
● Liskov Substitution - Ensured Discount subtypes could be used as Discount
● Interface Segregation - Items use Buyable, Product and Service interfaces
● Dependency Inversion - Registration Controller, Emailer, Shopping Cart,
Notification Factory - all use interfaces, not implementations

SLD: Apply Often
Preemptively
● Single Responsibility
● Liskov Substitution
● Dependency Inversion
OI: Apply As Needed
When Changes Occur
● Open/Closed
● Interface Segregation

Thank You!
SOLID in Practice
http://bit.ly/solid-oop
Feedback Questions?
Welcome Encouraged!
@jessicamauerhan
jessicamauerhan@gmail.com
jmauerhan.wordpress.com

SOLID in Practice

More Related Content

What's hot

Similar to SOLID in Practice

More from Jessica Mauerhan

Recently uploaded

SOLID in Practice