Symfony

Un framework PHP puissant et flexible qui permet de développer des applications web robustes, évolutives et maintenables.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce que Symfony ?

Imaginez que vous souhaitiez construire un gratte-ciel. Vous pourriez commencer par fabriquer chaque brique, chaque poutre, chaque circuit électrique... ou bien utiliser des éléments préfabriqués et éprouvés pour vous concentrer sur l'architecture et les fonctionnalités spécifiques de votre bâtiment.

Symfony est comme une collection de ces éléments préfabriqués pour le développement web. C'est un framework PHP qui fournit des outils robustes et flexibles permettant aux développeurs de créer rapidement des applications web sophistiquées tout en respectant les meilleures pratiques du secteur.

Pourquoi Symfony est si apprécié ?

Fiabilité

Utilisé par des milliers d'entreprises dont certaines des plus grandes au monde, Symfony est éprouvé pour des applications critiques.

Flexibilité

Utiliser ce dont vous avez besoin, quand vous en avez besoin - de quelques composants à un framework complet.

En résumé, Symfony permet aux entreprises de toutes tailles de construire des applications web robustes et évolutives, qu'il s'agisse d'un simple site d'entreprise, d'une application e-commerce complexe ou d'un système d'information critique.

Pour les développeurs

Fonctionnement technique

Symfony est un framework PHP qui suit le modèle MVC (Modèle-Vue-Contrôleur) et exploite les dernières fonctionnalités de PHP. Il est conçu autour d'un système de composants réutilisables et d'un puissant conteneur d'injection de dépendances, rendant le code modulaire et testable.

Les concepts fondamentaux

Contrôleurs et Routage

Les contrôleurs gèrent les requêtes HTTP entrantes et retournent des réponses. Le système de routage permet de mapper des URLs à des actions de contrôleurs.

ProductController.php

<?php
// src/Controller/ProductController.php
namespace App\Controller;

use App\Entity\Product;
use App\Repository\ProductRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class ProductController extends AbstractController
{
    /**
     * @Route("/products", name="product_list", methods={"GET"})
     */
    public function index(ProductRepository $productRepository): Response
    {
        $products = $productRepository->findAll();
        
        return $this->render('product/index.html.twig', [
            'products' => $products,
        ]);
    }
    
    /**
     * @Route("/products/{id}", name="product_show", methods={"GET"})
     */
    public function show(Product $product): Response
    {
        // Grâce au ParamConverter, Symfony récupère automatiquement
        // le produit à partir de l'ID dans l'URL
        
        return $this->render('product/show.html.twig', [
            'product' => $product,
        ]);
    }
}

Entités et ORM Doctrine

Symfony utilise Doctrine comme ORM (Object-Relational Mapping) pour interagir avec la base de données comme MySQL ou PostgreSQL en utilisant des objets PHP plutôt que des requêtes SQL directes.

Product.php Entity

<?php
// src/Entity/Product.php
namespace App\Entity;

use App\Repository\ProductRepository;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;

/**
 * @ORM\Entity(repositoryClass=ProductRepository::class)
 */
class Product
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(type="string", length=255)
     * @Assert\NotBlank()
     * @Assert\Length(min=3, max=255)
     */
    private $name;

    /**
     * @ORM\Column(type="text", nullable=true)
     */
    private $description;

    /**
     * @ORM\Column(type="decimal", precision=10, scale=2)
     * @Assert\NotBlank()
     * @Assert\Positive()
     */
    private $price;

    /**
     * @ORM\Column(type="datetime")
     */
    private $createdAt;

    public function __construct()
    {
        $this->createdAt = new \DateTimeImmutable();
    }

    // Getters and setters...
}

Templates Twig

Twig est le moteur de templates par défaut de Symfony, offrant une syntaxe élégante et sécurisée pour créer vos vues.

index.html.twig

{# templates/product/index.html.twig #}
{% extends 'base.html.twig' %}

{% block title %}Liste des produits{% endblock %}

{% block body %}
    <div class="container">
        <h1>Liste des produits</h1>
        
        {% if products|length > 0 %}
            <div class="row">
                {% for product in products %}
                    <div class="col-md-4 mb-4">
                        <div class="card">
                            {% if product.imageFilename %}
                                <img src="{{ asset('uploads/products/' ~ product.imageFilename) }}" 
                                     class="card-img-top" alt="{{ product.name }}">
                            {% endif %}
                            <div class="card-body">
                                <h5 class="card-title">{{ product.name }}</h5>
                                <p class="card-text">{{ product.description|slice(0, 100) }}...</p>
                                <div class="d-flex justify-content-between align-items-center">
                                    <span class="text-primary">{{ product.price|format_currency('EUR') }}</span>
                                    <a href="{{ path('product_show', {'id': product.id}) }}" 
                                       class="btn btn-sm btn-outline-primary">Voir détails</a>
                                </div>
                            </div>
                        </div>
                    </div>
                {% endfor %}
            </div>
        {% else %}
            <div class="alert alert-info">
                Aucun produit disponible pour le moment.
            </div>
        {% endif %}
    </div>
{% endblock %}

Services et Injection de dépendances

Les services encapsulent la logique réutilisable de l'application, et le conteneur d'injection de dépendances de Symfony gère leur instanciation et leurs relations.

ProductService.php

<?php
// src/Service/ProductService.php
namespace App\Service;

use App\Entity\Product;
use App\Repository\ProductRepository;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\String\Slugger\SluggerInterface;

class ProductService
{
    private $entityManager;
    private $productRepository;
    private $slugger;
    
    public function __construct(
        EntityManagerInterface $entityManager,
        ProductRepository $productRepository,
        SluggerInterface $slugger
    ) {
        $this->entityManager = $entityManager;
        $this->productRepository = $productRepository;
        $this->slugger = $slugger;
    }
    
    public function createProduct(array $data): Product
    {
        $product = new Product();
        $product->setName($data['name']);
        $product->setDescription($data['description'] ?? null);
        $product->setPrice($data['price']);
        
        if (isset($data['slug'])) {
            $product->setSlug($data['slug']);
        } else {
            $product->setSlug($this->generateSlug($data['name']));
        }
        
        $this->entityManager->persist($product);
        $this->entityManager->flush();
        
        return $product;
    }
    
    public function updateProduct(Product $product, array $data): Product
    {
        if (isset($data['name'])) {
            $product->setName($data['name']);
            
            // Mettre à jour le slug seulement si le nom a changé
            if (!isset($data['slug'])) {
                $product->setSlug($this->generateSlug($data['name']));
            }
        }
        
        if (isset($data['description'])) {
            $product->setDescription($data['description']);
        }
        
        if (isset($data['price'])) {
            $product->setPrice($data['price']);
        }
        
        if (isset($data['slug'])) {
            $product->setSlug($data['slug']);
        }
        
        $this->entityManager->flush();
        
        return $product;
    }
    
    private function generateSlug(string $name): string
    {
        return strtolower($this->slugger->slug($name));
    }
}

Composants clés

HttpFoundation - Abstraction orientée objet des requêtes et réponses HTTP
Form - Système complet pour créer et traiter des formulaires HTML
Security - Infrastructure d'authentification et d'autorisation configurable
Validator - Validation des données basée sur des contraintes
Messenger - Système de bus de messages et de files d'attente avec intégration possible avec AWS SQS
Mailer - Bibliothèque d'envoi d'emails puissante et flexible
Cache - Système de cache PSR-6 et PSR-16 avec différents adaptateurs

Outils et écosystème

Symfony Flex - Système de gestion de recettes pour automatiser la configuration des packages
Symfony CLI - Outil en ligne de commande pour faciliter le développement
API Platform - Framework pour construire des API web modernes (REST, GraphQL)
EasyAdmin - Générateur d'interface d'administration
Webpack Encore - Intégration simplifiée de Webpack pour gérer les assets
Panther - Outil de test E2E pour les applications Symfony similaire à Cypress ou Selenium