Understanding Dependency Injection in PHP for Cleaner Code
Written on
Chapter 1: Introduction to Dependency Injection
If you're acquainted with PHP, you might have stumbled upon the term Dependency Injection.
Though it may seem daunting at first glance, it's more straightforward than it appears. When implemented properly, it can significantly improve the cleanliness and manageability of your code. Let’s delve into the essentials of Dependency Injection.
What is Dependency Injection?
In essence, Dependency Injection refers to the technique of supplying an object to another object. The object being created relies on another object to function correctly. This is achieved by passing the dependent object as a parameter, either through a constructor or a standard function. The core principle here is to manage the creation of an object externally to the class itself, allowing it to be injected as a parameter instead of being instantiated within the class.
How to Implement Dependency Injection in PHP?
Consider a scenario involving an Order class, which is responsible for creating an order. To create an order, we first need to verify if a payment has been processed. Thus, we require a Payment object to invoke the checkIfPaymentSuccessful method.
Without Dependency Injection:
In this case, we directly instantiate the Payment object within the constructor:
class Order
{
private $payment;
// Payment Object is initialized within the constructor
public function __construct($paymentId){
$this->payment = new Payment($paymentId);}
public function checkIfOrderCanBeMade(): object
{
$paymentSuccessful = $this->payment->checkIfPaymentSuccessful();
if ($paymentSuccessful){
return $this->createOrder();}
else {
return $this->failedPaymentOrder();}
}
}
In this example, the Payment object is created inside the class, requiring us to supply the properties needed by the Payment class.
With Dependency Injection:
Now, we create the Payment object outside of the class and pass it into the constructor:
class Order
{
private $payment;
// Payment dependency is injected into the constructor
public function __construct(Payment $payment){
$this->payment = $payment;}
public function checkIfOrderCanBeMade(): object
{
$paymentSuccessful = $this->payment->checkIfPaymentSuccessful();
if ($paymentSuccessful){
return $this->createOrder();}
else {
return $this->failedPaymentOrder();}
}
}
This approach allows us to utilize all methods from the Payment object without creating it inside the Order class!
Why Opt for Dependency Injection?
Employing Dependency Injection brings several advantages to your code:
- Maintainability: By reducing the number of locations where objects are instantiated, updates to a class require fewer changes throughout your code.
- Testability: Managing dependencies externally enhances visibility into the outputs of instantiated classes. Each function can focus on a single action, making it easier to test for expected outputs. In Unit Tests, dependencies instantiated within a function cannot be mocked, but those passed into the function can be.
- Reusability: Dependency Injection allows for a single instantiation of an object, which can then be shared across multiple classes. This minimizes code duplication within your project.
Utilizing Dependency Injection naturally leads to cleaner code.
Explore the concepts of Dependency Injection in PHP through this video, which discusses various design patterns, including Dependency Injection.
Get a quick overview of Dependency Injection in PHP in just 60 seconds, perfect for developers on the go.