Symfony Dependency Injection #[Attributes]

Il y a bien longtemps, dans une version de Symfony lointaine, très lointaine, les services (qui sont des objets chargés de faire un travail) devaient être configurés dans des fichiers YAML ou XML séparés. Les développeurs branchés appelaient ça « câbler un service ».
Dans ces fichiers, on créait un identifiant de service, on référençait notre classe de service, puis on indiquait les identifiants de service, paramètres ou valeurs scalaires nécessaires.
Même si cela fonctionnait très bien, c’était un peu lourd. Chaque fois qu’on voulait ajouter, supprimer ou modifier les arguments d’un service, il fallait plonger dans un autre fichier de configuration pour tout mettre à jour.

Dans une version suivante de Symfony — encore lointaine aujourd’hui — ils ont introduit quelque chose appelé « autowiring »
Cela nous permettait de simplement créer un objet service en PHP, et tous les autres services nécessaires étaient injectés automatiquement. Il suffisait d’ajouter un type hint sur la classe ou l’interface du service.
C’était un énorme pas en avant, mais on devait encore configurer certains cas dans du YAML ou du XML, même pour des scénarios un peu plus avancés (comme injecter des valeurs scalaires depuis un paramètre).
On passait clairement moins de temps dans les fichiers de configuration, mais ça ne les supprimait pas complètement.

#[AutowireLocator]

C’est un attribut PHP de Symfony qui permet d’injecter automatiquement un service locator (un mini-container), contenant un ensemble de services que l’on définit sous forme de tableau clé/classe.

Il permet de récupérer dynamiquement des services via leurs clés, sans avoir à injecter chaque service individuellement.

#[AutowireLocator([
    'pdf' => PdfGenerator::class,
    'csv' => CsvGenerator::class,
])]
private ContainerInterface $formats;

$this->formats->get('pdf')->generate();

#[AutoconfigureTag]

C’est un attribut PHP qui permet de taguer automatiquement une classe quand elle est enregistrée comme service. Pas besoin d’aller l’écrire dans services.yaml.

use Symfony\Component\DependencyInjection\Attribute\AutoconfigureTag;

#[AutoconfigureTag('app.button')]
class VolumeUpButton
{
    // ...
}

#[AsTaggedItem]

C’est un attribut PHP qui ajoute des métadonnées à un service tagué. En gros : tu dis « je veux que ce service tagué soit accessible avec ce nom (clé) ».

use Symfony\Component\DependencyInjection\Attribute\AsTaggedItem;

#[AsTaggedItem('volume-up')]
class VolumeUpButton
{
    public function press() { /* ... */ }
}

#[AutowireIteraror]

Injecte une liste de services tagués, dans l’ordre, pour les traiter tous un par un.

#[AutowireIterator(tag: 'app.handler')]
private iterable $handlers;

foreach ($this->handlers as $handler) {
    $handler->handle($data);
}

Quand tu utilises #[AutowireIterator], Symfony injecte les services dans un tableau indexé numériquement par défaut. Mais si tu veux un tableau clé/valeur, où chaque service est identifié par une clé personnalisée, tu peux utiliser l’option indexAttribute.

use Symfony\Component\DependencyInjection\Attribute\AsTaggedItem;

#[AsTaggedItem(index: 'csv')]
#[AutoconfigureTag('app.exporter')]
class CsvExporter implements ExporterInterface {}

#[AsTaggedItem(index: 'pdf')]
#[AutoconfigureTag('app.exporter')]
class PdfExporter implements ExporterInterface {}


use Symfony\Component\DependencyInjection\Attribute\AutowireIterator;

class ExportManager
{
    public function __construct(
        #[AutowireIterator(tag: 'app.exporter', indexAttribute: 'index')]
        private iterable $exporters
    ) {}

    public function export(string $format, $data)
    {
        $this->exporters[$format]->export($data);
    }
}

#[Alias]

C’est un attribut PHP qui permet de créer un alias de service automatiquement.
Tu lies une interface à une implémentation, sans devoir le faire à la main dans services.yaml.

C’est l’équivalent de :

App\SomeInterface: '@App\SomeImplementation'

use Symfony\Component\DependencyInjection\Attribute\AsAlias;

#[AsAlias(SomeInterface::class)]
class MyService implements SomeInterface
{
    // ...
}

#[AsDecorator]

C’est un attribut PHP qui permet de créer un service décorateur directement en PHP (plus besoin de YAML). Il te permet d’envelopper un service existant, pour le modifier, l’étendre ou l’observer (ex : ajouter du logging, du cache, etc.)

#[AsDecorator(ButtonRemote::class)]
class RateLimitingRemote implements RemoteInterface
{
    public function __construct(
        private RateLimiter $rateLimiter,
        private RemoteInterface $inner,
    ) {
    }

}

#[Target]

C’est un attribut PHP que tu peux utiliser pour spécifier le nom exact d’un service à injecter dans un constructeur, quand il y a ambiguïté. Il dit à Symfony : « Pour cet argument, injecte ce service précis« 

use Symfony\Component\DependencyInjection\Attribute\Target;

class ReportManager
{
    public function __construct(
        #[Target('App\PdfExporter')]
        private ExporterInterface $pdfExporter,

        #[Target('App\CsvExporter')]
        private ExporterInterface $csvExporter,
    ) {}

    public function run()
    {
        echo $this->pdfExporter->export();
    }
}

#[When]

C’est un attribut PHP qui permet de charger un service (ou config) seulement dans un environnement précis : dev, prod, test, etc.

use Symfony\Component\DependencyInjection\Attribute\When;

#[When('dev')]
class DebugMailer
{
    public function send(): void
    {
        dump('fake mail sent!');
    }
}

#[Exclude]

C’est un attribut Symfony qui te permet de ne pas enregistrer un service automatiquement, même s’il est dans un dossier autowiré/autoconfiguré. En gros : « Ignore ce service, je ne veux pas qu’il soit enregistré automatiquement.« 

use Symfony\Component\DependencyInjection\Attribute\Exclude;

#[Exclude]
class SomeHelperClass
{
    public function help() {
        // ...
    }
}

#[Lazy]

C’est un attribut PHP que tu peux mettre sur une classe ou sur un paramètre de constructeur Il indique à Symfony : « Instancie ce service seulement si on l’utilise. »

#[Lazy]
class SlowService {
    public function __construct() {
        dump('Je suis instancié');
    }
}

#[AutowireServiceClosure]

C’est un attribut PHP introduit par Symfony pour injecter un service sous forme de Closure grâce à l’autowiring. Il permet de créer des injections différées (lazy), tout en gardant la logique simple et typée via PHP 8+

use Symfony\Component\DependencyInjection\Attribute\AutowireServiceClosure;

class MyService
{
    public function __construct(
        #[AutowireServiceClosure(SomeHeavyService::class)]
        private \Closure $heavyServiceFactory
    ) {}

    public function doSomething(): void
    {
        $service = ($this->heavyServiceFactory)(); // Instanciation au moment voulu
        $service->process();
    }
}

Vous avez plus d’informations ici https://symfony.com/doc/current/reference/attributes.html#dependency-injection