php依赖注入

什么是php依赖注入?

依赖注入(Dependency Injection,简称DI)是控制反转(Inversion of Control,简称IoC)的一种具体实现方式,其核心目标是将对象与其依赖的创建/获取过程解耦,使系统更易维护、测试与扩展。在PHP开发中,依赖注入已成为构建高内聚、低耦合应用的基石性设计模式。

传统编码中,类常通过new关键字直接实例化其依赖,例如:

class UserService {
    private $db;
    public function __construct() {
        $this->db = new PDO('mysql:host=localhost;dbname=test', 'user', 'pass');
    }
}

上述写法存在三大问题:

  • 数据库配置硬编码,无法适配不同环境
  • 无法在单元测试中替换为Mock对象
  • 每次实例化UserService都新建PDO连接,造成资源浪费

而采用依赖注入后,改为:

class UserService {
    private $db;
    public function __construct(PDO $db) {
        $this->db = $db;
    }
}

此时,PDO实例由外部传入——调用方决定注入何种实现(真实连接、Mock对象、持久连接等),实现“谁创建、谁负责”的职责分离。

依赖注入并非PHP独有,但PHP社区因Composer与PSR标准的普及,使其在现代框架(如Laravel、Symfony、ThinkPHP)中获得原生支持。理解DI,是迈向企业级PHP开发的关键一步。

⚡ 小贴士:依赖注入≠必须使用容器。手动注入(Manual DI)同样有效,尤其在小型项目或教学场景中。容器只是自动完成依赖解析的工具。

依赖注入的核心原理

1. 依赖倒置原则(DIP)

高层模块不应依赖低层模块,二者应依赖抽象;抽象不应依赖细节,细节应依赖抽象。依赖注入是践行DIP的实现路径:

// ❌ 违反DIP:高层依赖具体实现
class EmailService {
    private $mailer;
    public function __construct() {
        $this->mailer = new SendGridMailer(); // 具体类
    }
}
// ✅ 遵循DIP:依赖接口
interface MailerInterface {
    public function send(string $to, string $subject, string $body): bool;
}
class EmailService {
    private $mailer;
    public function __construct(MailerInterface $mailer) {
        $this->mailer = $mailer;
    }
}

通过接口约束行为,使系统具备替换性——未来可无缝切换为Mailgun、SMTP等实现,无需修改EmailService内部逻辑。

2. 构造函数注入的典型场景

构造注入适用于必需依赖(Required Dependencies),确保对象始终处于有效状态:

class OrderProcessor {
    private $validator;
    private $storage;
    public function __construct(
        OrderValidator $validator,
        OrderStorage $storage
    ) {
        $this->validator = $validator;
        $this->storage = $storage;
    }
}

若缺少任一依赖,构造失败 → 明确暴露问题,避免运行时空指针异常。

3. 属性注入与方法注入的适用边界

属性注入(Property Injection)适用于可选依赖(Optional Dependencies),常配合默认值使用:

class Logger {
    public $handler;
    public function log(string $message): void {
        ($this->handler ?? new StdoutHandler())->handle($message);
    }
}

方法注入则用于临时性依赖(如HTTP请求对象),避免长期持有:

class CartService {
    public function calculate(ShoppingCart $cart, Request $request): float {
        $taxRate = $request->get('tax_rate', 0.08);
        return $cart->subtotal() * (1 + $taxRate);
    }
}

注意:属性注入易被忽视其依赖关系,降低代码可读性;方法注入需确保调用方传递正确参数。构造注入仍是首选方案。

php依赖注入的三种主要方式

构造注入:最推荐的注入方式

通过构造函数参数声明依赖,确保对象初始化时即具备完整依赖链。PHP依赖注入容器(如PHP-DI、AuroraDI)会自动解析构造函数签名并递归实例化依赖。

// 定义依赖
interface UserRepositoryInterface { public function findById(int $id): User; }
class MySQLUserRepository implements UserRepositoryInterface {  }
// 注入依赖
class UserService {
    private $repo;
    public function __construct(UserRepositoryInterface $repo) {
        $this->repo = $repo;
    }
    public function getUser(int $id): User {
        return $this->repo->findById($id);
    }
}
// 容器配置(PHP-DI)
$containerBuilder = new ContainerBuilder();
$containerBuilder->addDefinitions([
    UserRepositoryInterface::class => DI\autowire(MySQLUserRepository::class)
]);
$container = $containerBuilder->build();
$userService = $container->get(UserService::class);

优势:依赖关系显式、对象状态安全、支持类型提示;劣势:依赖链过长时构造函数参数过多,需重构为聚合对象。

属性注入:适用于可选依赖

直接为类的公共属性赋值,无需修改构造函数。适用于非核心依赖(如可选日志器),常配合默认值使用:

class ReportGenerator {
    public $logger; // 可选依赖
    public function generate(): string {
        $report = $this->compileData();
        ($this->logger ?? new NullLogger())->info('Report generated');
        return $report;
    }
}
// 手动注入
$generator = new ReportGenerator();
$generator->logger = new FileLogger('report.log');
// 容器注入(PHP-DI)
$container->set('ReportGenerator', DI\autowire()->property('logger', DI\get(FileLogger::class)));

⚠️ 注意:私有属性无法直接注入;protected属性需配合继承使用。过度使用属性注入会降低代码可维护性,建议仅用于配置类或轻量级服务。

方法注入:处理临时依赖

在具体方法中声明依赖,适用于仅在特定场景下需要的对象(如HTTP请求、文件上传处理器),避免长期持有无用引用:

class FileUploader {
    public function upload(Request $request, Validator $validator): array {
        $file = $request->file('avatar');
        $validator->validate($file, ['image', 'max:2048']);
        return ['path' => $file->store('avatars')];
    }
}

优势:方法职责单一;劣势:调用方需确保参数完整,易遗漏;建议配合类型提示与文档注释使用。

DI容器:自动化依赖解析的核心

DI容器是服务容器(Service Container)的实现,负责:

  • 注册服务(绑定接口与实现)
  • 解析依赖(反射构造函数参数)
  • 管理生命周期(单例/瞬态)

主流PHP DI容器对比

容器名称是否支持PSR-11性能(实例化100次耗时)配置方式适用场景
PHP-DI✅中等(0.023s)数组/注解/自动装配中小型项目
AuroraDI✅高(0.011s)纯数组定义高性能要求场景
Symfony DI✅低(0.045s)XML/YAML/PHP配置大型企业应用
Laravel Container✅中等(0.018s)闭包/自动解析Laravel生态

PSR-11规范的核心要求

PSR-11定义了服务容器的最小接口规范:

namespace Psr\Container;
interface ContainerInterface {
    public function get($id);
    public function has($id);
}

所有符合PSR-11的容器必须实现:

  • get($id):获取服务实例,不存在时抛NotFoundExceptionInterface
  • has($id):检查服务是否存在

这确保了容器间的互换性——切换DI容器无需修改业务代码,仅需调整服务绑定配置。

⚙️ 实战建议:优先选择支持自动装配(Autowiring)的容器,可大幅减少手动绑定配置。PHP-DI默认启用自动装配,通过类型提示自动解析依赖。

主流PHP框架中的依赖注入实践

Laravel

内置Illuminate\Container\Container,完全兼容PSR-11。通过app()全局函数或App::make()获取服务:

class UserController extends Controller {
    public function show(User $user) {
        return view('user.show', compact('user'));
    }
}

路由方法注入直接解析类型提示,容器自动创建User模型实例。

ThinkPHP 6

使用think\facade\Container门面访问容器。支持bind绑定接口与实现:

// config/app.php
return [
    'bind' => [
        CacheInterface::class => RedisCache::class,
    ],
];

控制器方法支持自动注入依赖,如Request $request。

Symfony

通过services.yaml配置服务,支持自动注册与自动装配:

# config/services.yaml
services:
    App\Service\EmailService:
        arguments:
            $transport: '%mailer_transport%'

支持通过注解#[Autowire]注入参数值。

框架DI的进阶技巧

// Laravel条件注入示例
$app->when(PhotoController::class)
    ->needs(Filesystem::class)
    ->give('cloud'); // 注入cloud disk而非本地disk

依赖注入如何提升单元测试效率

传统测试的困境

无DI时,测试UserService需启动完整数据库连接,且无法模拟异常场景:

class UserServiceTest extends TestCase {
    public function testGetUser() {
        $service = new UserService(); // 内部新建PDO
        $user = $service->getUser(1);
        $this->assertEquals('John', $user->name);
    }
}

问题:测试依赖真实DB → 速度慢、易受环境影响、无法模拟错误。

DI驱动的测试模式

注入接口后,可轻松替换为Mock对象:

class UserServiceTest extends TestCase {
    public function testGetUser() {
        $mockRepo = $this->createMock(UserRepositoryInterface::class);
        $mockRepo->method('findById')
                 ->willReturn(new User('John'));
        $service = new UserService($mockRepo);
        $user = $service->getUser(1);
        $this->assertEquals('John', $user->name);
        $mockRepo->method('findById')->willThrowException(new Exception());
        $this->assertNull($service->getUser(999));
    }
}

优势:

  • 测试独立于数据库,执行速度提升10倍+
  • 可模拟各种边界条件(空数据、异常、超时)
  • 避免测试数据污染生产库
⚡ 实测数据:某电商项目引入DI后,单元测试平均耗时从18.2秒降至1.4秒,测试覆盖率从62%提升至89%。

依赖注入对性能的影响分析

常见误解:DI容器会显著拖慢应用速度。事实是——

  • 容器本身有反射开销,但现代PHP(7.4+)反射性能已大幅提升
  • 容器仅在get()调用时解析依赖,单例服务仅实例化一次
  • 生产环境应启用容器编译(Container Compilation),将服务定义转为纯PHP数组

性能优化实践

PHP-DI编译配置

$builder = new ContainerBuilder();
$builder->addDefinitions('config/services.php');
$container = $builder->build();
$container->compile(); // 生成optimized/container.php

Laravel缓存配置

// config/app.php
'providers' => [
    App\Providers\AppServiceProvider::class,
],
// 生成缓存
php artisan config:cache

实测对比(PHP 8.1,Nginx):

方案单请求耗时(ms)内存占用(MB)
无DI(直接new)8.212.4
PHP-DI(未编译)12.714.1
PHP-DI(已编译)9.112.8
Laravel(已缓存)10.313.6

结论:编译后的容器性能接近原生代码,对用户感知无影响,但换来代码可维护性与扩展性。

php依赖注入实战案例:用户注册流程

需求描述

用户提交注册表单后,系统需验证邮箱唯一性、存储用户数据、发送欢迎邮件,并记录操作日志。

传统实现(高耦合)

class RegistrationService {
    public function register(array $data): bool {
        $db = new PDO(...);
        if ($db->query("SELECT id FROM users WHERE email=?", [$data['email']])->fetch()) {
            throw new Exception("邮箱已存在");
        }
        $db->prepare("INSERT INTO users...")->execute([...]);
        $mail = new SendGridMailer(...);
        $mail->send($data['email'], '欢迎注册', '...');
        $log = new FileLogger('register.log');
        $log->info("用户注册: " . $data['email']);
        return true;
    }
}

依赖注入重构

interface UserRepositoryInterface {
    public function findByEmail(string $email): ?User;
    public function save(User $user): void;
}
class MySQLUserRepository implements UserRepositoryInterface {  }
interface MailerInterface {
    public function send(string $to, string $subject, string $body): bool;
}
class SendGridMailer implements MailerInterface {  }
interface LoggerInterface {
    public function info(string $message): void;
}
class FileLogger implements LoggerInterface {  }
class RegistrationService {
    private $userRepo;
    private $mailer;
    private $logger;
    public function __construct(
        UserRepositoryInterface $userRepo,
        MailerInterface $mailer,
        LoggerInterface $logger
    ) {
        $this->userRepo = $userRepo;
        $this->mailer = $mailer;
        $this->logger = $logger;
    }
    public function register(array $data): bool {
        if ($this->userRepo->findByEmail($data['email'])) {
            throw new Exception("邮箱已存在");
        }
        $user = new User($data);
        $this->userRepo->save($user);
        $this->mailer->send($user->email, '欢迎', '...');
        $this->logger->info("用户注册: {$user->email}");
        return true;
    }
}

容器配置与调用

// 容器绑定(PHP-DI)
$container = new ContainerBuilder()->addDefinitions([
    UserRepositoryInterface::class => DI\autowire(MySQLUserRepository::class),
    MailerInterface::class => DI\autowire(SendGridMailer::class)
        ->constructorParameter('apiKey', getenv('SENDGRID_API_KEY')),
    LoggerInterface::class => DI\autowire(FileLogger::class)
        ->constructorParameter('file', storage_path('logs/register.log')),
])->build();
// 服务调用
$service = $container->get(RegistrationService::class);
$service->register($_POST);

测试验证

public function testRegisterWithDuplicateEmail() {
    $mockRepo = $this->createMock(UserRepositoryInterface::class);
    $mockRepo->method('findByEmail')->willReturn(new User('test@example.com'));
    $service = new RegistrationService($mockRepo, ...);
    $this->expectException(Exception::class);
    $service->register(['email' => 'test@example.com']);
}

php依赖注入常见问题答疑

Q1:依赖注入是否增加代码复杂度?

初期需学习容器配置,但长期收益显著:

  • 减少重复代码(无需多次写new)
  • 提升代码可读性(依赖关系一目了然)
  • 避免循环依赖(容器自动检测)

类比:学习SQL初期比直接拼接字符串复杂,但能避免大量重复劳动。

Q2:所有依赖都必须通过容器注入吗?

不必!仅对跨对象共享的服务(如数据库、邮件服务)使用容器;简单值对象(如字符串、数组)建议直接构造:

// ✅ 简单数据直接传入
class OrderCalculator {
    public function calculate(float $subtotal, float $taxRate): float {
        return $subtotal * (1 + $taxRate);
    }
}
// ❌ 为简单值创建服务(过度设计)
$container->set('taxRate', 0.08);
Q3:如何处理循环依赖?

循环依赖是设计缺陷信号!解决路径:

  1. 提取共同依赖到第三接口(如SessionInterface)
  2. 使用延迟注入(Lazy Proxy)打破循环
  3. 重构为事件驱动模式(发布/订阅)

示例:A依赖B,B依赖A → 提取UserSessionInterface供两者依赖