依赖注入通过外部传入依赖降低耦合，手动注入适用于简单场景，复杂项目推荐使用DI容器自动管理对象创建与依赖解析。
依赖注入（Dependency Injection，简称DI）不是PHP独有的概念，而是一种设计模式，用来降低类之间的耦合度。在PHP中实现依赖注入，核心思想是：不直接在类内部创建依赖对象，而是通过外部传入。这样可以让代码更灵活、可测试、易维护。
手动依赖注入的基本实现
最简单的依赖注入方式是手动传参，比如一个用户服务依赖数据库连接：
class DatabaseConnection {
public function query($sql) {
// 模拟查询
return "result from $sql";
}
}
class UserService {
private $db;
// 通过构造函数注入依赖
public function __construct(DatabaseConnection $db) {
$this->db = $db;
}
public function getUser($id) {
return $this->db->query("SELECT * FROM users WHERE id = $id");
}}
// 使用时由外部创建并传入
$db = new DatabaseConnection();
$userService = new UserService($db);
echo $userService->getUser(1);
这种方式清晰明了，适用于小型项目。但当类越来越多、依赖关系复杂时，手动管理就变得繁琐。
立即学习“PHP免费学习笔记（深入）”；
依赖注入容器的作用
依赖注入容器（DI Container）是一个管理对象创建和依赖注入的工具。它能自动解析类的依赖，并实例化所需对象。
一个简单的容器可以这样实现：
class Container {
private $definitions = [];
private $instances = [];
// 绑定接口或类到具体实现
public function bind($abstract, $concrete = null) {
if ($concrete === null) {
$concrete = $abstract;
}
$this->definitions[$abstract] = $concrete;
}
// 获取实例
public function get($abstract) {
if (isset($this->instances[$abstract])) {
return $this->instances[$abstract];
}
$concrete = $this->definitions[$abstract] ?? $abstract;
// 如果是可调用的，执行它
if (is_callable($concrete)) {
$object = $concrete($this);
} else {
$object = $this->build($concrete);
}
$this->instances[$abstract] = $object;
return $object;
}
// 根据类的构造函数自动解析依赖
public function build($className) {
$reflector = new ReflectionClass($className);
if (!$reflector->isInstantiable()) {
throw new Exception("Can't instantiate $className");
}
$constructor = $reflector->getConstructor();
if (!$constructor) {
return new $className;
}
$parameters = $constructor->getParameters();
$dependencies = [];
foreach ($parameters as $param) {
$type = $param->getType();
if ($type && !$type->isBuiltin()) {
$dependencies[] = $this->get($type->getName());
} else {
if (!$param->isDefaultValueAvailable()) {
throw new Exception("Cannot resolve parameter: {$param->getName()}");
}
$dependencies[] = $param->getDefaultValue();
}
}
return $reflector->newInstanceArgs($dependencies);
}}
使用容器管理复杂依赖
假设我们有一个邮件服务和日志服务，用户注册时需要发送邮件并记录日志：
class Logger {
public function log($message) {
echo "[LOG] $message\n";
}
}
class Mailer {
private $logger;
public function __construct(Logger $logger) {
$this->logger = $logger;
}
public function send($to, $msg) {
$this->logger->log("Email sent to $to: $msg");
}}
class UserRegistration {
private $mailer;
private $logger;
public function __construct(Mailer $mailer, Logger $logger) {
$this->mailer = $mailer;
$this->logger = $logger;
}
public function register($email) {
$this->logger->log("Registering user: $email");
$this->mailer->send($email, "Welcome!");
}}
使用容器来自动解析这些嵌套依赖：
$container = new Container();// 注册服务 $container->bind(Logger::class); $container->bind(Mailer::class); $container->bind(UserRegistration::class);
// 获取实例（自动注入所有依赖） $registration = $container->get(UserRegistration::class); $registration->register('user@example.com');
输出：
[LOG] Registering user: user@example.com [LOG] Email sent to user@example.com: Welcome!
实际项目中的建议
虽然自己写容器有助于理解原理，但在生产环境中推荐使用成熟的DI容器，例如：
- PHP-DI：功能强大，支持注解和配置文件
- Symfony DependencyInjection：Symfony框架的核心组件之一
- Laravel Service Container：Laravel内置容器，使用广泛
它们支持更多高级特性，如作用域、延迟加载、配置绑定、Autowire等。
基本上就这些。掌握依赖注入的关键是理解“控制反转”——把对象创建的责任交给外部，而不是自己new。配合容器使用，能让应用结构更清晰，测试更容易。不复杂但容易忽略的是：别为了用容器而用容器，先从手动注入做起，等依赖变多再引入容器也不迟。
