MVC Lesson 11: Dependency Injection (DI) & Container using a very simple real-life analogy

Dilip Published: Categories: PHP MVC

Let’s break down Dependency Injection (DI) using a very simple real-life analogy, followed by an easy PHP example.

🔧 Analogy: Car and Tyre Shop

Imagine you’re building a Car. A car needs Tyres to run.

❌ Without Dependency Injection:

You hardcode tyre creation inside the car:

class Car {
    public $tyre;

    public function __construct() {
        $this->tyre = new Tyre(); // Car decides which Tyre to use
    }
}

Problem: The car is now responsible for creating its own tyres. What if you want to use different tyres (e.g., for racing or off-road)? You’d have to modify the Car class every time. That’s not flexible.

✅ With Dependency Injection:

You give the tyre to the car from outside, like handing it a part in a garage:

class Car {
    public $tyre;

    public function __construct(Tyre $tyre) {
        $this->tyre = $tyre;
    }
}

Now, when building the car:

$tyre = new Tyre();           // You control which Tyre is used
$car = new Car($tyre);        // Inject it into the Car

Benefit:

  • The Car doesn’t care how the Tyre is made.
  • You can easily swap out the Tyre (e.g., RacingTyre, CheapTyre) without changing the Car class.

🧠 In Simple Words

Dependency Injection means giving an object its needed things (dependencies) from the outside, instead of creating them inside the object.

Using global variables can be used to share dependencies or data across different parts of an application, but it’s risky and generally discouraged.

Now Let’s break down containers in PHP (like Laravel’s service container) using a very simple analogy anyone can understand:

📦 Analogy: A Coffee Shop and the Barista

Imagine you walk into a coffee shop and ask for a Cappuccino.

You don’t need to know:

  • How to make espresso
  • How to steam milk
  • What brand of coffee beans they use

You just ask:

“Give me a Cappuccino.”

And the Barista (Container) takes care of:

  • Finding the recipe
  • Preparing all the ingredients (dependencies)
  • Handing you a ready-made Cappuccino

🧠 Now Think in Code:

In Laravel or modern PHP MVC, instead of manually creating all objects (and their dependencies), you just ask the container:

$car = $container->make(Car::class);

And the container will:

  • Look at the constructor of Car
  • See that it needs a Tyre
  • Create a Tyre automatically
  • Inject it into Car
  • Return the ready-to-use Car object

✅ Why Containers Are Useful

  • Automatic dependency injection
  • Central place to bind/configure services
  • Makes code loosely coupled and testable

💬 In Simple Words:

A container is like a smart assistant or factory that knows how to build and provide anything your app needs—without you doing all the setup manually.