Dependency inversion, injection and the containers

In this talk, I'll talk about the dependency inversion principle, dependency injection and DI containers, using real-life examples for each of the concepts to understand the difference between them, how they align together and the benefits of applying it to your code.

This talk was given at the SydPHP May 2019 Meetup.

Transcript

1. Dependency inversion, injection and the containers
2. Luã de Souza Lead Software Engineer @ THE ICONIC
3. Why should I care? - Helps decoupling your code - Promotes a clean and readable codebase - Your code becomes more reusable - Makes testing easier - Improves the logical abstraction of components
4. Dependency Injection
5. <?php class CaptureCommand { public function execute(OutputInterface $output) { $fetcher = new StatsFetcher(); $summary = $fetcher->fetch(); $output->writeln($summary->getResult()); } } Sample class
6. Separate the creation of the dependencies from your class' behaviour
7. Constructor injection Types of injection
8. class CaptureCommand { private $fetcher; public function __construct(StatsFetcher $fetcher) { $this->fetcher = $fetcher; } public function execute(OutputInterface $output) { $summary = $this->fetcher->fetch(); // ... } } Constructor injection
9. Setter injection Types of injection
10. class CaptureCommand { private $logger; public function setLogger(LoggerInterface $logger) { $this->logger = $logger; } } Setter injection public function run() { if (!$this->logger instanceof LoggerInterface) { $this->logger->log('fetch'); } } }
11. How is this supposed to help me with my unit tests?
12. <?php class CaptureCommand { public function execute(OutputInterface $output) { $fetcher = new StatsFetcher(); $summary = $fetcher->fetch(); $output->writeln($summary->getResult()); } } Back to the sample class
13. <?php class CaptureCommandTest extends TestCase { public function testCommandExecutionFecthesMyStats(): void { $fetcherMock = $this ->createMock(StatsFetcher::class); $fetcherMock->method('fetch')->willReturn([]); $command = new CaptureCommand($fetcherMock); // test only your class here } } Unit tests
14. Dependency Inversion Principle
15. 1. High-level modules should not depend on low-level modules. Both should depend on abstractions. 2. Abstractions should not depend upon details. Details should depend upon abstractions. SOLID
16. Your class shouldn't care about specific implementations of a dependency
17. Interfaces
18. <?php // ShipmendAdapterInterface.php interface ShipmentAdapterInterface { public function create(Shipment $shipment): Shipment; } // Implementations class AuspostShipmentAdapter {} class StartrackShipmentAdapter {} Interfaces
19. <?php class ShipmentClient extends AbstractClient { private $adapter; public function __construct(ShipmentAdapterInterface $adapter) { $this->adapter = $adapter; } public function create(Shipment $shipment): Shipment { return $this->adapter->create($shipment); } } Interfaces
20. Abstraction doesn't mean that every class needs an interface
21. Abstract classes
22. <?php abstract class AbstractFetcher { protected $connection; public function __construct(PDO $connection) { $this->connection = $connection; } abstract public function fetch(): Summary; } Abstract classes
23. class CaptureCommand { private $fetcher; public function __construct( { $this->fetcher = $fetcher; } protected function execute(OutputInterface $output) { $summary = $this->fetcher->fetch(); // ... } } Abstract classes StatsFetcher $fetcher)
24. class CaptureCommand { private $fetcher; public function __construct(AbastractFetcher $fetcher) { $this->fetcher = $fetcher; } protected function execute(OutputInterface $output) { $summary = $this->fetcher->fetch(); // ... } } Abstract classes
25. You Aren't Gonna Need It
26. Base classes
27. <?php class GithubClient { private $httpClient; public function authenticate(string $token): void { $this->httpClient->request( 'POST', '/v1/authenticate', [ 'token' => $token, ] ); } } Base classes
28. <?php class GithubReviewer { protected $githubClient; public function __construct(GithubClient $githubClient) { $this->githubClient = $githubClient; } public function auth(string $token): Reviewer { $this->githubClient->authenticate($token); return $this; } } Base classes
29. A dependency should be replaceable without code changes in your class
30. SOLID YAGNI
31. Inversion of Control
32. Don't call us, we'll call you. "The Hollywood Principle"
33. Where is it applicable? - Frameworks - Dependency Injection containers - Event-driven architectures - Observer pattern
34. <?php require __DIR__.'/../vendor/autoload.php'; $connection = new PDO('mysql:host=localhost;dbname=sample); $client = new GuzzleHttp\Client([]); $report = new Report($client, 'sample'); $fetcher = new StatsFetcher($connection, $report); $comand = new CaptureStatsCommand($fetcher); $app = new Application('Sample app'); $app->add($comand); $app->run(); Structured programming
35. <?php $container = require __DIR__.'/../config/container.php'; $app = $container['application']; $app->run(); Inversion of Control
36. Dependency Injection Containers
37. How complex is a container?
39. Dependency A Dependency C Dependency E Dependency B Dependency D Dependency F Container
40. How does it work?
41. <?php // index.php $container = require __DIR__.'/../config/container.php'; /** @var AbstractCommand $command */ $command = $container['command']; $command->run();
42. <?php class CaptureCommand { private $repository; public function __construct(RepositoryInterface $repository) { $this->repository = $repository; } public function run(): void { // ... } }
43. <?php class StatsRepository implements RepositoryInterface { protected $connection; public function __construct(PDO $connection) { $this->connection = $connection; } // ... }
44. <?php // index.php $container = require __DIR__.'/../config/container.php'; /** @var AbstractCommand $command */ $command = $container['command']; $command->run();
45. <?php // container.php $container = new Container(); $container['connection'] = function () { return new PDO( sprintf('mysql:host=%s;dbname=sample', getenv('DB_HOST')) ); }
46. <?php // container.php $container['repository.stats'] = function (Container $container) { return new StatsRepository($container['connection']); }
47. <?php // container.php $container['repository.users'] = function (Container $container) { return new UsersRepository($container['connection']); } $container['model.payments'] = function (Container $container) { return new PaymentModel($container['connection']); }
48. <?php // container.php $container['command.capture'] = function (Container $container) { return new CaptureCommand($container['repository.stats']); }
49. <?php // index.php $container = require __DIR__.'/../config/container.php'; /** @var AbstractCommand $command */ $command = $container['command']; $command->run();
50. Container libraries in PHP - fabpot/pimple - symfony/dependency-injection - php-di
51. 1. Write clean, decoupled code 2. Make things reusable 3. Testability is key 4. Maintainable code is beautiful So why should I care?
52. Thanks!