Dependency injection (DI) is a way in PHP to pass dependencies to a class rather than hard-coded inside a class. 1. DI passes the dependencies of the object to the outside through constructors or settings methods to improve code flexibility and testability; 2. DI can be implemented manually, suitable for small projects; 3. DI can be automatically resolved by complex applications, such as Symfony and Laravel built-in containers; 4. Common misunderstandings include premature over-design, type prompts specific implementation rather than interfaces, abuse of service locators, etc. Correct use of DI can significantly improve code quality and maintenance efficiency.

Dependency injection (DI) in PHP is a way to pass dependencies into a class rather than hard-coding them inside it. This makes your code more flexible, easier to test, and maintainable. You don't need a framework to do DI — you can implement it manually or use a container for more complex applications.

Understanding the Basic Concept

At its core, dependency injection means giving an object its dependencies instead of letting it create them itself. Think of it like ordering food at a restaurant: instead of going to the kitchen to cook yourself, someone else prepares it and give it to you.

For example, if you have a Mailer class that sends emails, and another class UserNotifier needs to send emails when something happens, instead of creating a new Mailer inside UserNotifier , you pass it in:

 class Mailer {
    public function send($message) {
        // Send email logic
    }
}

class UserNotifier {
    private $mailer;

    public function __construct(Mailer $mailer) {
        $this->mailer = $mailer;
    }

    public function notify($user) {
        $this->mailer->send("Hello " . $user['name']);
    }
}

This allows you to swap out the mailer easily (eg, with a mock during testing), which is one of the main benefits.

Implementing DI Manually

You can start using DI without any tools. Just write classes that accept their dependencies through constructors or setter methods.

Here's how you might instantiate the above classes manually:

 $mailer = new Mailer();
$notifier = new UserNotifier($mailer);
$notifier->notify(['name' => 'Alice']);

• Construction injection is the most common and preferred method.
• Setter injection is useful when the dependency is optional or might change.
• Avoid calling new inside your classes — this tightly couples them to specific implementations.

This manual approach works fine for small projects, but as your app grows, managing dependencies by hand becomes tedious.

Using a DI Container

As your application scales, managing dependencies manually gets harder. That's where a DI container comes in handy. A container automates the process of resolving and injecting dependencies.

Popular PHP containers include:

• Symfony's DependencyInjection component
• Laravel's service container
• PHP-DI

These tools allow you to define how your classes should be created and what dependencies they need. The container handles instantiating everything automatically.

A basic usage pattern looks like this:

 // With a container like PHP-DI
use DI\ContainerBuilder;

$container = new ContainerBuilder();
$container->addDefinitions([
    Mailer::class => \DI\autowire(),
    UserNotifier::class => \DI\autowire()
]);

$userNotifier = $container->get(UserNotifier::class);
$userNotifier->notify(['name' => 'Bob']);

The container automatically resolves the Mailer dependency and injects it into UserNotifier .

If you're using a modern PHP framework like Laravel or Symfony, you already have a DI container built-in. You just type-hint the dependencies in your constructor, and the framework does the rest.

Common Pitfalls and Tips

• Don't over-engineer early : If your app is small, stick with manual DI. You can always introduce a container later.
• Type-hint interfaces, not implementations : This makes your code more flexible. For example, type-hint an EmailServiceInterface instead of a specific Mailer .
• Use autowiring when possible : Most containers support autowiring, which reduces boilerplate configuration.
• Avoid service locators or global containers : These can lead to hidden dependencies and make your code harder to understand and test.

Also, remember that DI doesn't mean “always inject everything.” Use it where it makes sense — especially for services, external APIs, and things that vary between environments (like database connections or loggers).

Basically that's it.

The above is the detailed content of How Do You Implement Dependency Injection in PHP?. For more information, please follow other related articles on the PHP Chinese website!