SOLID code in practice - creating good object oriented PHP application @ WDI 2018

>>>Pytania?
Zadawaj je, oceniaj prelekcję, komentuj
lub polub poprzez sli.do:
WarszawskieDniInformatyki.pl/slido

SOLID code in practice
creating good object-oriented
PHP applications
/prgTW /prgTW /prgTW
Senior developer, 9+ years of experience
Tomasz Wójcik

WRITING SOLID CODE IN PRACTICE
SRP - Single Responsibility Principle
OCP - Open/Closed Principle
LSP - Liskov Substitution Principle
ISP - Interface Segregation Principle
DIP - Dependency Inversion Principle
What SOLID stands for

Single Responsibility Principle

• class/module should have only single responsibility
• the above is deﬁned as single reason for change

<?php 
 
class RandomGithubEmoji 
{ 
public function fetch(): string 
{ 
$cacheFile = __DIR__ . '/random_emoji'; 
 
if (is_file($cacheFile) && time() - filemtime($cacheFile) <= 3) 
{ 
return file_get_contents($cacheFile); 
} 
 
$response = file_get_contents('https://api.github.com/emojis'); 
if (!$response) 
{ 
return 'https://assets-cdn.github.com/images/icons/emoji/trollface.png?v6'; 
} 
 
$emojis = json_decode($response, true); 
$randomEmoji = array_rand($emojis); 
 
file_put_contents($cacheFile, $randomEmoji); 
 
return $randomEmoji; 
} 
} 

<?php 
 
{ 
{ 
 
{ 
} 
 
if (!$response) 
{ 
} 
 
 
 
} 
} 
 
 
 
 
 
 
 
{ 
} 
 
 
 
 
 
 
 
 
 
 
file_put_contents($cacheFile, $randomEmoji);
cache control

<?php 
 
{ 
{ 
 
{ 
} 
 
if (!$response) 
{ 
} 
 
 
 
} 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
fetching data

<?php 
 
{ 
{ 
 
{ 
} 
 
if (!$response) 
{ 
} 
 
 
 
} 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
if (!$response) 
{ 
} error handling

<?php 
 
{ 
{ 
 
{ 
} 
 
if (!$response) 
{ 
} 
 
 
 
} 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
$emojis = json_decode($response, true);
data transformation

<?php 
 
{ 
{ 
 
{ 
} 
 
if (!$response) 
{ 
} 
 
 
 
} 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
$randomEmoji = array_rand($emojis);
 
 
 
return $randomEmoji;
random emoji logic

class FileCache
class FileGetContentsFetcher
throw new Exception
class JsonSerializer
class RandomGithubEmoji
• cache control
• fetching data
• error handling
• data transformation
• random emoji logic
custom one

<?php 
 
{ 
{ 
 
 
 
 
 
 
 
if (!$response) 
{ 
} 
 
 
 
 
} 
} 
 
 
 
 
 
 
 
{ 
} 
 
 
 
 
 
 
 
 
 
 
file_put_contents($cacheFile, $randomEmoji);
cache control

<?php 
 
{ 
{ 
 
 
 
 
 
 
 
if (!$response) 
{ 
} 
 
 
 
 
} 
} 
cache control
 
 
 
 
 
 
$cache = new FileCache(__DIR__ . '/random_emoji'); 
 
$randomEmoji = $cache->fetch(); 
if (null !== $randomEmoji) 
{ 
} 
 
 
 
 
 
 
 
 
 
$cache->put($randomEmoji);

<?php 
 
{ 
{ 
 
{ 
} 
 
 
if (!$response) 
{ 
} 
 
 
 
} 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
fetching data

<?php 
 
{ 
{ 
 
{ 
} 
 
 
if (!$response) 
{ 
} 
 
 
 
} 
} 
fetching data
 
 
 
 
 
 
 
 
 
 
 
 
 
$response = (new FileGetContentsFetcher)->fetch('https://api.github.com/emojis');

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
error handling
<?php 
 
{ 
{ 
 
{ 
} 
 
if (!$response) 
{ 
 
} 
 
 
 
} 
}

error handling
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
throw new UnableToFetchEmojiException;
<?php 
 
{ 
{ 
 
{ 
} 
 
if (!$response) 
{ 
 
} 
 
 
 
} 
}

<?php 
 
{ 
{ 
 
{ 
} 
 
if (!$response) 
{ 
} 
 
 
 
 
} 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
$emojis = json_decode($response, true);
data transformation

<?php 
 
{ 
{ 
 
{ 
} 
 
if (!$response) 
{ 
} 
 
 
 
 
} 
} 
data transformation
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
$emojis = (new JsonSerializer)->deserialize($response, 'json');

<?php 
 
{ 
{ 
{ 
} 
 
$response = (new FileGetContentsFetcher)->fetch('https://api.github.com/emojis'); 
if (!$response) 
{ 
throw new UnableToFetchEmojiException; 
} 
 
$emojis = (new JsonSerializer)->deserialize($response, 'json'); 
 
$cache->put($randomEmoji); 
 
} 
}

<?php 
 
{ 
{ 
{ 
} 
 
$response = (new FileGetContentsFetcher)->fetch('https://api.github.com/emojis'); 
if (!$response) 
{ 
throw new UnableToFetchEmojiException; 
} 
 
$emojis = (new JsonSerializer)->deserialize($response, 'json'); 
 
$cache->put($randomEmoji); 
 
} 
}
 
 
 
 
 
 
new FileCache(__DIR__ . '/random_emoji'); 
 
 
 
 
 
 
new FileGetContentsFetcher 
 
 
 
 
 
new JsonSerializer
We still have concrete dependencies

Dependency Injection
not a part of SOLID but closely related

• providing dependencies from outside of the dependent class
• class mustn’t use new or static methods

<?php 
 
{
/** @var FileCache */ 
private $cache; 
 
/** @var FileGetContentsFetcher */ 
private $fetcher; 
 
/** @var JsonSerializer */ 
private $serializer; 
 
public function __construct(FileCache $cache, FileGetContentsFetcher $fetcher, JsonSerializer $serializer)
{ 
$this->cache = $cache; 
$this->fetcher = $fetcher; 
$this->serializer = $serializer; 
}
 
// …
}

Dependency Inversion Principle

• used to decouple software modules
• high-level modules shouldn’t depend on low-level modules, they both should
depend on abstractions
• variables must be created via injection or creational patterns (eg. factories)
• class members should be interfaces or abstracts
• class shouldn’t derive from concretions (composition over inheritance)
• methods shouldn’t derive from already implemented methods

https://en.wikipedia.org/wiki/Dependency_inversion_principle

<?php 
 
{
/** @var CacheInterface */ 
private $cache; 
 
/** @var FetcherInterface */ 
 
/** @var SerializerInterface */ 
 
public function __construct(Cache Interface $cache , FetcherInterface $fetcher, SerializerInterface $serializer)
{ 
$this->cache = $cache; 
}
 
// ...
}

<?php 
 
{
/** @var Cache Interface */ 
private $cache ; 
 
/** @var FetcherInterface */ 
 
/** @var SerializerInterface */ 
 
public function __construct(Cache Interface $cache , FetcherInterface $fetcher, SerializerInterface $serializer)
{ 
$this->cache = $cache  
}
 
// ...
}
 
 
 
 
 
 
 
 
 
 
 
 
CacheFactoryInterface $cacheFactory
 
$this->cache = $cacheFactory->createCache(__DIR__ . '/random_emoji');

PSR-11 - Container interface
orchestrating how frameworks and libraries obtain objects and parameters
• https://packagist.org/packages/symfony/dependency-injection
• https://packagist.org/packages/pimple/pimple
• https://packagist.org/packages/league/container
• https://packagist.org/packages/php-di/php-di

Open/Closed Principle

• class should be open for extension
• class behaviour can be changed in derived classes
• protected instead of private methods
• class should be closed for modiﬁcation
• there should be no reason to change class code
• interfaces
• think of dependencies coming from 3rd party vendors

<?php 
 
interface RandomEmojiInterface 
{ 
}

<?php 
 
 
 
 
 
class Emoji 
{ 
/** @var string */ 
private $url; 
 
public function __construct(string $url) 
{ 
$this->url = $url; 
} 
 
public function getUrl(): string 
{ 
return $this->url; 
} 
} 
 
{ 
public function fetch(): Emoji 
}

 
 
 
 
 
 
 
 
/** @var string */ 
private $url; 
 
public function __construct(string $url) 
{ 
$this->url = $url; 
} 
 
public function getUrl(): string 
{ 
return $this->url; 
} 
 
 
 
 
 
<?php 
interface EmojiInterface 
{ 
public function getUrl(): string; 
} 
 
class Emoji implements EmojiInterface 
{ 
 
 
 
 
 
 
 
 
 
 
} 
 
{ 
public function fetch(): EmojiInterface; 
}

Interface Segregation Principle

• many speciﬁc interfaces are better than one generic
• client shouldn’t be aware and forced to depend on methods it doesn’t use
• helps keeping parts of the system decoupled

<?php 
 
interface CacheInterface 
{ 
public function get($key); 
 
public function put($something); 
 
} 
 
class FileCache implements CacheInterface 
{ 
// get, put 
}

<?php 
 
{ 
 
 
public function getMany(array $keys); 
 
public function putMany(array $items); 
} 
 
{ 
// get, put 
// getMany, putMany 
}

<?php 
 
{ 
 
 
 
 
public function invalidate($key); 
 
public function invalidateMany(array $keys); 
 
public function invalidataAll(); 
} 
 
{ 
// get, put 
// getMany, putMany
// invalidate, invalidateMany, invalidateAll 
}

<?php 
 
{ 
 
 
 
 
public function invalidate($key); 
 
public function invalidateMany(array $keys); 
 
public function invalidataAll(); 
 
public function gc(); 
 
public function countAll(); 
} 
 
{ 
// :( 
}

Liskov Substitution Principle
(Barbara Liskov)

https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)

• objects of type T can be replaced by any subtype S of type T without altering
desired properties of the program/module (eg. correctness)
• signature requirements
• covariance of return types, contravariance of method arguments
• no new exceptions being non-derived from exceptions thrown in super type
• behavioral conditions
• preconditions cannot be strengthen in subtype
• postconditions cannot be weakened in subtype

<?php 
 
interface T 
{ 
} 
 
interface S extends T 
{ 
} 
 
 
// --------------------------- 
 
 
interface A 
{ 
public function do(T $t); 
} 
 
interface B extends A 
{ 
} 
<?php 
 
interface T 
{ 
} 
 
{ 
}
invariance of method argument

<?php 
 
interface T 
{ 
} 
 
{ 
}
 
 
// --------------------------- 
 
 
interface A 
{ 
} 
 
interface B extends A 
{ 
public function do(S $s); 
} 
covariance of method argument is not allowed
• violating A::do signature
• violating “preconditions cannot be strengthen in subtype”

<?php 
 
interface T 
{ 
} 
 
{ 
} 
// ---------------------------
 
class A 
{ 
public function do(): S
{
} 
} 
 
class B extends A 
{ 
public function do(): T
{
} 
} 
contravariance of return type is not allowed
• violating A::do signature
• violating “postconditions cannot be weakened in subtype”

Summary

Before

After

Benefits of writing SOLID code

Benefits
• code is well organised and more declarative
• code is easy to read and understand (short learning curve)
• code is loosely coupled and thus reusable
• code is easy to adapt
• code is easy to extend
• code is easy to refactor
• code is easy to unit test
• code is easy to replace/mock in functional tests

Thanks for attention
Questions?

SOLID code in practice - creating good object oriented PHP application @ WDI 2018

More Related Content

What's hot

Similar to SOLID code in practice - creating good object oriented PHP application @ WDI 2018

Recently uploaded

SOLID code in practice - creating good object oriented PHP application @ WDI 2018