SOLID

Programista PHP, Magento Developer
Aurora Creation sp. z o.o.
Łukasz Paliwoda
luk.paliwoda@gmail.com
l.paliwoda@auroracreation.com

“On the one hand, if the bricks aren’t well made, the architecture of the building
doesn’t matter much. On the other hand, you can make a substantial mess with
well-made bricks.”
Robert C. Martin

SOLID
SOLID is a acronym for five design principles intended to make software
designs more understandable, flexible and maintainable.
● Zebrane przez Robert C. Martin
● Nazwane przez Michael Feathers w 2004

S R P
O C P
L S P
I S P
D I P
Single Responsibility Principle
Open/Closed Principle
Liskov Substitution Principle
Interface Segregation Principle
Dependency Inversion Principle

SOLID
Single Responsibility Principle
“A class should only have a single responsibility, that is, only changes to one
part of the software's specification should be able to affect the specification of
the class.”

SOLID
class Menu
{
public function getMenu()
{
$url = 'http://example.com/menu.xml';
$string = $this->download($url);
$response = $this->parse($string);
return $response;
}
private function parse($string) { /* some logic */ }
private function download($url) { /* some logic */ }
private function log($message) { /* some logic */ }
}
$menuDownloader = new Menu();
$menu = $menu->getMenu();

SOLID
class Menu
{
private $menuParser;
private $contentProvider;
public function __construct(
XmlParser $menuParser,
HttpClient $contentProvider
) {
$this->menuParser = $menuParser;
$this->contentProvider = $contentProvider;
}
public function getMenu()
{
$rawContent = $this->contentProvider->getRawContent();
$parsedMenu = $this->parser->parse($rawContent);
return $parsedMenu;
}
}
$parser = new XmlParser();
$httpClient = new HttpClient();
$menu = new Menu($parser, $httpClient);
try {
$menu = $menu->getMenu();
} catch (Exception $e) {
echo $e->getMessage();
}

SOLID
Open/Closed Principle
"Software entities ... should be open for extension, but closed for
modification."

SOLID
class Publisher
{
public function display($type)
{
switch($type) {
case 'screen':
/* some logic */
break;
case 'rss':
/* some logic */
break;
}
}
}
$publsher = new Publisher();
$publsher->display('screen');
$publsher->display('rss');

SOLID
interface PublisherInterface
{
public function getContent();
}
class Publisher
{
public function display(PublisherInterface $publisher)
{
$publisher->getContent();
}
}
class ScreenPublisher implements PublisherInterface
{
public function getContent() { /* some logic */ }
}
class RssPublisher implements PublisherInterface
{
}

SOLID
$publsher = new Publisher();
$screenPublisher = new ScreenPublisher();
$publsher->display($screenPublisher);
$rssPublisher = new RssPublisher();
$publsher->display($rssPublisher);
class PrintPublisher implements PublisherInterface
{
}
$printPublisher = new PrintPublisher();
$publsher->display($printPublisher);

SOLID
Liskov Substitution Principle
"Objects in a program should be replaceable with instances of their subtypes
without altering the correctness of that program."

SOLID
class Ptak
{
public function lec() { /* some logic */ }
}
class Golab extends Ptak
{
}
class Strus extends Ptak
{
public function lec()
{
throw new Exception('Not Implemented');
}
}
class Ptak
{
}
class LatajacyPtak extends Ptak
{
public function lec() { /* some logic */ }
}
public class Golab extends LatajacyPtak
{
}
public class Strus extends Ptak
{
}

SOLID
interface Jednoslad
{
public function jedz();
}
class Rower implements Jednoslad
{
public function jedz();
}
$notebook = new Rower();
$notebook->jedz();
class Motor implements Jednoslad
{
public function wlacz()
{
/* some logic */
}
public function jedz()
{
/* some logic */
}
}
$tablet = new Motor();
$tablet->jedz();
// throw new Exception("You need to start the engine")

SOLID
Interface Segregation Principle
"Many client-specific interfaces are better than one general-purpose
interface."

SOLID
interface FormatterInterface
{
public function toPDF($content);
public function toXML($content);
public function toJSON($content);
}
class Formatter implements FormatterInterface
{
public function toPDF($content)
{
throw new Exception('Not Implemented');
}
public function toXML($content)
{
/* some logic */
}
public function toJSON($content)
{
/* some logic */
}
}

SOLID
interface PdfFormatterInterface
{
public function toPDF($content);
}
interface XmlFormatterInterface
{
public function toXML($content);
}
interface JsonFormatterInterface
{
public function toJSON($content);
}
class Formatter implements JsonFormatterInterface, XmlFormatterInterface
{
public function toJSON($content)
{
/* some logic */
}
public function toXML($content)
{
/* some logic */
}
}

SOLID
Dependency Inversion Principle
“Entities must depend on abstractions not on concretions.”

SOLID
class MysqlConnection
{
public function connect()
{
/* some logic */
}
}
class PasswordReminder
{
private $connection;
public function __construct(MysqlConnection $connection)
{
$this->connection = $connection;
}
}

SOLID
interface DbConnectionInterface
{
public function connect();
}
class MysqlConnection implements DbConnectionInterface
{
public function connect()
{
/* some logic */
}
}
class PasswordReminder
{
private $connection;
public function __construct(DbConnectionInterface $connection)
{
$this->connection = $connection;
}
}

Podsumowanie
● klasa powinna mieć jeden i tylko jeden powód do zmiany
● pozwól na zmianę zachowania systemu poprzez dodawanie nowego kodu,
a nie modyfikowanie istniejącego
● buduj elementy tak aby były wzajemnie wymienne
● unikaj tworzenia zależności od elementów których nie potrzebujesz
● uniezależnij od siebie kod implementujący poszczególne warstwy

SOLID

More Related Content

What's hot (20)

Similar to SOLID (20)

More from PHPstokPHPstok (14)

Recently uploaded (20)

SOLID

Editor's Notes