L'injection de dépendances (DI) est un modèle de conception où une classe reçoit ses dépendances de l'extérieur (généralement via le constructeur) plutôt que de les créer elle-même. Les frameworks PHP modernes utilisent massivement la DI, souvent avec un conteneur qui résout et injecte automatiquement les dépendances — ce qui conduit à un code faiblement couplé et testable.
{
;
{
->mailer = ();
}
}
{
{}
}
Injecter des dépendances (contre une interface) découple la classe des implémentations concrètes — vous pouvez échanger les implémentations et injecter des mocks dans les tests.
class OrderService {
public function __construct(
private OrderRepository $repo, // dependencies declared in the constructor
private MailerInterface $mailer,
private LoggerInterface $logger,
) {}
}
L'injection de constructeur rend les dépendances explicites et garantit que l'objet est entièrement formé lors de sa création.
// a DI CONTAINER builds objects, resolving the whole dependency graph automatically
$container->bind(MailerInterface::class, SmtpMailer::class); // map interface → impl
$service = $container->get(OrderService::class);
// the container sees OrderService needs OrderRepository, MailerInterface, LoggerInterface,
// constructs each (recursively), and injects them — you don't `new` anything manually
Un conteneur DI (dans Laravel, Symfony, ou autonome comme PHP-DI) construit automatiquement les objets en résolvant récursivement leurs dépendances de constructeur — vous configurez les liaisons interface-à-implémentation, et le conteneur assemble tout ensemble.
✓ Loose coupling — depend on interfaces/abstractions, not concrete classes
✓ Testability — inject mocks/fakes in tests (no real DB/mailer needed)
✓ Flexibility — swap implementations via container config (e.g. fake mailer in dev)
✓ Single responsibility — classes focus on logic, not constructing dependencies
L'injection de dépendances est un modèle fondamental en PHP moderne, central à la structure des applications et frameworks professionnels (Laravel, Symfony), donc la comprendre est une connaissance importante au niveau senior.
La valeur centrale est le découplage et la testabilité : en ayant les classes qui reçoivent leurs dépendances (déclarées contre des interfaces) plutôt que de les créer, le code devient faiblement couplé (dépendant des abstractions, pas des implémentations concrètes), facilement testable (vous injectez des mocks au lieu de vraies bases de données/services — ce qui rend les tests unitaires approfondis pratiques), et flexible (échange d'implémentations via la configuration).
Les frameworks PHP modernes fournissent des conteneurs DI qui automatisent cela — résolvant et injectant l'ensemble du graphique de dépendances automatiquement en fonction des liaisons interface-à-implémentation, donc vous ne construisez pas manuellement les objets.
Comprendre l'injection de constructeur (la forme standard), programmer contre des interfaces, et comment fonctionnent les conteneurs DI (résolution automatique) est essentiel pour travailler efficacement avec les frameworks PHP (qui sont construits autour de DI) et pour écrire du code PHP bien architecturé, maintenable et testable.
Etant donné que la DI sous-tend la structure de tous les principaux frameworks PHP modernes et est une caractéristique du design d'application professionnel, la maîtriser — le modèle, ses avantages, et la résolution basée sur conteneur — est une connaissance importante qui distingue les développeurs qui peuvent construire du PHP propre, testable et idiomatique des frameworks de ceux qui écrivent du code fortement couplé et difficile à tester.