ThinkPHP8容器与依赖注入

ThinkPHP8 容器与依赖注入（DI）核心机制解析

容器（Container）与依赖注入（DI）是 ThinkPHP8（TP8）的核心底层机制，支撑框架“低代码、高扩展、低耦合”的设计目标。

容器的核心定位

TP8 的容器（think\Container）是基于单例模式实现的依赖注入容器，可理解为框架的“对象工厂 + 对象仓库 + 依赖管理器”，承担三项核心职责：

• 对象工厂：根据类名或别名自动解析依赖并创建实例；
• 对象仓库：默认缓存已创建实例，避免重复实例化；
• 依赖管理器：统一管理接口与实现类、别名与类的绑定关系，支持灵活扩展。

容器的全局访问方式

以下三种写法等价，推荐使用助手函数 app()：

// 方式1：助手函数（最常用）
$container = app();

// 方式2：静态方法获取单例
$container = \think\Container::getInstance();

// 方式3：依赖注入（适用于控制器/中间件等支持 DI 的上下文）
public function __construct(\think\Container $container) {}

依赖注入（DI）的设计思想

DI 是一种解耦编程范式：类不再自行创建依赖对象，而是由容器将依赖实例“注入”到类中。TP8 基于 PHP 反射（Reflection）实现自动注入，解析构造方法或方法参数类型，完成依赖识别与实例装配，彻底替代手动 new 的耦合写法。

// 传统写法（高耦合）
class OrderController {
  public function create() {
    // 手动创建依赖，耦合严重
    $service = new OrderService(new Db());
  }
}

// DI 写法（低耦合）
class OrderController {
  // 容器自动注入依赖
  public function create(OrderService $service) {
    // 直接使用，无需关心实例化逻辑
  }
}

TP8 容器核心工作流程

容器遵循“绑定 → 解析 → 缓存”三步原则，底层依托反射机制实现：

流程拆解

1. 绑定（bind）：可选步骤，将接口、抽象类或别名映射至具体实现类；
2. 解析（resolve）：核心步骤，通过反射或 __make 方法解析依赖并创建实例；
3. 缓存（cache）：默认启用单例缓存，多次获取返回同一实例。

绑定方式详解

绑定是实现灵活扩展的关键，支持三类方式：

// 场景1：别名绑定（简化类名）
app()->bind('user.service', 'app\service\UserService');

// 场景2：接口绑定（面向接口编程）
app()->bind('app\contract\UserInterface', 'app\service\UserServiceImpl');

// 场景3：闭包绑定（自定义实例化逻辑）
app()->bind('pay.alipay', function () {
  $config = config('pay.alipay');
  return new \app\library\AliPay($config);
});

推荐将绑定规则统一配置在 app/provider.php（框架自动加载）：

// app/provider.php
return [
  'user.service' => 'app\service\UserService',
  'app\contract\UserInterface' => 'app\service\UserServiceImpl',
];

实例创建与获取（make / get）

• make：强制创建新实例，支持传入自定义参数，不优先使用缓存；
• get：优先返回缓存实例，无缓存时调用 make 创建。

// 场景1：基础解析（自动注入依赖）
$userService = app()->make('app\service\UserService');

// 场景2：通过别名解析
$userService = app()->get('user.service');

// 场景3：传入自定义参数（覆盖构造方法默认值）
$orderService = app()->make('app\service\OrderService', ['app_name' => 'shop']);

DI 触发方式：自动与手动

自动触发（框架内置支持）

TP8 在以下核心场景中自动完成依赖注入，开发者无需干预：

• 控制器的构造方法及普通方法；
• 中间件的 handle 方法；
• 命令行指令的 execute 方法；
• 事件监听器的处理方法。

namespace app\controller;
use think\Request;
use app\service\OrderService;
use app\contract\UserInterface;

class Order {
  // 场景1：方法参数注入（最常用）
  public function create(Request $request, OrderService $service) {
    $orderId = $request->param('id');
    return $service->createOrder($orderId);
  }

  // 场景2：构造方法注入（全局复用）
  public function __construct(private UserInterface $userService) {}

  public function detail($id) {
    return $this->userService->getUserInfo($id);
  }
}

手动触发（非核心流程）

对定时任务、工具类调用等框架未自动接管的场景，需使用 invoke 或 invokeMethod 显式触发 DI：

// Service 类（方法声明依赖）
namespace app\service;
use think\Request;
use app\util\DateUtil;

class OrderService {
  public function createOrder(Request $request, DateUtil $dateUtil, $orderId) {
    return "订单{$orderId}：{$dateUtil->formatNow()}，请求ID：{$request->id}";
  }
}

// 调用示例（如定时任务中）
$service = new OrderService();
$result = invoke([$service, 'createOrder'], ['orderId' => 1001]);

// 场景1：闭包注入
$closure = function (think\Db $db) {
  return $db->name('order')->where('id', 1001)->find();
};
$result = invoke($closure);

// 场景2：普通函数注入
function getOrder(think\Request $request) {
  return $request->param('id');
}
$result = invoke('getOrder');

__make：自定义实例化钩子

当类构造方法含非类参数（如字符串、数组）时，容器默认反射无法解析。可通过定义静态 __make 方法扩展实例化逻辑，突破默认规则：

namespace app\service;
use think\Container;
use think\Request;

class OrderService {
  private $request;
  private $appName;

  public function __construct(Request $request, string $appName) {
    $this->request = $request;
    $this->appName = $appName;
  }

  // 自定义实例化逻辑
  public static function __make(Container $container, array $params = []) {
    // 1. 获取类类型依赖（复用 DI）
    $request = $container->get(Request::class);

    // 2. 处理非类参数（从配置或传参获取）
    $appName = $params['app_name'] ?? $container->get('config')->get('app.name');

    // 3. 返回实例
    return new self($request, $appName);
  }

  public function getInfo() {
    return "应用名：{$this->appName}，请求ID：{$this->request->id}";
  }
}

// 调用（无需手动传 $appName）
$service = app(OrderService::class);
echo $service->getInfo(); // 输出：应用名：default，请求ID：xxx

最佳实践规范

类的设计规范

• 依赖优先通过构造方法注入，方法参数仅传递业务数据；
• 禁止手动 new 实例，所有对象均应通过容器获取（如 app(类名)）；
• 构造方法中的非类参数（如字符串、数字）须设默认值，或由 __make 统一处理。

项目结构规范

app/
├── controller/   # 控制器：声明依赖，由框架自动注入
├── service/      # 业务服务：构造方法注入依赖，封装核心逻辑
├── contract/     # 接口：定义契约，解耦实现
├── util/         # 工具类：无状态，可被自动注入
└── provider.php  # 容器绑定：集中管理接口→实现类、别名绑定

常见问题避坑指南

总结

容器是 TP8 的核心枢纽，统一管理所有类的生命周期与依赖关系；DI 是其核心能力，基于反射实现自动化装配。

DI 分两类触发方式：框架自动接管控制器、中间件等核心流程；非核心流程需通过 invoke 显式调用。

__make 是关键扩展钩子，用于覆盖默认反射规则，处理含非类参数的复杂构造场景。

落地核心原则：依赖通过构造方法注入、所有实例经容器获取、杜绝手动 new——这正是 TP8 “约定优于配置、自动化替代手动”的现代框架设计思想体现。