迹忆客 专注技术分享

在本文中，我们将查看一些使用 Symfony DependencyInjection 组件的示例。 我们将学习依赖注入的基础知识，它允许干净和模块化的代码，我们将看到如何在带有 Symfony 组件的 PHP 应用程序中使用它。

什么是 Symfony DependencyInjection 组件？

Symfony DependencyInjection 组件提供了一种标准方法来实例化对象并处理 PHP 应用程序中的依赖管理。 DependencyInjection 组件的核心是一个容器，它包含应用程序中所有可用的服务。

在应用程序的引导阶段，我们应该将应用程序中的所有服务注册到容器中。 在稍后阶段，容器负责根据需要创建服务。 更重要的是，容器还负责创建和注入服务的依赖项。

这种方法的好处是我们不必对实例化对象的过程进行硬编码，因为依赖项将被自动检测和注入。 这会在应用程序的各个部分之间造成松耦合。

在本文中，我们将探讨如何释放 DependencyInjection 组件的强大功能。 像往常一样，我们将从安装和配置说明开始，我们将实施一些真实世界的示例来演示关键概念。

安装和配置

在本节中，我们将继续安装 DependencyInjection 组件。 我假设大家已经在系统中安装了 Composer，因为我们需要它来安装 Packagist 提供的 DependencyInjection 组件。

因此，继续使用以下命令安装 DependencyInjection 组件。

$ composer require symfony/dependency-injection

那应该已经创建了 composer.json 文件，它应该如下所示：

{
    "require": {
        "symfony/dependency-injection": "^5.4"
    }
}

我们还将安装一些在我们的示例中有用的其他组件。

如果我们想从 YAML 文件加载服务而不是在 PHP 代码中定义它，那么 Yaml 组件可以帮上忙，因为它可以帮助我们将 YAML 字符串转换为 PHP 兼容的数据类型，反之亦然。

$ composer require symfony/yaml

最后，我们将安装 Config 组件，它提供了几个实用程序类来初始化和处理在不同类型的文件（如 YAML、INI 和 XML）中定义的配置值。 在我们的例子中，我们将使用它从 YAML 文件加载服务。

$ composer require symfony/config

让我们将 composer.json 文件修改为如下所示。

{
    "require": {
        "symfony/dependency-injection": "^5.4",
        "symfony/yaml": "^5.4",
        "symfony/config": "^5.4"
    },
    "autoload": {
         "psr-4": {
             "Services\\": "src"
         },
         "classmap": ["src"]
    }
}

由于我们添加了一个新的类映射条目，让我们继续运行以下命令来更新 composer 自动加载器。

$ composer dump -o

现在，我们可以使用服务命名空间自动加载 src 目录下的类。

这就是安装部分，但是我们应该如何使用它呢？ 事实上，这只是将 Composer 创建的 autoload.php 文件包含在我们的应用程序中的问题，如以下代码段所示。

require_once './vendor/autoload.php';

如何使用容器

在本节中，我们将通过一个示例来演示如何将服务注入到容器中。 容器应充当中央存储库，其中包含应用程序中的所有服务。 稍后，我们可以根据需要使用容器来获取服务。

首先，让我们继续在 src/DemoService.php 中使用以下内容定义一个非常基本的服务。

src/DemoService.php

namespace Services;
 
class DemoService
{
  public function helloWorld()
  {
    return "Hello World!\n";
  }
}

这是一个非常简单的服务，暂时只是实现了 helloWorld 方法。

接下来，继续在应用程序的根目录中创建包含以下内容的 basic_container.php 文件。

basic_container.php

require_once './vendor/autoload.php';
use Symfony\Component\DependencyInjection\ContainerBuilder;
 
// init service container 
$containerBuilder = new ContainerBuilder();
 
// add service into the service container 
$containerBuilder->register('demo.service', '\Services\DemoService');
 
// fetch service from the service container 
$demoService = $containerBuilder->get('demo.service');
echo $demoService->helloWorld();

首先，我们使用 new ContainerBuilder() 构造函数实例化了 ContainerBuilder 对象。 接下来，我们使用 ContainerBuilder 对象的 register 方法将我们的自定义服务 \Services\DemoService 注入到容器中。 demo.service 充当我们服务的别名。

最后，我们使用了 ContainerBuilder 对象的 get 方法从容器中获取我们的服务并使用它来调用 helloWorld 方法。

所以这是如何使用容器的基本演示。 在下一节中，我们将扩展此示例以探索如何使用容器解决类依赖关系。

一个真实的例子

在本节中，我们将创建一个示例来演示如何使用 DependencyInjection 组件解析类依赖项。

为了演示它，我们将创建一个新服务 DependentService，它需要在上一节中创建的 DemoService 服务作为依赖项。 因此，我们将看到 DemoService 服务如何在 DependentService 服务实例化时作为依赖自动注入。

继续使用以下内容创建 src/DependentService.php 文件来定义 DependentService 服务。

src/DependentService.php

namespace Services;
 
class DependentService
{
  private $demo_service;
 
  public function __construct(\Services\DemoService $demoService)
  {
    $this->demo_service = $demoService;
  }
 
  public function helloWorld()
  {
    return $this->demo_service->helloWorld();
  }
}

如大家所见，需要 \Services\DemoService 服务才能实例化 DependentService 服务。

接下来，继续创建包含以下内容的 di_container.php 文件。

di_container.php

require_once './vendor/autoload.php';
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;
 
// init service container 
$containerBuilder = new ContainerBuilder();
 
// add demo service into the service container 
$containerBuilder->register('demo.service', '\Services\DemoService');
 
// add dependent service into the service container 
$containerBuilder->register('dependent.service', '\Services\DependentService')
                 ->addArgument(new Reference('demo.service'));
 
// fetch service from the service container 
$dependentService = $containerBuilder->get('dependent.service');
echo $dependentService->helloWorld();

我们使用相同的注册方法将我们的自定义服务 \Services\DependentService 注入到容器中。

除此之外，我们还使用了 addArgument 方法来通知容器有关 DependentService 服务的依赖性。 我们使用 Reference 类来通知容器它需要在 dependent.service 服务实例化时注入 demo.service 服务。 这样，一个依赖项就会根据需要自动注入！

最后，我们使用 ContainerBuilder 对象的 get 方法从 ContainerBuilder 对象中获取 dependent.service 服务，并使用它调用 helloWorld 方法。

通过这种方式，DependencyInjection 组件提供了一种标准方法来实例化对象并在我们的应用程序中注入依赖项。

如何使用 YAML 文件动态加载服务

在本节中，我们将探讨如何从 YAML 文件动态加载服务。 基本上，我们将更新上一节中讨论的示例。

除了 DependencyInjection 组件之外，我们还需要另外两个 Symfony 组件来实现 YAML 示例——Config 和 Yaml。 回想一下，我们已经在安装和配置部分安装了这两个组件以及 DependencyInjection 组件本身。 所以我们可以开始了！

继续并在应用程序的根目录中创建包含以下内容的 services.yaml 文件。

services.yaml

services:
    demo.service:
        class:     \Services\DemoService
    dependent.service:
        class:     \Services\DependentService
        arguments: ["@demo.service"]

如大家所见，使用 YAML 语法定义服务非常简单。 要定义服务的依赖项，您需要使用参数键。

接下来，继续创建包含以下内容的 di_yaml_container.php 文件。

di_yaml_container.php

require_once './vendor/autoload.php';
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
 
// init service container 
$containerBuilder = new ContainerBuilder();
 
// init yaml file loader 
$loader = new YamlFileLoader($containerBuilder, new FileLocator(__DIR__));
 
// load services from the yaml file 
$loader->load('services.yaml');
 
// fetch service from the service container 
$serviceOne = $containerBuilder->get('dependent.service');
echo $serviceOne->helloWorld();

除了我们从 services.yaml 文件加载服务而不是在 PHP 代码本身中定义服务外，一切都几乎相同。 这允许动态定义应用程序依赖性。

如何注入惰性服务

在某些情况下，我们想注入惰性服务。 有时，我们有一个实例化起来非常繁重的服务。 所以你只希望在真正需要的时候注入这样的服务，而不是在那之前。 这个问题的答案是惰性服务。

但这究竟是如何工作的呢？ 事实上，当我们配置惰性服务时，并没有注入实际的服务，而是注入了服务的代理。 从表面上看，代理服务就像实际服务一样，但是一旦您开始与代理服务交互，实际服务就会被实例化。

要使用惰性服务，我们需要安装 symfony/proxy-manager-bridge 包。 让我们首先这样做。

$ composer require symfony/proxy-manager-bridge

接下来，我们将修改 di_container.php 示例以了解如何使用代理管理器来创建和注入代理服务。

继续将 di_container.php 文件的代码替换为以下内容。

di_container.php

require_once './vendor/autoload.php';
use ProxyManager\Factory\LazyLoadingValueHolderFactory;
use ProxyManager\Proxy\LazyLoadingInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
// code for creating proxy starts 
$factory     = new LazyLoadingValueHolderFactory();
$initializer = function (& $wrappedObject, LazyLoadingInterface $proxy, $method, array $parameters, & $initializer) {
    global $containerBuilder;
    $initializer   = null; // disable initialization 
    $wrappedObject = $containerBuilder->get('demo.service'); // fill your object with values here 
    return true; // confirm that initialization occurred correctly 
};
$proxy = $factory->createProxy('\Services\DemoService', $initializer);
// code for creating proxy ends 
global $containerBuilder;
$containerBuilder = new ContainerBuilder();
$containerBuilder->register('demo.service', '\Services\DemoService');
$containerBuilder->register('dependent.service', '\Services\DependentService')->addArgument($proxy);
$dependentService = $containerBuilder->get('dependent.service');
echo $dependentService->helloWorld();

首先，我们创建了 LazyLoadingValueHolderFactory 类的一个实例。 接下来，我们使用了此类的 createProxy 方法来定义如何创建 \Services\DemoService 类的实例。 createProxy 方法的第二个参数是一个匿名函数，当需要实例化类的实际实例而不是代理对象时将调用该函数。 因此，匿名函数处理创建实际实例的逻辑。

除此之外，它几乎是一样的。 创建代理实例后，我们将在 addArgument 方法中传递它，而不是使用 Reference 类创建实例。

这种方法的好处是，每当我们创建 \Services\DependentService 类的实例时，它不会创建 \Services\DemoService 类的实际对象，而是创建一个代理对象。 \Services\DemoService 类的实际对象只有在您调用它的任何方法时才会创建。

为了确认这一点，我们可以转储 $dependentService 对象，我们应该会看到类似这样的内容。

Services\DependentService Object
(
    [demo_service:Services\DependentService:private] => ProxyManagerGeneratedProxy\__PM__\Services\DemoService\Generatedccdf8241e892da36c12500ed72d82829 Object
        (
            [valueHoldera1fd8:ProxyManagerGeneratedProxy\__PM__\Services\DemoService\Generatedccdf8241e892da36c12500ed72d82829:private] => 
            [initializere3996:ProxyManagerGeneratedProxy\__PM__\Services\DemoService\Generatedccdf8241e892da36c12500ed72d82829:private] => Closure Object
                (
                    [parameter] => Array
                        (
                            [&$wrappedObject] => <required>
                            [$proxy] => <required>
                            [$method] => <required>
                            [$parameters] => <required>
                            [&$initializer] => <required>
                        )
                )
        )
)

如大家所见，它创建了代理对象而不是实际的 \Services\DemoService 对象。

如果你没有使用代理方法，输出会是这样的。

Services\DependentService Object
(
    [demo_service:Services\DependentService:private] => Services\DemoService Object
        (
        )
)

如大家所见，它创建了 \Services\DemoService 类的一个实例。 这就是延迟加载服务的工作原理！

结论

Symfony DependencyInjection 组件在本教程中占据了中心位置。 我们看到了如何安装和配置 DependencyInjection，以及一些如何使用它的真实示例。

我真的对 Symfony 框架的解耦组件感到着迷和兴奋，我们可以为应用程序挑选和选择这些组件。 将它们插入我们的代码，它们就可以正常工作！ 总而言之，我只能看到这种框架方法对我们的 PHP 社区的好处。