Symfony 7: les services
Introduction aux services dans Symfony
1. Qu'est-ce qu'un service ?
Un service est une classe qui effectue une tâche spécifique, généralement utilisée pour
centraliser des fonctionnalités réutilisables comme l'envoi d'emails, la gestion des utilisateurs,
ou l'accès à des API externes. Symfony utilise un conteneur de services (ou conteneur
d'injection de dépendances) pour gérer et fournir ces services.
2. Pourquoi utiliser des services ?
● Centralisation des fonctionnalités réutilisables.
● Favorise l'injection de dépendances et facilite le test.
● Réduit le couplage entre les composants.
Création et gestion des services
1. Création d'un service simple
Étape 1 : Créer une classe de service
// src/Service/EmailService.php
namespace App\Service;
class EmailService
{
public function sendEmail(string $recipient, string $subject, string
$body): void
{
// Logique pour envoyer un email
echo "Email envoyé à $recipient avec le sujet $subject";
}
}
Étape 2 : Utiliser le service dans un contrôleur
Symfony détecte automatiquement les services si leur chemin respecte la convention PSR-4.
// src/Controller/EmailController.php
namespace App\Controller;
use App\Service\EmailService;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
class EmailController extends AbstractController
{
private EmailService $emailService;
public function __construct(EmailService $emailService)
{
$this->emailService = $emailService;
}
public function sendEmail(): Response
{
$this->emailService->sendEmail('
[email protected]', 'Bienvenue',
'Merci de nous rejoindre!');
return new Response('Email envoyé avec succès.');
}
}
2. Configuration des services
Fichier de configuration des services
Symfony utilise le fichier config/services.yaml pour configurer les services.
Exemple :
# config/services.yaml
services:
App\Service\EmailService:
arguments:
$mailer: '@mailer'
3. Injection de dépendances
Injection via le constructeur
C'est la méthode la plus courante. Les dépendances sont injectées dans le constructeur de la
classe.
Exemple :
// src/Service/EmailService.php
namespace App\Service;
use Symfony\Component\Mailer\MailerInterface;
class EmailService
{
private MailerInterface $mailer;
public function __construct(MailerInterface $mailer)
{
$this->mailer = $mailer;
}
public function sendEmail(string $recipient, string $subject, string
$body): void
{
// Utilise $this->mailer pour envoyer un email
}
}
Injection dans les méthodes
Les dépendances peuvent être injectées directement dans les méthodes si elles ne sont
utilisées qu'à certains moments.
Exemple :
// src/Controller/EmailController.php
namespace App\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use App\Service\EmailService;
class EmailController extends AbstractController
{
public function sendEmail(EmailService $emailService): Response
{
$emailService->sendEmail('
[email protected]', 'Bienvenue', 'Merci de
nous rejoindre!');
return new Response('Email envoyé avec succès.');
}
}
4. Services avec des paramètres
Vous pouvez définir des paramètres dans le conteneur et les injecter dans vos services.
Définir un paramètre
# config/services.yaml
parameters:
app.default_sender: '[email protected]'
Utiliser le paramètre dans un service
// src/Service/EmailService.php
namespace App\Service;
class EmailService
{
private string $defaultSender;
public function __construct(string $defaultSender)
{
$this->defaultSender = $defaultSender;
}
public function sendEmail(string $recipient, string $subject, string
$body): void
{
echo "Envoyé par {$this->defaultSender} à $recipient avec le sujet
$subject";
}
}
Configuration dans services.yaml
services:
App\Service\EmailService:
arguments:
$defaultSender: '%app.default_sender%'
Les types de services
1. Services privés et publics
● Par défaut, les services sont privés dans Symfony 7. Ils ne peuvent être utilisés que via
l’injection de dépendances.
● Un service peut être rendu public si nécessaire, mais cela est déconseillé.
Exemple :
services:
App\Service\PublicService:
public: true
2. Services autowirés et autoconfigurés
● Autowiring : Symfony résout automatiquement les dépendances par leur type.
● Autoconfiguration : Symfony applique automatiquement les configurations comme les
tags.
Ces fonctionnalités sont activées par défaut.
Utilisation avancée des services
1. Les alias de services
Les alias permettent de créer des noms alternatifs pour des services.
Exemple :
services:
app.email_service: '@App\Service\EmailService'
2. Services partagés vs non partagés
Par défaut, les services sont partagés, c’est-à-dire qu’une seule instance est utilisée.
Vous pouvez définir un service comme non partagé pour obtenir une nouvelle instance à
chaque fois.
Exemple :
services:
App\Service\NonSharedService:
shared: false
3. Tags pour les services
Les tags permettent d’ajouter des métadonnées aux services, souvent utilisées pour
l’intégration avec des systèmes externes ou des extensions Symfony.
Exemple : Tag pour un événement
services:
App\EventListener\UserEventListener:
tags:
- { name: kernel.event_listener, event: user.registered }
