Inject service based on dynamic value in Symfony

Question

I have 2 services, BlueWorkerService and YellowWorkerService, both implementing the same interface, WorkerServiceInterface. Each of these services use the same entities but with different required logic.

I need to inject one of, but not both, of these classes and use them in ProcessorService so that the interface methods are called using on correct Worker. Which worker service to use is dependent on which Worker is currently being processed. I'll break it down:

Class WorkerProcessor {

  private $workerService;

  public function __construct(WorkerServiceInterface $workerServiceInterface)
  {
    $this->workerService = $workerServiceInterface;
  }

  public function getMixedColourWithRed() {
    return $this->workerService->mixWithRed();
  }
}

The worker service that is being used would be based on whether the worker being processed has the colour property of Blue or Yellow.

I know I can probably use a Factory to achieve this as described here but my problem is how to tell the factory which Worker colour I am processing?

Running on Symfony 3.4

If you need more info, just ask and I will update the question.

user_8003007 · Answer

NOTE: I'm using Symfony 4.3.1. I'll post it like that, then I'll help you to move all code from this architecture to Symfony 3.4.

I'm using a similar concept to load different classes in my project. Let me explain first, then I'll add code under this text.

Firstly, I'm loading a custom compiler pass under src/Kernel.php (your file is app/AppKernel.php):

/**
 * {@inheritDoc}
 */
public function build(ContainerBuilder $container)
{
    $container->addCompilerPass(new BannerManagerPass());
}

BannerManagerPass its created under src/DependencyInjection/Compiler (in your case should be src/BUNDLE/DependencyInjection/Compiler`).

class BannerManagerPass implements CompilerPassInterface
{
    /**
     * {@inheritDoc}
     */
    public function process(ContainerBuilder $container)
    {
        if (!$container->has(BannerManager::class)) {
            return;
        }

        $definition     = $container->findDefinition(BannerManager::class);
        $taggedServices = $container->findTaggedServiceIds('banner.process_banners');

        foreach (array_keys($taggedServices) as $id) {
            $definition->addMethodCall('addBannerType', [new Reference($id)]);
        }
    }
}

As you see, this class should implement CompilerPassInterface. You can observe that I'm looking for specific services tagged as banner.process_banners. I'll show how I tagged services a little bit later. Then, I'm calling addBannerType method from BannerManager.

App\Service\BannerManager.php: (in your case src/BUNDLE/Service/BannerManager.php)

class BannerManager
{
    /**
     * @var array
     */
    private $bannerTypes = [];

    /**
     * @param BannerInterface $banner
     */
    public function addBannerType(BannerInterface $banner)
    {
        $this->bannerTypes[$banner->getType()] = $banner;
    }

    /**
     * @param string $type
     *
     * @return BannerInterface|null
     */
    public function getBannerType(string $type)
    {
        if (!array_key_exists($type, $this->bannerTypes)) {
            return null;
        }

        return $this->bannerTypes[$type];
    }

    /**
     * Process request and return banner.
     *
     * @param string  $type
     * @param Server  $server
     * @param Request $request
     *
     * @return Response
     */
    public function process(string $type, Server $server, Request $request)
    {
        return $this->getBannerType($type)->process($request, $server);
    }
}

This class has a custom method (created by me) called process(). You can name it whatever you want it, but I think that's pretty verbose. All parameters are sent by me, so don't mind. You can send whatever you want.

Now we have our Manager and compiler pass is set. It's time to set our banner types (based on my example) and tag them!

My banner types are under src/Service/Banner/Types (in your case should be src/BUNDLE/Service/WhateverYouWant/Type. This does not matter! You can change it later from services.yaml).

These types are implementing my BannerInterface. It does not matter the code under the class in this instance. One more thing that I should warn you! You should see that under BannerManager, inside the addBannerType() I'm calling $banner->getType(). This is one method inherited from BannerInterface in my case and it has a unique string (in my example I have three banner types: small, normal, large). This method can have any name, but don't forget to update it as well in your manager.

We are almost ready! We should tag them, then we are ready to try them!

Go to your services.yaml and add these lines:

  App\Service\Banner\Types\:
    resource: '../src/Service/Banner/Types/'
    tags: [banner.process_banners]

Please see the tag!

Whatever I want to show a custom banner, I'm using a simple URL with $_GET where I keep my banner type, then I load it like this:

public function view(?Server $server, Request $request, BannerManager $bannerManager)
{
   ...

    return $bannerManager->getBannerType($request->query->get('slug'))->process($request, $server);
}

Inject service based on dynamic value in Symfony

1 Answers