SOLID in Practice

SOLID In Practice
@jessicamauerhan | https://joind.in/talk/17a66 | @OpenWest

@jessicamauerhan
Senior Software Engineer
TDD/BDD Expert
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');
}
}

{
{
[...]
}
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;
}
}

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

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

{
{
}
$user = new User();
}
//Persist User
$this->saveUser($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 <a>click 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
}
private function sendConfirmationEmail(string $email) {
}
private function saveUser(User $user) {
}
private function emailIsRegistered(string $email): bool {
$rows = DB::query("SELECT count(id) FROM users WHERE (email='{$email}')");
return $rows > 0;
}
}

{
public function register(Request $request): Response {
}
$user = new User();
}
//Persist User
}
private function sendConfirmationEmail(string $email) {
}
private function saveUser(User $user) {
}
private function emailIsRegistered(string $email): bool {
$numRows = DB::query("SELECT count(id) FROM users WHERE (email='{$email}')");
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

{
private $db;
public function __construct(Database $db)
{
$this->db = $db;
}
{
[...]
}
{
$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);
}

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());
}
}
}
{
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);
}
}
}
{
private $factory, $validator, $repository, $emailer;
public function __construct(UserFactory $factory, UserValidator $validator,
UserRepository $repository, ConfirmationEmailer $emailer)
{
$this->repository = $repository;
$this->emailer = $emailer;
}
{
try {
}
}
try {
$this->repository->create($user);
$this->emailer->sendConfirmationEmail($user);
return UserCreatedResponse($user);
} catch (UnableToCreateUser $exception) {
return UnableToCreateUserResponse($user);
} catch (MailerException $mailerException) {
return UnableToSendConfirmationEmailResponse($user);
}
}
}
interface UserFactory
{
/**
* @throws UnableToParseUser
*/
public function createRegisteringUser(Request $request): User;
}
interface UserValidator
{
public function isValid(User $user): bool;
public function getInvalidProperties(User $user):array;
}
interface UserRepository
{
/**
* @throws UnableToCreateUser
*/
public function create(User $user): bool;
}
interface ConfirmationEmailer
{
/**
* @throws MailerException
*/
public function send(string $to);
}

interface UserFactory
{
/**
*/
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);
}
}

interface UserValidator
{
public function isValid(User $user): bool;
public function getInvalidProperties(User $user):array;
}
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;
}
}

interface UserRepository
{
/**
* @param User $user
* @return bool
*
* @throws UnableToCreateUser
*/
public function create(User $user): 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();
}
}
}

{
/**
* @throws MailerException
*/
public function send(string $to);
}
class MandrillConfirmationEmailer implements ConfirmationEmailer
{
private $mandrill;
public function __construct(Mandrill $mandrill)
{
$this->mandrill = $mandrill;
}
public function send(User $user)
{
$message = "Please <a>click 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;
}
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;
}
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;
}
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());
}
}

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

Interface Notifier
{
public function notify(ContactInfo $contact);
}

Interface Notifier
{
}
Class EmailNotifier implements Notifier
{
private $mailer;
{
}
public function notify(ContactInfo $contact)
{
$email = new OverdueEmail($contact->getEmailAddress());
}
}
Class TextNotifier implements Notifier
{
private $texter;
public function __construct(Texter $texter)
{
}
{
$text = 'Your Account Is Overdue!';
$this->texter->send($text, $contact->getPhoneNumber());
}
}

Interface Notifier
{
}
Class NotifierFactory
{
private $notifiers;
public function register($name, Notifier $notifier)
{
$this->notifiers[$name] = $notifier;
}
public function getNotifier(string $name): Notifier
{
return $this->notifiers[$name];
}
}
Class EmailNotifier implements Notifier
{
private $mailer;
{
}
{
$email = new OverdueEmail($contact->getEmailAddress());
}
}
Class TextNotifier implements Notifier
{
private $texter;
public function __construct(Texter $texter)
{
}
{
$text = 'Your Account Is Overdue!';
$this->texter->send($text, $contact->getPhoneNumber());
}
}

{
private $notifierFactory;
public function __construct(NotifierFactory $notifierFactory)
{
$this->notifierFactory = $notifierFactory;
}
{
$contact = $account->getContactInfo();
$notifications = $account->getEnabledNotifications();
foreach ($notifications AS $notificationType) {
$notifier = $this->notifierFactory->getNotifier($notificationType);
$notifier->send($contact);
}
}
}

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): float
{
return ($this->discount / 100) * $item->getCost();
}
}

{
private $discount;
{
}
public function calculateAmountOff(Item $item)
{
}
}
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;
{
}
{
}
}
{
private $type;
{
}
{
}
throw new NotEnoughItems();
}
{
$found = 0;
$found++;
}
return true;
}
}
return false;
}
}

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

Interface Discount
{
/** @throws DiscountException */
public function calculateAmountOff(Item $item): float;
}
Class PercentageDiscount implements Discount
{
private $discount;
{
}
{
}
}
Class BuyEligibleItemsToGetDiscount extends PercentageDiscount
{
public function calculateAmountOff(Item $item): float { [...] }
}

Interface Item
{
public function getName(): string;
public function getPrice(): float;
public function getShippingWeight(): float;
public function getShippingCost(): float;
}
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 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 Buyable
{
}
Interface Product
{
}
Interface Service
{
public function getWorkerAssigned(): Worker;
public function assignWorker(Worker $worker);
public function getServiceScheduledDate(): DateTime;
public function getServiceCompletedDate(): DateTime;
public function isCompleted(): bool;
}
class Cart
{
private $products;
public function addItem(Product $product){
$this->products[] = $product;
}
public function calculateTotal(){
$total = 0;
foreach ($this->products AS $p) {
$total += $p->getPrice() + $p->getShippingCost();
}
return $total;
}
}
Class ServiceManager
{
private $services;
public function addService(Service $service){
$this->services[] = $service;
}
public function getCompletedServices(){
$completed = [];
foreach ($this->services AS $service){
if ($service->isCompleted()) {
$completed[] = $service;
}
}
return $completed;
}
}
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;
}
}
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
Feedback & Questions?
Welcome & Encouraged!
@jessicamauerhan
jessicamauerhan@gmail.com
jmauerhan.wordpress.com

SOLID in Practice

More Related Content

Recently uploaded

Featured

SOLID in Practice