Dependency Injection is all about code reusability. It's a design pattern aiming to make high-level code reusable, by separating the object creation / configuration from usage.
Consider the following code:
As you can see, instead of creating the PDO object inside the class, we create it outside of the class and pass it in as a dependency - via the constructor method. This way, we can use the driver of our choice, instead of having to to use the driver defined inside the class.
Our very own Alejandro Gervasio has explained the DI concept fantastically, and Fabien Potencier also covered it in a series.
There's one drawback to this pattern, though: when the number of dependencies grows, many objects need to be created/configured before being passed into the dependent objects. We can end up with a pile of boilerplate code, and a long queue of parameters in our constructor methods. Enter Dependency Injection containers!
A Dependency Injection container - or simply a DI container - is an object which knows exactly how to create a service and handle its dependencies.
In this article, we'll demonstrate the concept further with a newcomer in this field: Disco.
For more information on dependency injection containers, see our other posts on the topic here.
As frameworks are great examples of deploying DI containers, we will finish the article by creating a basic HTTP-based framework with the help of Disco and some Symfony Components.
Installation
To install Disco, we use Composer as usual:
To test the code, we'll use PHP's built-in web server:
As a result, the application will be accessible under http://localhost:8000 from the browser. The last parameter -t option defines the document root - where the index.php file resides.
Getting Started
Disco is a container_interop compatible DI container. Somewhat controversially, Disco is an annotation-based DI container.
Note that the package container_interop consists of a set of interfaces to standardize features of container objects. To learn more about how that works, see the tutorial in which we build our own, SitePoint Dependency Injection Container, also based on container-interop.
To add services to the container, we need to create a configuration class. This class should be marked with the @Configuration annotation:
Each container service should be defined as a public or protected method inside the configuration class. Disco calls each service a Bean, which originates from the Java culture.
Continue reading %Disco with Design Patterns: A Fresh Look at Dependency Injection%