Ce livre sur Symfony 4 s’adresse aux développeurs, chefs de projets, architectes techniques, qui souhaitent, grâce à ce framework, structurer et organiser leurs développements PHP au sein d’un environnement de construction d’applications robuste et professionnel. La maîtrise de la programmation objet avec PHP est un prérequis indispensable pour tirer le meilleur parti de ces pages.

Le livre couvre les principaux composants de Symfony 4, considéré aujourd’hui comme le framework PHP de référence. Il fournit les connaissances de base qui permettent non seulement de créer un site ou une application web, mais également de comprendre et maîtriser son fonctionnement en détail. Un chapitre entier est par exemple consacré à l’architecture du framework.

Les sujets détaillés vont de l’installation de Symfony à la création de tests unitaires et fonctionnels. La gestion des formulaires, des interactions avec une base de données, des templates, de la journalisation ou même de la sécurité de l’application sont autant de thèmes exposés dans le livre.

Le temps de chargement des pages d’un site web étant un élément crucial, un chapitre délivre les techniques et astuces pour fortement améliorer les performances d’une application.

Les auteurs ont structuré les chapitres pour faciliter l’apprentissage de Symfony 4 et dévoilent au fil des pages des conseils, bonnes pratiques et exemples détaillés.

Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.



Quizinclus dans
la version en ligne !

• Testez vos connaissances à l'issue de chaque chapitre
• Validez vos acquis

Téléchargements

• Des fichiers complémentaires (827 Ko)

Introduction

1. Avant-propos
2. Public visé
3. Prérequis
4. Objectifs du livre
5. Le développement avec les frameworks
   1. 1. Complexité des développements etproductivité
      1. a. Productivité et qualité logicielle
      2. b. Intégration et livraison continues
   2. 2. Particularité des développementsen PHP
      1. a. Contexte historique de PHP
      2. b. Évolutions
   3. 3. L’apport des frameworks
      1. a. Éviter les problèmes techniquesliés à l’organisation du code
      2. b. Définir des responsabilités
      3. c. Ne pas réinventer la roue
      4. d. Utiliser des modèles de conception éprouvés
6. Symfony
   1. 1. Historique
   2. 2. Gouvernance et gestion des versions
      1. a. Les versions
      2. b. Le cycle de « release »
   3. 3. Choisir sa version pour un projet

Mise en place d’un projet Symfony

1. L’outillage nécessaire
   1. 1. Introduction
   2. 2. Symfony : Un projet PHP
      1. a. Préconisation d’installation
      2. b. Installation sous Linux
      3. c. Installation sous Windows
   3. 3. L’installeur Symfony
   4. 4. Composer
      1. a. Installer Composer
   5. 5. Les environnements de développement pourSymfony
      1. a. Un IDE pour Symfony !
      2. b. PHPStorm
      3. c. Eclipse IDE for PHP Developers
      4. d. Visual Studio Code
      5. e. Conclusion
2. Création d’un projet Symfony
   1. 1. Prérequis
   2. 2. Création via l’installeur Symfony
   3. 3. Création via Composer
   4. 4. Configurer son serveur web
      1. a. Serveur web PHP
      2. b. Apache et Nginx
3. Structure de l’application
   1. 1. Arborescence du projet
   2. 2. Règles et conventions d’organisationdu projet
      1. a. Le standard PSR-4
      2. b. Conventions de nommage
   3. 3. La configuration d’une application Symfony
      1. a. Les annotations
      2. b. Le format YAML
      3. c. Le format XML
      4. d. Le format PHP
      5. e. Choisir son format de configuration

Architecture du framework

1. Le modèle de conception MVC
   1. 1. Définitions et responsabilités
      1. a. La vue
      2. b. Le modèle
      3. c. Le contrôleur
   2. 2. En pratique
      1. a. Le contrôleur frontal
      2. b. Le routage
      3. c. Le contrôleur et le modèle
      4. d. La vue
      5. e. En synthèse
2. Architecture de Symfony
   1. 1. Présentation
   2. 2. Le contrôleur frontal
   3. 3. Le Service Container
   4. 4. Le modèle MVC dans Symfony ?
   5. 5. L’approche par composant
3. Symfony Flex
   1. 1. Présentation
   2. 2. Fonctionnement de Symfony Flex
   3. 3. Les recettes Flex
      1. a. Un exemple concret
4. Les environnements
   1. 1. Principe et apports
   2. 2. Les fichiers de configuration
   3. 3. Dans le contexte HTTP
   4. 4. Dans le contexte CLI (Command Line Interface)
5. Le chargement automatique de classes
   1. 1. Le standard PSR-4
   2. 2. Mécanismes alternatifs
   3. 3. Application aux applications Symfony
6. La console
   1. 1. Présentation
   2. 2. Les commandes
      1. a. Lister les commandes disponibles
      2. b. Exécuter une commande
   3. 3. Les options
   4. 4. Les arguments
   5. 5. L’aide sur les commandes
   6. 6. Exécuter rapidement des commandes
7. Les outils pour le débogage
   1. 1. Le profiler Symfony
   2. 2. La fonction dump()

Routage et contrôleur

1. Fonctionnement du routage dans Symfony
   1. 1. Définition
   2. 2. Le répertoire public et le contrôleurfrontal
   3. 3. Une requête, une action
2. Définition des routes
   1. 1. Les différents formats de définition
   2. 2. Les options sur la définition des routes
3. Configurer le path
   1. 1. Illustration par l’exemple : /hello/world
   2. 2. La notation du contrôleur
   3. 3. Importer des routes depuis d’autres fichiers
   4. 4. Comprendre l’ordre de chargement des routes
   5. 5. Préfixer les routes
   6. 6. Les paramètres de substitution des routes
   7. 7. Les restrictions sur les paramètres
   8. 8. Obtenir des informations sur le routage
4. Routage par nom de domaine
   1. 1. Prérequis
   2. 2. Exemple de mise en œuvre
   3. 3. Explications
5. Le contrôleur
   1. 1. Modèle de programmation et règles
   2. 2. Travailler avec les services
   3. 3. Utiliser les paramètres de substitution
      1. a. Paramètres de substitution des routes
      2. b. Exemples
   4. 4. Travailler avec les URL
   5. 5. Effectuer une redirection
   6. 6. La délégation de requête
   7. 7. La gestion des erreurs et des pages d’erreursdans les contôleurs
      1. a. Le contrôleur
      2. b. La vue

L’injection de dépendances

1. Le modèle de conception IoC : Inversion Of Control
   1. 1. Apports dans une architecture applicative
   2. 2. IoC et injection de dépendances
2. L’injection de dépendances
   1. 1. Principes de base
   2. 2. Les différentes techniques d’injectionde dépendances
      1. a. L’injection de dépendances par leconstructeur
      2. b. L’injection de dépendances par setter(mutateur)
      3. c. L’injection de dépendances par propriété
   3. 3. Les avantages
3. Le Service Container
   1. 1. Les services
   2. 2. Explications au travers d’un service X
4. Créer un service et configurer ses injections
   1. 1. Créer un service
   2. 2. Les différents types d’injectionsdans un service Symfony
      1. a. Injection par constructeur
      2. b. Injection par méthode
      3. c. Injection par propriété
   3. 3. Injection automatique avec l’autowiring
   4. 4. Les services « lazy »
5. Le chargement automatique de services
   1. 1. La configuration
   2. 2. Exemple d’utilisation
6. Créer des services réutilisables et distribuables
   1. 1. Le concept de bundle
      1. a. Créer un bundle
      2. b. Arborescence du bundle
   2. 2. La définition de services dans un bundle
   3. 3. La configuration
      1. a. Définir une arborescence
      2. b. Les différentes étapes du traitementde la configuration
      3. c. Récupérer la configuration validée
   4. 4. Les « Compiler Passes »
      1. a. Concept
      2. b. Les tags
      3. c. Le Compiler Pass

Les templates avec Twig

1. Présentation et concepts
   1. 1. Le concept de Templating
   2. 2. Templating et modèle MVC
2. Twig
   1. 1. Présentation
   2. 2. Pourquoi un nouveau langage ?
   3. 3. Mise en pratique
   4. 4. Remarques sur l’utilisation
   5. 5. La notation des templates
   6. 6. Extension du système de templates
   7. 7. L’annotation @Template
3. Les gabarits de pages (layouts) et les blocks
   1. 1. La composition de pages
   2. 2. Définition des gabarits
   3. 3. Les blocks
4. Le langage Twig
   1. 1. Les différents types d’instructions
   2. 2. Manipulation des variables
      1. a. Utilisation de variables dans les templates
      2. b. Utilisation des variables de type tableau ou objet
   3. 3. Structures de contrôle et tags
      1. a. Les conditions
      2. b. Les boucles
   4. 4. Les balises Twig (tags)
      1. a. Créer et modifier des variables
      2. b. Twig et l’échappement
   5. 5. Inclure des templates
5. Les filtres et les fonctions
   1. 1. Présentation des filtres
      1. a. Utilisation et syntaxe
   2. 2. Les principaux filtres Twig
      1. a. Chaînes de caractères
      2. b. Échappement
      3. c. L’encodage
   3. 3. Les fonctions
      1. a. Twig et le routage
      2. b. Débogage avec la fonction dump
6. La gestion des ressources statiques (images, feuilles de style, scripts JS…)
   1. 1. Les ressources statiques dans une application Symfony
   2. 2. Le cas des ressources statiques externes
   3. 3. Référencer les ressources publiquesdepuis un template
   4. 4. Cas pratique avec le framework CSS Bootstrap 4

Accéder aux bases de données avec Doctrine

1. Présentation et concepts
   1. 1. Les principes de l’ORM
   2. 2. Architecture de Doctrine
      1. a. DBAL
      2. b. Entité
      3. c. ORM
   3. 3. La notion d’entité
2. Installer et configurer Doctrine
   1. 1. Mise en place de Doctrine
   2. 2. Relation avec PDO
   3. 3. Configuration
3. Définition des entités et de leur mapping
   1. 1. Règles de conception des entités
   2. 2. Les syntaxes pour le mapping des entités
   3. 3. Le mapping d’entités simples
      1. a. Définir une entité avec @ORM\Entity
      2. b. Gérer les colonnes de la table avec @ORM\Column
      3. c. @ORM\Table
      4. d. Les clés primaires
      5. e. Configurer les index
   4. 4. Le mapping des relations (clés étrangères)
      1. a. @ORM\OneToOne
      2. b. @ORM\ManyToOne
      3. c. @ORM\ManyToMany
      4. d. Relations bidirectionnelles
   5. 5. Les outils de la console
      1. a. Repérer les erreurs de mapping
      2. b. Générer le schéma des données à partirdes entités
      3. c. Générer les entités à partirdu schéma des données
4. Manipulation des entités avec l’EntityManager
   1. 1. Le rôle de l’EntityManager
   2. 2. Insertion de données
   3. 3. Modification de données
   4. 4. Suppression de données
   5. 5. Autres opérations de l’EntityManager
      1. a. refresh()
      2. b. detach()
   6. 6. Les opérations en cascade
5. Récupérer des entités
   1. 1. Le repository
      1. a. Un rôle de centralisateur
      2. b. Les méthodes de base du repository
      3. c. Les méthodes personnalisées du repository
   2. 2. Le DQL
      1. a. SELECT
      2. b. FROM
      3. c. JOIN et LEFT JOIN
      4. d. WHERE
      5. e. ORDER BY
      6. f. Les limites
      7. g. Les limites et la pagination
   3. 3. Le QueryBuilder
6. Fonctionnalités avancées
   1. 1. Les extensions Doctrine
      1. a. Installation
      2. b. Utilisation d’un slug sur une entité

La gestion des événements applicatifs

1. Concepts et écoute d’événement applicatifs
   1. 1. Le propagation des événements
   2. 2. L’écoute des événements
2. Les événements du Kernel
   1. 1. Les différents type d’événements
   2. 2. Applications
3. Les événements de la console
   1. 1. Prérequis
   2. 2. Les événements

Les formulaires

1. Un composant MVC
   1. 1. Le modèle
   2. 2. Le contrôleur
   3. 3. La vue
2. Fonctionnement du composant
   1. 1. L’objet « Form »
      1. a. Soumission
      2. b. Validation
      3. c. Vue
   2. 2. Les types
   3. 3. Les options
   4. 4. Les objets « Form » et « FormBuilder »
      1. a. Le FormBuilder
      2. b. Structure de l’objet Form
   5. 5. Association avec l’objet de la couche Modèle
   6. 6. Formulaires sans objet
   7. 7. La représentation des valeurs
      1. a. Transformation des données
      2. b. Illustration avec le type date
3. Les types de champs de formulaire
   1. 1. L’héritage
   2. 2. FormType
      1. a. label
      2. b. label attr
      3. c. data
      4. d. required
      5. e. disabled
      6. f. mapped
      7. g. property_path
      8. h. attr
      9. i. trim
      10. j. error_bubbling
   3. 3. TextType
   4. 4. PasswordType
   5. 5. RepeatedType
      1. a. type
      2. b. first_options et second_options
      3. c. options
      4. d. first_name
      5. e. second_name
      6. f. invalid_message
   6. 6. ChoiceType
      1. a. choices
      2. b. expanded et multiple
      3. c. placeholder
      4. d. preferred_choices
      5. e. Types similaires
   7. 7. EntityType
      1. a. class
      2. b. choice_label
      3. c. query_builder
      4. d. group_by
      5. e. em
   8. 8. DateType
      1. a. widget
      2. b. format
      3. c. model_timezone
      4. d. view_timezone
      5. e. years
      6. f. months
      7. g. days
      8. h. placeholder
      9. i. Types similaires
   9. 9. FileType
      1. a. multiple
      2. b. Récupérer les fichiers
      3. c. Traiter les fichiers
   10. 10. CheckboxType
   11. 11. SubmitType, ResetType et ButtonType
4. Créer des formulaires réutilisables
   1. 1. Définir un formulaire avec la classe AbstractType
   2. 2. Utiliser un formulaire défini dans une classe
      1. a. Définition manuelle
      2. b. Avec l’injection de dépendances
5. Validation des données
   1. 1. Objectifs
   2. 2. La définition des contraintes de validation
      1. a. Ajout des contraintes lors de la configuration d’unformulaire
      2. b. Ajout des contraintes sur l’objet associé auformulaire
      3. c. Les différents formats de configuration
      4. d. Les options
   3. 3. Les contraintes et leurs options
      1. a. NotBlank et NotNull
      2. b. IsNull et Blank
      3. c. IsTrue, IsFalse
      4. d. Type
      5. e. Email, Url et Ip
      6. f. Regex
      7. g. Length, Count
      8. h. Range
      9. i. Comparaisons
      10. j. Dates
      11. k. File
      12. l. Image
      13. m. Choice
      14. n. UniqueEntity
      15. o. Données financières
      16. p. Callback
      17. q. All
      18. r. Valid
   4. 4. Groupes de validation
   5. 5. Validation d’un objet hors du contexte d’unformulaire
6. Personnaliser le rendu - thèmes de formulaires
   1. 1. Afficher le formulaire manuellement
      1. a. form_start()
      2. b. form_end()
      3. c. form_widget()
      4. d. form_errors()
      5. e. form_label()
      6. f. form_row()
      7. g. form_rest()
      8. h. Arborescence des parties de formulaires
   2. 2. Créer des thèmes
      1. a. Formulaire d’exemple
      2. b. Créer et associer un thème de formulaires
      3. c. Comprendre le nom des blocks

La sécurité dans une application Symfony

1. Présentation et concepts de sécurité
   1. 1. Les challenges de la sécurité desapplications web
   2. 2. La sécurité dans Symfony
2. Authentification
   1. 1. Pare-feu
      1. a. Pare-feu pour ressources statiques/développement
   2. 2. Authentification HTTP
   3. 3. Authentification par formulaire de connexion
   4. 4. Connexion automatique des utilisateurs
   5. 5. Déconnexion des utilisateurs
3. Utilisateurs et rôles
   1. 1. L’utilisateur
      1. a. Récupérer l’utilisateurcourant
   2. 2. Les fournisseurs d’utilisateurs
      1. a. En mémoire
      2. b. Fournisseur d’utilisateurs de bases de données
      3. c. Fournisseur d’utilisateurs personnalisé
      4. d. Notes additionnelles
   3. 3. Cryptage des mots de passe
      1. a. Encodeurs
      2. b. Le salage
      3. c. Crypter un mot de passe
   4. 4. Les rôles
4. Autorisations
   1. 1. Les rôles, au cœur du processus
   2. 2. Vérifier le rôle de l’utilisateur
   3. 3. Sécuriser une action
   4. 4. Sécuriser une section de l’application
   5. 5. Sécuriser selon d’autres critères
   6. 6. Pour aller plus loin

Tester son application Symfony

1. Introduction au test logiciel
   1. 1. Les tests : un indispensable pour la qualité logicielle
   2. 2. Les différentes catégories de tests
      1. a. Les tests unitaires
      2. b. Les tests d’intégration
      3. c. Les tests fonctionnels
   3. 3. Analogie
   4. 4. L’approche des tests en PHP
2. Les tests unitaires avec PHPUnit
   1. 1. Mise en place des tests
   2. 2. Règle d’écriture des tests
   3. 3. Exécuter les tests
      1. a. Exécuter une partie des tests
3. Les tests fonctionnels
   1. 1. Différence par rapport aux tests unitaireset d’intégration
   2. 2. Tester une action
   3. 3. Les objets pour l’écriture des test
      1. a. L’objet Client
      2. b. L’objet Crawler
   4. 4. Soumettre un formulaire
   5. 5. Pour aller plus loin

Journalisation et surveillance avec Symfony

1. Générer des journaux avec Monolog
   1. 1. La journalisation
   2. 2. La librairie Monolog
   3. 3. Le service logger
   4. 4. Le fichier journal
      1. a. Identifier la cause d’un bogue
      2. b. Le problème
   5. 5. Les gestionnaires (handlers)
      1. a. Définir plusieurs gestionnaires
      2. b. Envoyer des logs par e-mail
      3. c. Utiliser un tampon (buffer)
      4. d. Ajouter des informations complémentaires
   6. 6. Les canaux (channels)
      1. a. Ajouter ses propres canaux
      2. b. Envoyer un enregistrement sur un canal donné
      3. c. Configurer les gestionnaires par canaux
      4. d. Gestion des erreurs 404
2. Le monitoring avec Prometheus et Grafana
   1. 1. Un allié proactif au logging
   2. 2. Préparation d’une application Symfonypour Prometheus
   3. 3. Instrumenter les mesures
   4. 4. Pour aller plus loin

Amélioration des performances

1. La mise en cache de pages
   1. 1. Autour du protocole HTTP
   2. 2. Un serveur proxy inverse (ou « reverse proxy »)
      1. a. HttpCache
      2. b. Nginx
      3. c. Varnish
   3. 3. Les en-têtes
   4. 4. Les réponses publiques et privées
   5. 5. L’expiration
      1. a. L’en-tête Expires
      2. b. Les directives max-age et s-max-age
      3. c. L’annotation @Cache
   6. 6. La validation
      1. a. Par date avec Last-Modified
      2. b. Par empreinte avec l’en-tête ETag
   7. 7. Les ESI
      1. a. Activation
      2. b. Générer une balise ESI
2. L’autochargement des classes
   1. 1. Générer un classmap
3. Le cache avec Doctrine
   1. 1. Les différents types de cache
   2. 2. Configuration
4. Le cache d’annotations
5. Les sessions
6. Autres optimisations
   1. 1. Choix de sa SAPI PHP
      1. a. Qu’est-ce qu’une SAPI ?
      2. b. Module du serveur
      3. c. CGI
      4. d. FastCGI
      5. e. Conclusion
   2. 2. Mise en cache d’OPCodes
      1. a. Les OPCodes
      2. b. Une étape lourde
      3. c. La mise en cache
   3. 3. La compression des réponses
      1. a. Compression gzip
      2. b. Précompression
   4. 4. Optimisation des images
      1. a. Validation
      2. b. Expiration
      3. c. Autres techniques
7. Test des performances d'un site web
   1. 1. Côté serveur
      1. a. Apache Bench
      2. b. Xhprof
   2. 2. Côté client

Internationalisation des applications Symfony

1. Introduction
   1. 1. Culture, internationalisation et régionalisation
      1. a. La culture (Locale)
      2. b. Internationalisation
      3. c. Régionalisation
   2. 2. L’internationalisation dans Symfony
2. Détecter la culture d'un utilisateur
   1. 1. Les techniques
      1. a. Négociation de contenu
      2. b. Par l’URL
   2. 2. En pratique
3. Activation des traductions
   1. 1. Le composant translator
   2. 2. Configuration du framework
4. Les routes et les traductions
5. Les fichiers de traductions
   1. 1. Organisation et règles de nommage
      1. a. Règle de nommage
   2. 2. Outillage pour la création des fichiers detraduction
      1. a. Afficher la liste des traductions manquantes
      2. b. Générer un fichier de traduction
6. Traduction d'un message
   1. 1. Le service translator
   2. 2. Les paramètres de substitution (placeholders)
   3. 3. Utilisation dans les templates Twig

Développer une API REST avec Symfony

1. Introduction à REST et concepts fondamentaux
   1. 1. Les concepts de REST
      1. a. Les ressources
      2. b. Le changement d’état d’uneressource
   2. 2. Architecture et protocole HTTP
   3. 3. Les Single-Page Applications
2. La gestion du format JSON
   1. 1. Présentation du format JSON
      1. a. Représentation des données en JSON
      2. b. Types de données
      3. c. Structures
   2. 2. Le support de JSON en PHP
   3. 3. Et dans Symfony ?
3. Mise en place d’une API REST
   1. 1. Le service serializer
      1. a. Sérialiser des données
      2. b. Désérialiser des données
   2. 2. Adaptation des contrôleurs
4. Les objets de requête et de réponse
   1. 1. Le contenu et les en-têtes de requête
   2. 2. Manipulation de la réponse avec Responseet JsonResponse
      1. a. Renvoyer une réponse au format JSON
   3. 3. Les codes de réponse HTTP dans une API REST
      1. a. Problématique de l’étatde la réponse
      2. b. Expression de la réponse avec HTTP
      3. c. Mise en œuvre
5. Tester une API REST
   1. 1. Les limites du navigateur web
   2. 2. Les outils
      1. a. Postman
      2. b. SOAP UI

Annexes

1. Créer une commande pour la console
   1. 1. La configuration d’une commande
   2. 2. Les objets input et output
   3. 3. Le Service Container
   4. 4. Commande d’exemple
2. Envoyer des e-mails grâce à SwiftMailer
   1. 1. Le protocole SMTP
   2. 2. Le transport
      1. a. Le transport smtp
      2. b. Le transport sendmail
   3. 3. Envoi d’un e-mail
3. Travailler avec les sessions
   1. 1. Introduction
   2. 2. Intégration des sessions dans Symfony
   3. 3. Configuration du gestionnaire de sauvegarde
      1. a. Avec PHP
      2. b. Avec Symfony
   4. 4. Les messages « flash »
4. Déployer une application symfony
   1. 1. Le déploiement
   2. 2. Faut-il déployer par FTP ?
   3. 3. Les différentes étapes
   4. 4. Capistrano et Capifony
      1. a. Installation
      2. b. Configuration
      3. c. Déploiement
   5. 5. Fonctionnalités avancées