1 / 15

Symfony 6.4

Installation, Architecture MVC et Premiers Pas

Formation DWWM - Développement Web et Web Mobile

💡 Introduction pour les apprenants :
Bienvenue dans cette formation sur Symfony ! Ce framework vous permettra de créer des applications web professionnelles et robustes. Nous allons partir de zéro et construire ensemble votre première application.

Plan du Cours

  • Présentation de Symfony
  • Installation et prérequis
  • Structure d'un projet Symfony
  • Architecture MVC dans Symfony
  • Création du premier contrôleur
  • Routage et annotations
  • Templates avec Twig
  • Premier projet pratique
📋 Objectifs pédagogiques :
À la fin de cette formation, vous saurez installer Symfony, comprendre son architecture, créer des pages web dynamiques et structurer un projet professionnel. Chaque étape sera illustrée par des exemples pratiques.

Qu'est-ce que Symfony ?

  • Framework PHP open-source créé par Fabien Potencier
  • Basé sur le pattern MVC (Model-View-Controller)
  • Utilise des composants réutilisables
  • Excellent pour le développement d'applications web robustes
  • Grande communauté et documentation complète
  • Version 6.4 : version LTS (Long Term Support)
🔍 Pourquoi utiliser un framework ?
Imaginez que vous construisez une maison. Au lieu de fabriquer chaque brique, vous utilisez des matériaux préfabriqués. Symfony fonctionne de la même manière : il vous fournit des "briques" de code testées et optimisées pour construire votre application web plus rapidement et de manière plus fiable.
💡 À retenir : La version LTS (6.4) bénéficie de 4 ans de support. C'est idéal pour des projets professionnels qui doivent durer dans le temps.

Prérequis Techniques

Serveur

  • PHP 8.1 ou supérieur
  • Extensions PHP requises
  • Composer (gestionnaire de paquets)
  • Symfony CLI (optionnel)

Base de données

  • MySQL 5.7+
  • PostgreSQL 10+
  • SQLite 3.15+
  • MariaDB 10.3+
🛠️ Préparation de l'environnement :
Composer est l'équivalent de npm pour JavaScript - il gère les dépendances PHP. Symfony CLI est un outil qui simplifie le développement (serveur local, vérifications, etc.). Pour débuter, nous utiliserons XAMPP ou WAMP qui incluent PHP et MySQL.
⚠️ Important : Vérifiez que PHP est bien accessible depuis votre terminal avec la commande php -v

Installation de Symfony

Méthode 1 : Symfony CLI (Recommandée)

# Installation de Symfony CLI
curl -sS https://get.symfony.com/cli/installer | bash

# Création d'un nouveau projet
symfony new mon_projet --version=6.4 --webapp

# Démarrage du serveur de développement
cd mon_projet
symfony server:start

Méthode 2 : Composer

composer create-project symfony/skeleton:"6.4.*" mon_projet
cd mon_projet
composer require webapp
📝 Explication des commandes :
--webapp installe un pack complet avec Twig, Doctrine, formulaires, etc. C'est parfait pour débuter.
symfony server:start lance un serveur local sur http://127.0.0.1:8000
Si vous n'avez pas Symfony CLI, la méthode Composer fonctionne très bien aussi !
🎯 Conseil pratique : Ouvrez deux terminaux : un pour les commandes Symfony, un autre pour suivre les logs en temps réel.

Structure d'un Projet Symfony

mon_projet/
├── bin/                 # Scripts exécutables
├── config/             # Configuration de l'application
├── public/             # Point d'entrée web (index.php)
├── src/                # Code source de l'application
│   ├── Controller/     # Contrôleurs
│   ├── Entity/         # Entités (modèles)
│   └── Repository/     # Repositories
├── templates/          # Templates Twig
├── var/               # Fichiers temporaires (cache, logs)
├── vendor/            # Dépendances Composer
└── composer.json      # Configuration Composer
🏗️ Architecture claire et logique :
src/ : Tout votre code PHP personnalisé
templates/ : Vos pages HTML avec Twig
public/ : Le seul dossier accessible depuis le web
var/ : Cache et logs (ignoré par Git)
config/ : Paramètres de l'application
🔍 Comparaison : Si vous connaissiez PHP vanilla, tout était mélangé dans un même dossier. Ici, chaque type de fichier a sa place logique !

Architecture MVC dans Symfony

MODEL

Entités
Repositories
Doctrine ORM

→

CONTROLLER

Logique métier
Traitement
Routing

→

VIEW

Templates Twig
Présentation
Interface

Le contrôleur fait le lien entre le modèle et la vue

🎭 MVC expliqué simplement :
Model : Gère les données (comme un carnet d'adresses)
View : Affiche les informations (comme une page web)
Controller : Chef d'orchestre qui coordonne le tout

Exemple concret : Pour afficher la liste des utilisateurs :
1. Le Controller demande les données au Model
2. Le Model récupère les utilisateurs en base
3. Le Controller passe ces données à la View
4. La View génère le HTML final

Création du Premier Contrôleur

# Génération automatique
php bin/console make:controller HomeController
// src/Controller/HomeController.php
<?php
namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class HomeController extends AbstractController
{
    #[Route('/', name: 'app_home')]
    public function index(): Response
    {
        return $this->render('home/index.html.twig', [
            'title' => 'Bienvenue sur mon site Symfony !',
        ]);
    }
}
🏗️ Décortiquons ce code :
make:controller : Commande magique qui génère le contrôleur ET son template
#[Route('/', name: 'app_home')] : Attribut PHP 8 qui définit l'URL
AbstractController : Classe parente qui donne accès aux services Symfony
render() : Méthode qui génère le HTML à partir d'un template Twig
💡 Astuce : Le nom de la route ('app_home') permet de générer des URLs dans les templates avec {{ path('app_home') }}

Système de Routage

Avec les Attributs PHP 8 (Recommandé)

#[Route('/blog/{id}', name: 'blog_show', requirements: ['id' => '\d+'])]
public function show(int $id): Response
{
    return new Response('Article numéro: ' . $id);
}

#[Route('/blog/{slug}', name: 'blog_by_slug')]
public function showBySlug(string $slug): Response
{
    return new Response('Article: ' . $slug);
}

Paramètres optionnels

#[Route('/blog/{page}', name: 'blog_list', requirements: ['page' => '\d+'])]
public function list(int $page = 1): Response
{
    return new Response('Page: ' . $page);
}
🛣️ Le routage, c'est quoi ?
C'est le système qui transforme une URL en action PHP.
{id} : Paramètre dynamique (ex: /blog/123)
requirements : Contraintes sur les paramètres (\d+ = que des chiffres)
Paramètre optionnel : Si aucune valeur, utilise la valeur par défaut
🌐 Exemples d'URLs :
/blog/123 → appelle show() avec $id = 123
/blog/mon-article → appelle showBySlug() avec $slug = "mon-article"
/blog → appelle list() avec $page = 1 (valeur par défaut)

Templates avec Twig

Template de base (base.html.twig)

<!-- templates/base.html.twig -->
<!DOCTYPE html>
<html>
    <head>
        <title>{% block title %}Mon Site{% endblock %}</title>
        {% block stylesheets %}{% endblock %}
    </head>
    <body>
        {% block body %}{% endblock %}
        {% block javascripts %}{% endblock %}
    </body>
</html>

Template enfant

<!-- templates/home/index.html.twig -->
{% extends 'base.html.twig' %}

{% block title %}{{ title }}{% endblock %}

{% block body %}
    <h1>{{ title }}</h1>
    <p>Ceci est ma première page Symfony !</p>
{% endblock %}
🎨 Twig : le moteur de templates :
{% block %} : Définit une zone que les templates enfants peuvent remplacer
{{ variable }} : Affiche le contenu d'une variable
extends : Hérite d'un template parent
Avantage : Structure HTML commune, contenu spécifique par page
🔒 Sécurité : Twig échappe automatiquement les variables (protection XSS). Plus besoin de htmlspecialchars() !

Configuration et Environnements

Fichier .env

# .env
APP_ENV=dev
APP_SECRET=your-secret-key
DATABASE_URL="mysql://user:password@127.0.0.1:3306/ma_base"

Commandes utiles

# Vider le cache
php bin/console cache:clear

# Lister les routes
php bin/console debug:router

# Vérifier la configuration
php bin/console debug:config

# Mode debug
php bin/console about
⚙️ Configuration flexible :
.env : Variables d'environnement (dev, prod, test)
APP_ENV=dev : Active le mode développement (erreurs détaillées, profiler)
DATABASE_URL : Connexion base de données
console : Outil en ligne de commande très puissant
🔐 Sécurité : Ne commitez jamais le fichier .env.local en production ! Utilisez des variables d'environnement réelles.

Services et Injection de Dépendances

Utilisation dans un contrôleur

use Psr\Log\LoggerInterface;

class HomeController extends AbstractController
{
    public function __construct(
        private LoggerInterface $logger
    ) {}

    #[Route('/', name: 'app_home')]
    public function index(): Response
    {
        $this->logger->info('Page d\'accueil visitée');
        
        return $this->render('home/index.html.twig');
    }
}

Symfony injecte automatiquement les services grâce à l'autowiring

🔧 L'injection de dépendances expliquée :
Au lieu de créer manuellement les objets dont vous avez besoin, Symfony les "injecte" automatiquement dans votre contrôleur.

Avant : $logger = new Logger(); // Vous devez tout gérer
Avec Symfony : Il suffit de le demander dans le constructeur !

Autowiring : Symfony devine automatiquement quel service injecter selon le type
🎯 Services courants :
LoggerInterface → pour les logs
EntityManagerInterface → pour la base de données
Request → pour les données de la requête HTTP

Première Application : Blog Simple

Étapes de développement

  • Créer un contrôleur BlogController
  • Définir les routes pour lister et afficher les articles
  • Créer les templates Twig correspondants
  • Ajouter du CSS avec Bootstrap
  • Tester l'application
# Génération du contrôleur
php bin/console make:controller BlogController

# Structure des routes
/blog           → Liste des articles
/blog/{id}      → Affichage d'un article
🚀 Mise en pratique :
Nous allons créer un blog simple avec des données statiques pour comprendre le fonctionnement. Dans un second temps, nous ajouterons une vraie base de données.

Méthode pédagogique :
1. D'abord le contrôleur (logique)
2. Puis les templates (affichage)
3. Enfin le style (présentation)
💡 Astuce : Utilisez le profiler Symfony pour vérifier que vos routes fonctionnent correctement et que les templates sont bien rendus.

Outils de Développement

Symfony CLI

  • Serveur de développement
  • Vérification des prérequis
  • Intégration Git

Profiler

  • Debug des performances
  • Analyse des requêtes
  • Timeline d'exécution
# Installation du profiler (mode dev)
composer require --dev symfony/profiler-pack

# Debug d'une route spécifique
php bin/console debug:router app_home
🛠️ Outils indispensables du développeur :
Symfony CLI : Votre couteau suisse Symfony. Détecte les erreurs de configuration, optimise les performances.
Profiler : Barre de debug en bas de page en mode dev. Montre tout : requêtes SQL, temps d'exécution, variables Twig, etc.
Console : Plus de 50 commandes pour automatiser vos tâches
🔍 Debug efficace : Utilisez toujours le profiler pour identifier les problèmes de performance. Il vous montre exactement ce qui se passe !

Prochaines Étapes

  • Doctrine ORM et base de données
  • Formulaires Symfony
  • Sécurité et authentification
  • API REST avec Symfony
  • Tests unitaires et fonctionnels

Ressources Utiles

🎓 Progression pédagogique :
Niveau 1 (aujourd'hui) : Installation, MVC, contrôleurs, templates
Niveau 2 : Base de données avec Doctrine ORM
Niveau 3 : Formulaires et validation
Niveau 4 : Sécurité et authentification
Niveau 5 : APIs et services web
💪 Conseils pour continuer :
• Pratiquez régulièrement avec de petits projets
• Lisez la documentation officielle (excellente qualité)
• Rejoignez la communauté Symfony (Slack, forums)
• Suivez les bonnes pratiques dès le début

🎉 Merci pour votre attention ! 🎉