Symfony 4. Comment accéder au service depuis le contrôleur sans injection de dépendances?

Pour toute situation «plusieurs instances du même type par clé», vous pouvez utiliser un tableau câblé automatiquement.

1. Services de découverte automatique avec espace de noms App \

use Symplify\PackageBuilder\DependencyInjection\CompilerPass\AutowireArrayParameterCompilerPass;

final class AppKernel extends Kernel
{
    protected function build(ContainerBuilder $containerBuilder): void
    {
        $containerBuilder->addCompilerPass(new AutowireArrayParameterCompilerPass);
    }
}

2. Nécessite un tableau autowired dans le constructeur

<?php

namespace App\Controller\Api;

use App\Service\Cases\DieselCaseService

final class AccountController
{
    /**
     * @var CaseInterface[]
     */
    private $cases;

    /**
     * @param CaseInterface[] $cases
     */
    public function __construct(array $cases)
    {
        foreach ($cases as $case) {
            $this->cases[$case->getName()] = $cases;
        }
    }

    public function someAction(): void
    {
        $dieselCase = $this->cases['diesel']; // @todo maybe add validation for exisiting key
        $dieselCase->anyMethod();
    }
}

3. Enregistrer le passage du compilateur dans le noyau

La fonctionnalité tableau autowired n'est pas dans le noyau de Symfony. C'est possible grâce aux passes du compilateur. Vous pouvez écrire le vôtre ou utiliser celui-ci:

services:
    _defaults:
        autowire: true

    App\:
        resource: ../src

C'est tout! :)

Je l'utilise sur tous mes projets et cela fonctionne comme un charme.

En savoir plus sur post sur les tableaux autowired a > J'ai écrit.

J'ai créé un service wrapper

public function saveRegisterData(Request $request, AccountService $accountService, ServiceFactory $serviceFactory) 
{
.
.
.

    if (!$serviceFactory->hasService('case_service.'.$type)) {
        throw new \LogicException("no valid case_service found");
    }

    /**
    * @var $caseService \App\Service\Cases\CaseInterface
    */
    $caseService = $serviceFactory->getService('case_service.' . $type);

.
.
.
}

puis j'injecte ce service dans le contrôleur

<?php
namespace App;

use Symfony\Component\DependencyInjection\ContainerInterface;

class ServiceFactory
{

    /** @var ContainerInterface */
    private $container;


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

    public function getService($alias)
    {
        return $this->container->get($alias);
    }

    /**
     * @param $alias
     * @return bool
     */
    public function hasService($alias)
    {
        return $this->container->has($alias);
    }
}

Un code de dimanche après-midi pluvieux. Cette question est fondamentalement un doublon de plusieurs autres questions mais il y a suffisamment de pièces mobiles pour que je suppose qu'il soit utile de fournir des solutions spécifiques.

Commencez par définir les cas juste pour vous assurer que nous sommes tous sur la même page: p>

class CaseController extends AbstractController
{
    public function action2(CaseLocator $caseLocator)
    {
        $case = $caseLocator->get(CarloanCaseService::class);

        return new Response(get_class($case));
    }

Le moyen le plus simple de répondre à la question est d'ajouter les services de cas directement au conteneur du contrôleur:

# src/Kernel.php
// Make the kernel a compiler pass by implementing the pass interface
class Kernel extends BaseKernel implements CompilerPassInterface 
{
    protected function build(ContainerBuilder $container)
    {
        // Tag all case interface classes for later use
        $container->registerForAutoconfiguration(CaseInterface::class)->addTag('case');
    }
    // and this is the actual compiler pass code
    public function process(ContainerBuilder $container)
    {
        // Add all the cases to the case locator
        $caseIds = [];
        foreach ($container->findTaggedServiceIds('case') as $id => $tags) {
            $caseIds[$id] = new Reference($id);
        }
        $caseLocator = $container->getDefinition(CaseLocator::class);
        $caseLocator->setArguments([$caseIds]);
    }

La seule chose J'ai changé car votre question utilise les noms de classe pour les identifiants de service au lieu de quelque chose comme «case_service.diesel». Vous pouvez bien sûr modifier le code pour utiliser vos identifiants, mais les noms de classe sont plus standard. Notez qu'aucune entrée dans services.yaml n'est nécessaire pour que cela fonctionne.

Il y a quelques problèmes avec le code ci-dessus qui peuvent ou non être un problème. La première est que seul le seul contrôleur aura accès aux services de cas. Ce qui peut être tout ce dont vous avez besoin. Le deuxième problème potentiel est que vous devez répertorier explicitement tous vos services de cas. Ce qui peut être correct, mais il peut être intéressant de sélectionner automatiquement les services qui implémentent l'interface de cas.

Ce n'est pas difficile à faire mais cela nécessite de suivre toutes les étapes.

Démarrer définir un localisateur de cas:

use Symfony\Component\DependencyInjection\ServiceLocator;

class CaseLocator extends ServiceLocator
{

}

Nous avons maintenant besoin de code pour trouver tous les services de cas et les injecter dans le localisateur. Il existe plusieurs approches, mais la plus simple est peut-être d'utiliser la classe Kernel.

class CaseController extends AbstractController
{
    public function action1()
    {
        $case = $this->get(DieselCaseService::class);

        return new Response(get_class($case));
    }
    // https://symfony.com/doc/current/service_container/service_subscribers_locators.html#including-services
    public static function getSubscribedServices()
    {
        return array_merge(parent::getSubscribedServices(), [
            // ...
            DieselCaseService::class => DieselCaseService::class,
            CarloanCaseService::class => CarloanCaseService::class,
        ]);
    }
}

Si vous suivez toutes les étapes ci-dessus, vous pouvez injecter votre localisateur de cas dans n'importe quel contrôleur (ou autre service) qui en a besoin:

interface CaseInterface { }
class DieselCaseService implements CaseInterface {}
class CarloanCaseService implements CaseInterface{}

Et encore une fois, il n'est pas nécessaire d'apporter des modifications à votre services.yaml pour que tout cela fonctionne.