The document discusses the SOLID principles of object-oriented design: - The Single Responsibility Principle states that a class should have one single responsibility. - The Open/Closed Principle states that software entities should be open for extension but closed for modification. - The Liskov Substitution Principle states that objects should be replaceable with their subtypes without altering correctness. - The Interface Segregation Principle states that many specific client interfaces are better than one general interface. - The Dependency Inversion Principle states that high-level modules shouldn't depend on low-level modules but both should depend on abstractions.

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

2. S O L I D

3. “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

4. 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

5. 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

6. S O L I D

7. 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.”

8. SOLID

9. 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();

10. 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();
}

11. S O L I D

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

13. SOLID

14. 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');

15. 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
{
public function getContent() { /* some logic */ }
}

16. SOLID
$publsher = new Publisher();
$screenPublisher = new ScreenPublisher();
$publsher->display($screenPublisher);
$rssPublisher = new RssPublisher();
$publsher->display($rssPublisher);
class PrintPublisher implements PublisherInterface
{
public function getContent() { /* some logic */ }
}
$printPublisher = new PrintPublisher();
$publsher->display($printPublisher);

17. S O L I D

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

19. SOLID

20. 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
{
}

21. 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")

22. S O L I D

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

24. SOLID

25. 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 */
}
}

26. 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 */
}
}

27. S O L I D

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

29. SOLID

30. SOLID

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

32. 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;
}
}

33. 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

34. DZIĘKUJĘ