依赖注入

    安装

    该组件默认存在 项目中并作为主要组件存在，如希望在其它框架内使用该组件可通过下面的命令安装。

    通常来说，类的关系及注入是无需显性定义的，这一切 Hyperf 都会默默的为您完成，我们通过一些代码示例来说明一下相关的用法。假设我们需要在 内调用 UserService 类的 getInfoById(int $id) 方法。

    1. <?php
    2. namespace App\Service;
    4. class UserService
    5. {
    6.     public function getInfoById(int $id)
    7.     {
    8.         // 我们假设存在一个 Info 实体
    9.         return (new Info())->fill($id);    
    10.     }
    11. }

    通过构造方法注入

    1. <?php
    2. namespace App\Controller;
    4. use App\Service\UserService;
    5. use Hyperf\HttpServer\Annotation\AutoController;
    7. class IndexController
    8. {
    9.     /**
    10.      * @var UserService
    11.      */
    12.     private $userService;
    14.     // 通过在构造函数的参数上声明参数类型完成自动注入
    15.     public function __construct(UserService $userService)
    16.     {
    17.         $this->userService = $userService;
    18.     }
    20.     public function index()
    21.     {
    22.         $id = 1;
    23.         // 直接使用
    24.     }
    25. }

    通过 @Inject 注解注入

    1. <?php
    2. namespace App\Controller;
    4. use App\Service\UserService;
    5. use Hyperf\Di\Annotation\Inject;
    6. use Hyperf\HttpServer\Annotation\AutoController;
    8. class IndexController
    9. {
    10.     /**
    11.      * 通过 `@Inject` 注解注入由 `@var` 注解声明的属性类型对象
    12.      * 
    13.      * @Inject 
    14.      * @var UserService
    15.      */
    16.     private $userService;
    18.     public function index()
    19.     {
    20.         $id = 1;
    21.         // 直接使用
    22.         return $this->userService->getInfoById($id);    
    23.     }
    24. }

    基于上面的例子，从合理的角度上来说，Controller 面向的不应该直接是一个 UserService 类，可能更多的是一个 UserServiceInterface 的接口类，此时我们可以通过 config/dependencies.php 来绑定对象关系达到目的，我们还是通过代码来解释一下。

    定义一个接口类：

    1. <?php
    2. namespace App\Service;
    4. class UserService implements UserServiceInterface
    5. {
    6.     public function getInfoById(int $id)
    7.     {
    8.         // 我们假设存在一个 Info 实体
    9.         return (new Info())->fill($id);    
    10.     }
    11. }

    在 config/dependencies.php 内完成关系配置：

    1. <?php
    2. return [
    3.     'dependencies' => [
    4.         \App\Service\UserServiceInterface::class => \App\Service\UserService::class
    5.     ],
    6. ];

    这样配置后就可以直接通过 UserServiceInterface 来注入 UserService 对象了，我们仅通过注解注入的方式来举例，构造函数注入也是一样的：

    1. <?php
    2. namespace App\Controller;
    4. use Hyperf\Di\Annotation\Inject;
    5. use Hyperf\HttpServer\Annotation\AutoController;
    7. class IndexController
    8. {
    9.     /**
    10.      * @Inject 
    11.      * @var UserServiceInterface
    12.      */
    13.     private $userService;
    15.     public function index()
    16.     {
    17.         $id = 1;
    18.         // 直接使用
    19.         return $this->userService->getInfoById($id);    
    20.     }
    21. }

    我们假设 UserService 的实现会更加复杂一些，在创建 UserService 对象时构造函数还需要传递进来一些非直接注入型的参数，假设我们需要从配置中取得一个值，然后 需要根据这个值来决定是否开启缓存模式（顺带一说 Hyperf 提供了更好用的 模型缓存 功能）

    我们需要创建一个工厂来生成 UserService 对象：

    UserService 也许在构造函数提供一个参数接收对应的值：

    1. <?php
    2. namespace App\Service;
    4. class UserService implements UserServiceInterface
    5. {
    7.     /**
    8.      * @var bool
    9.      */
    10.     private $enableCache;
    12.     public function __construct(bool $enableCache)
    13.     {
    14.         // 接收值并储存于类属性中
    15.         $this->enableCache = $enableCache;
    16.     }
    18.     public function getInfoById(int $id)
    19.     {
    20.         return (new Info())->fill($id);    
    21.     }
    22. }

    在 config/dependencies.php 调整绑定关系：

    1. <?php
    2. return [
    3.     'dependencies' => [
    4.         \App\Service\UserServiceInterface::class => \App\Service\UserServiceFactory::class
    5.     ],
    6. ];

    注意事项

    换种方式理解就是容器内管理的对象都是单例，这样的设计对于长生命周期的应用来说会更加的高效，减少了大量无意义的对象创建和销毁，这样的设计也就意味着所有需要交由 DI 容器管理的对象均不能包含 状态 值。状态 可直接理解为会随着请求而变化的值，事实上在 协程 编程中，这些状态值也是应该存放于 协程上下文 中的，即 Hyperf\Utils\Context。

    通过 new 关键词创建的对象毫无疑问的短生命周期的，那么如果希望创建一个短生命周期的对象但又希望通过依赖注入容器注入相关的依赖呢？这是我们可以通过 make(string $name, array $parameters = []) 函数来创建 $name 对应的的实例，代码示例如下：

      获取容器对象

      有些时候我们可能希望去实现一些更动态的需求时，会希望可以直接获取到 容器(Container) 对象，在绝大部分情况下，框架的入口类（比如命令类、控制器、RPC服务提供者等）都是由 容器(Container) 创建并维护的，也就意味着您所写的绝大部分业务代码都是在 容器(Container) 的管理作用之下的，也就意味着在绝大部分情况下您都可以通过在 构造函数(Constructor) 声明或通过 @Inject 注解注入 Psr\Container\ContainerInterface 接口类都能够获得 Hyperf\Di\Container 容器对象，我们通过代码来演示一下：

      在某些更极端动态的情况下，或者非 容器(Container) 的管理作用之下时，想要获取到 容器(Container) 对象还可以通过 \Hyperf\Utils\ApplicationContext::getContaienr() 方法来获得 容器(Container) 对象。

      1. $container = \Hyperf\Utils\ApplicationContext::getContainer();