Dependency Injection 💉

Build testable, decoupled PHP applications with dependency injection containers and service providers.

What You'll Learn in This Lesson

• Why tight coupling makes code untestable and fragile
• Constructor, setter, and interface injection techniques
• Build a DI container with bind, singleton, and resolve
• Service providers for organizing registration logic
• The "depend on abstractions, not concretions" principle

Note: PHP runs on a server. Our examples simulate PHP logic using JavaScript. To run real PHP, install PHP.

🎯 Real-World Analogy: Dependency Injection is like ordering food at a restaurant. Without DI, you'd go to the kitchen, find ingredients, and cook yourself — tightly coupled to the kitchen's layout. With DI, you just tell the waiter what you want (the interface) and they bring it — you don't care if the chef uses gas or electric, local or imported ingredients. The waiter (container) handles all the wiring.

DI Fundamentals: Tight vs Loose Coupling

Without DI, classes create their own dependencies — hardcoding which database, logger, or mailer to use. This makes swapping implementations impossible and unit testing a nightmare. With DI, dependencies are passed in from outside, so you can inject real services in production and mock objects in tests.

Try It: DI Basics

See the difference between tight coupling and dependency injection

Try it Yourself »

JavaScript

// Dependency Injection: The Core Concept
console.log("=== WITHOUT Dependency Injection (Tight Coupling) ===");
console.log();

class MySQLDatabase {
  connect() { return "Connected to MySQL"; }
  query(sql) { return "MySQL result for: " + sql; }
}

// ❌ BAD: Class creates its own dependency
class UserServiceBad {
  constructor() {
    this.db = new MySQLDatabase(); // Hardcoded! Can't swap or test
  }
  getUsers() { return this.db.query("SELECT * FROM users"); }
}

let bad = new UserServiceBad(
...

Building a DI Container

A DI container is a registry that knows how to create and wire all your application's services. You register factories (bind) or singletons, and the container resolves the full dependency tree automatically. Frameworks like Laravel, Symfony, and PHP-DI all provide containers — but understanding how they work from scratch makes you a better developer.

Try It: DI Container

Build a container with bind, singleton, and resolve — auto-wire services

Try it Yourself »

JavaScript

// DI Container: Auto-Wiring Dependencies
console.log("=== Building a Simple DI Container ===");
console.log();

class Container {
  constructor() {
    this.bindings = new Map();
    this.singletons = new Map();
  }

  // Register a factory function
  bind(name, factory) {
    this.bindings.set(name, { factory, singleton: false });
    console.log("  📦 Bound: " + name);
  }

  // Register as singleton (created once, reused)
  singleton(name, factory) {
    this.bindings.set(name, { factory, si
...

⚠️ Common Mistakes

⚠️

Service Locator anti-pattern — don't pass the container itself into classes. Each class should declare its dependencies explicitly in the constructor, not fetch them from a global container.

⚠️

Injecting too many dependencies — if a class needs 7+ injected services, it's doing too much. Split it into smaller, focused classes with 2-3 dependencies each.

⚠️

Circular dependencies — if A needs B and B needs A, your design is flawed. Extract shared logic into a third class that both can depend on.

💡

Pro Tip: In PHP 8+, use constructor promotion to keep DI clean: public function __construct(private readonly UserRepository $users) {}

📋 Quick Reference — Dependency Injection

Concept	Description
Constructor Injection	Pass dependencies via constructor (preferred)
Setter Injection	Pass dependencies via setter methods
bind()	Register a factory — new instance each time
singleton()	Register once — same instance reused
resolve()	Get an instance from the container
Service Provider	Organizes bindings into logical groups

🎉 Lesson Complete!

You can now build decoupled, testable PHP apps with DI! Next, learn advanced error handling with custom exception hierarchies.