Le but de ce chapitre va être d’initialiser le projet qui nous servira de fil rouge tout au long de ce cours.
Ce projet, volontairement très simple, va nous placer dans la position d’une bibliothèque qui veut publier une API sur les livres qu’elle possède, ainsi que sur les auteurs de ces livres.
De plus, un système de sécurité sera mis en place pour ne permettre aux utilisateurs sans droits particuliers que la consultation, et aux administrateurs de créer et modifier livres et auteurs.
Installez Symfony
Nous n’allons pas détailler ici l’installation de l’exécutable “Symfony”, et nous allons considérer que les prérequis nécessaires à cette installation sont déjà remplis.
Par défaut, le framework Symfony peut s’installer :
en version basique, avec uniquement les bundles requis pour un fonctionnement minimal ;
ou en version web, avec de nombreux bundles supplémentaires généralement utilisés lorsqu’on veut réaliser un site web (Twig pour le moteur de template, Doctrine pour accéder à une base de données, etc.).
Nous souhaitons simplement proposer une API, nous allons donc initialiser le projet avec la version basique, et nous rajouterons les divers bundles dont nous aurons besoin au fur et à mesure que ceux-ci apparaîtront.
Pour initialiser votre projet, dans un terminal, vous pouvez taper symfony new Books.
Books est le nom de notre projet, n’hésitez pas à le changer si vous le désirez.
Pour vérifier que l’installation s’est bien déroulée, toujours dans le terminal, vous pouvez vous rendre dans le dossier Books qui a été créé avec la commande cd Books , puis lancer le serveur de Symfony avec symfony server:start .
Cela lancera le serveur de Symfony, et en vous rendant sur l’URL proposée, vous devriez voir quelque chose comme ceci :
Créez une toute première entité
Maintenant que le framework est installé, nous voulons créer nos premières données. En particulier, une toute première table qui contiendra quelques informations basiques sur les livres que nous allons mettre à disposition.
Il est possible de créer cette entité à la main, mais Symfony nous propose de nombreux outils pour nous faciliter la vie, et il serait dommage de s’en passer.
Installez le maker-bundle
Le premier outil est le maker-bundle. Cela permet de demander à Symfony de nous créer certains éléments via la ligne de commande, comme par exemple des contrôleurs ou encore des entités.
Pour installer ce bundle, il suffit de taper composer require symfony/maker-bundle --dev dans votre terminal.
Ajoutez Doctrine
Pour interagir avec une base de données, Symfony utilise ce qu’on appelle un ORM (Object Relational Mapping) qui permet de faire le lien entre le code PHP et la base elle-même.
Comme nous souhaitons créer une entité, et par la suite la transformer en table dans notre base de données, nous devons installer également le bundle Doctrine. Pour cela, rien de plus simple ; dans votre terminal : composer require orm .
Créez l’entité book
C’est bon, nous avons désormais tous les outils pour créer notre entité Book , c'est-à-dire “Livre”. Il ne reste plus qu’à demander à Symfony de nous aider un peu grâce à la commande php bin/console make:entity .
On suit les instructions, et à la fin nous obtenons deux nouveaux fichiers.
Ici, j’ai créé une entité extrêmement simple avec deux champs :
title: le titre du livre (en laissant toutes les options par défaut) ;coverText: la quatrième de couverture, de typetextet nullable.
Une fois ceci complété, nous pouvons voir que deux fichiers supplémentaires ont été créés :
Book.php, qui est l’entité proprement dite ;et
BookRepository.phpqui est en quelque sorte le “manager” de l’entité, et qui nous permettra de requêter la base.
Voici le contenu du fichier Books.php :
<?php
// src\Entity\Book.php
namespace App\Entity;
use App\Repository\BookRepository;
use Doctrine\ORM\Mapping as ORM;
#[ORM\Entity(repositoryClass: BookRepository::class)]
class Book
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column(type: 'integer')]
private $id;
#[ORM\Column(type: 'string', length: 255)]
private $title;
#[ORM\Column(type: 'text', nullable: true)]
private $coverText;
public function getId(): ?int
{
return $this->id;
}
public function getTitle(): ?string
{
return $this->title;
}
public function setTitle(string $title): self
{
$this->title = $title;
return $this;
}
public function getCoverText(): ?string
{
return $this->coverText;
}
public function setCoverText(?string $coverText): self
{
$this->coverText = $coverText;
return $this;
}
}Configurez la base de données
Maintenant que notre première entité est créée, il faut l’envoyer sur la base de données, et pour cela, créer notre base de données.
La première chose à faire est de configurer l’accès à votre base. Pour cela, copiez-collez le fichier .env et renommez la copie en .env.local .
Ce fichier contiendra vos accès réels à votre base et sera utilisé automatiquement par Symfony. Lorsque vous voudrez passer votre projet en mode production, il faudra créer un autre fichier nommé .env.prod .
Dans ce fichier, configurez votre base de données. Comme je suis sous Windows et que ma base de données est une base MySQL configurée par défaut par Wamp, voici ce que j’ai écrit :
DATABASE_URL="mysql://root:@127.0.0.1:3306/Books"Une fois votre chaîne de connexion configurée, vous pouvez créer votre base grâce à Doctrine dans votre terminal : php bin/console doctrine:database:create .
Et finalement, il ne reste plus qu’à dire à Doctrine de transformer l’entité en véritable table avec la commande php bin/console doctrine:schema:update --force .
Vérifiez que votre table est bien créée avec l’outil de votre choix : MySQL Workbench, un plugin dans votre éditeur de texte, ou votre IDE en ligne de commande. Ici, parce que c’est installé directement avec Wamp, j’ai utilisé phpMyAdmin pour vérifier que la structure correspond bien à ce que j’attendais.
Ajoutez des fixtures
Allons un tout petit peu plus loin. Avoir une base de données et une table, c’est très bien, mais avoir des données à exploiter, c’est encore mieux.
Pour cela, nous allons créer des fixtures. En d’autres termes, nous allons écrire du code qui va générer automatiquement des données qui vont s’insérer dans notre base de données.
Là encore, laissons Symfony, et plus précisément Doctrine, nous aider en installant un add-on pour Doctrine qui va nous permettre d’écrire et d’exécuter simplement nos fixtures : composer require orm-fixtures --dev .
Cette commande a normalement créé un nouveau fichierAppFixture.php , déjà prérempli :
Ce fichier va contenir nos instructions pour créer des données.
<?php
// src\DataFixtures\AppFixtures.php
namespace App\DataFixtures;
use App\Entity\Book;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Persistence\ObjectManager;
class AppFixtures extends Fixture
{
public function load(ObjectManager $manager): void
{
// Création d'une vingtaine de livres ayant pour titre
for ($i = 0; $i < 20; $i++) {
$livre = new Book;
$livre->setTitle('Livre ' . $i);
$livre->setCoverText('Quatrième de couverture numéro : ' . $i);
$manager->persist($livre);
}
$manager->flush();
}
}Une fois le code écrit, il faut l’exécuter, et pour cela, tapez en ligne de commande php bin/console doctrine:fixtures:load .
Si tout s’est bien passé, alors allez vérifier dans votre base de données (par exemple avec phpMyAdmin, ou un plugin dans votre éditeur de code favori) : vous devriez voir vos données.
En résumé
Initialiser un projet Symfony se fait simplement grâce à l'exécutable Symfony.
Lorsqu'un outil ou une bibliothèque est manquant, il peut s'installer grâce à la ligne de commandes et l'exécutable "composer".
La création d'une entité est la première étape pour mettre à jour la base de données.
Les fixtures sont un moyen pratique de remplir votre base de données avec un jeu de fausses données pour faciliter les tests.
Et voici pour ce chapitre ! Nous avons désormais une application Symfony minimale avec une entité Book , et même des données à l’intérieur. Tout est désormais prêt pour rentrer dans le vif du sujet et écrire notre toute première API !
