动态服务使用

Question

我想使用服务处理表中的数据，并在记录中指定要使用的正确服务。所以假设我有一个包含以下数据的表

| id | value1  | value2  | service        | result |
|----|---------|---------|----------------|--------|
| 1  | string1 | string2 | string_version |        |
| 2  | int1    | int2    | int_version    |        |
| 3  | string3 | string3 | string_version |        |

我想处理我的父服务calculator中的每一行，它循环每条记录并根据service的值获取服务，服务使用value1和value2计算结果然后存储结果在result

目前我已经创建了 calculator 服务，其中一个参数是服务容器 - 然后我可以使用 get 来获得我需要的实际服务：

class Calculator {
  private $container;

  public function __construct(ContainerInterface $container) {
     $this->container = $container;
  }

  public function calcResult($record) {
    $service = $this->container->get($record->getService());
    $result = $service->process($record->getValue1(),$result->getValue2());
    $record->setResult($result);
  }

}

但是......这不是非常可测试的 - 因为我在整个服务容器中传递。将来，我还希望能够添加新服务 - 因此第 3 方可以添加具有特定服务名称的捆绑包并使用它来处理表中的记录

这是我尝试做的一个非常简化的版本 - 但能够从另一个服务动态传递/获取服务是我想做的。

如何修改此代码，以便我可以根据数据库中的动态值获取服务并允许第 3 方添加“处理”服务 - 当然会实现接口 - 所以确保存在正确的方法

Answer 1

你有两个明显的候选人：

• service locator（在 OOP 中被视为反模式）
• tagged services（策略模式）

我个人（将始终）在这种情况下使用标记服务（策略模式），但仍会为每个示例提供示例，因此由您决定。

注意：如果您使用如下所示的服务定位器，您的服务中会出现重复和一些难看的代码。

服务定位器

interface ServiceLocatorInterface
{
    public function locate(string $id);
}

-

use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Symfony\Component\DependencyInjection\ServiceSubscriberInterface;

class ServiceLocator implements ServiceLocatorInterface, ServiceSubscriberInterface
{
    private $locator;

    public function __construct(ContainerInterface $locator)
    {
        $this->locator = $locator;
    }

    public static function getSubscribedServices()
    {
        return [
            'string_version' => StringCalculator::class,
            'int_version' => IntCalculator::class,
        ];
    }

    public function locate(string $id)
    {
        if (!$this->locator->has($id)) {
            throw new ServiceLocatorException('Service was not found.');
        }

        try {
            return $this->locator->get($id);
        } catch (ContainerExceptionInterface $e) {
            throw new ServiceLocatorException('Failed to fetch service.');
        }
    }
}

-

class StringCalculator
{
    public function calculate($value1, $value2)
    {
        return $value1.' - '.$value2;
    }
}

-

class IntCalculator
{
    public function calculate($value1, $value2)
    {
        return $value1 + $value2;
    }
}

用法：

class YourService
{
    private $serviceLocator;

    public function __construct(\App\ServiceLocatorInterface $serviceLocator)
    { 
        $this->serviceLocator = $serviceLocator;
    }

    public function yourMethod()
    {
        /** @var StringCalculator $calculator */
        $calculator = $this->serviceLocator->locate('string_version');
        $result = $calculator->calculate('1', '2'); // result: 1 - 2

        /** @var IntCalculator $calculator */
        $calculator = $this->serviceLocator->locate('int_version');
        $result = $calculator->calculate(1, 2); // result: 3
    }
}

标记服务

service:
    App\Strategy\Calculator:
        arguments: [!tagged calculator]

    App\Strategy\StringCalculatorStrategy:
        tags:
            - { name: calculator }

    App\Strategy\IntCalculatorStrategy:
        tags:
            - { name: calculator }

-

use Traversable;

class Calculator
{
    private $calculators;

    public function __construct(Traversable $calculators)
    {
        $this->calculators = $calculators;
    }

    public function calculate(string $serviceName, $value1, $value2)
    {
        /** @var CalculatorStrategyInterface $calculator */
        foreach ($this->calculators as $calculator) {
            if ($calculator->canProcess($serviceName)) {
                return $calculator->process($value1, $value2);
            }
        }
    }
}

-

interface CalculatorStrategyInterface
{
    public function canProcess(string $serviceName): bool;

    public function process($value1, $value2);
}

-

class StringCalculatorStrategy implements CalculatorStrategyInterface
{
    public function canProcess(string $serviceName): bool
    {
        return $serviceName === 'string_version';
    }

    public function process($value1, $value2)
    {
        return $value1.' '.$value2;
    }
}

-

class IntCalculatorStrategy implements CalculatorStrategyInterface
{
    public function canProcess(string $serviceName): bool
    {
        return $serviceName === 'int_version';
    }

    public function process($value1, $value2)
    {
        return $value1 + $value2;
    }
}

用法：

class YourService
{
    private $calculator;

    public function __construct(\App\Strategy\Calculator $calculator)
    { 
        $this->calculator = $calculator;
    }

    public function yourMethod()
    {
        // result: 1 - 2
        $result = $this->calculator->calculate('string_version', 1, 2);
        // result: 3
        $result = $this->calculator->calculate('int_version', 1, 2);
    }
}