9 juin 2024
Créer une API avec Symfony
Dans cette formation, nous allons voir comment créer une API avec le framework Symfony.
Avant de commencer, une API c'est quoi ?
Une API (application programming interface ou « interface de programmation d'application ») est une interface logicielle qui permet de « connecter » un logiciel ou un service à un autre logiciel ou service afin d'échanger des données et des fonctionnalités.
Souvent, on utilise une API pour connecter une partie front-end à une partie back-end. Prenons par exemple, le cas de JavaScript. En effet, JavaScript ne peut interagir avec une base de données. D’où l'utilité d'une API, on récupérera les données qui sont dans notre base de données, puis nous les rendrons accessibles au format JSON ou XML pour que notre code JavaScript puisse interagir avec nos différentes données.
Une API se forme comme suit au format JSON :
[
{
"id"
:
"reserved"
,
"title"
:
""
,
"start"
:
"2024-03-06"
,
"end"
:
"2024-03-11"
,
"color"
:
"#f50202"
,
"display"
:
"background"
,
}
]
NB : Les crochets ne sont pas obligatoires, on peut rencontrer des cas où ce sont des accolades.
Chaque donnée comprise entre les accolades est considérée comme une seule ligne de données, si nous venions à en avoir plusieurs, une nouvelle paire d'accolades s'ouvriraient.
[
{
"id"
:
"reserved"
,
"title"
:
""
,
"start"
:
"2024-03-06"
,
"end"
:
"2024-03-11"
,
"color"
:
"#f50202"
,
"display"
:
"background"
,
},
{
"id"
:
"reserved2"
,
"title"
:
""
,
"start"
:
"2024-03-06"
,
"end"
:
"2024-03-11"
,
"color"
:
"#f50202"
,
"display"
:
"background"
,
}
]
Au format XML voici la forme que ça aurait :
<?xml
version
=
"1.0"
encoding
=
"ISO-8859-1"
?>
<memo>
<de>
John
</de>
<a>
Bob
</a>
<contenu>
<titre>
Bonjour
</titre>
<texte>
Ca va ?
</texte>
</contenu>
</memo>
Le plus rependu reste le format JSON. Nous allons donc créer une API sous ce format.
Créons l'entité API qui sera là pour créer notre base de données :
#[ORMId]
#[ORMGeneratedValue]
#[ORMColumn]
private
?
int
$id
=
null
;
#[ORMColumn(
type
:
Types
::BIGINT)]
private
?
string
$participants
=
null
;
#[ORMColumn(
length
:
100
)]
private
?
string
$societe
=
null
;
#[ORMColumn(
type
:
Types
::DATE_MUTABLE)]
private
?
DateTimeInterface
$date_Reservation
=
null
;
Puis exportons notre nouvelle base dans notre SQL avec les commandes symfony console m:mig
et symfony console d:m:m
:
Et j'y est entrée quelques informations à la main :
Maintenant, que nous avons cela, nous sommes prêts à créer notre API ! Créons un contrôleur qui aura une route destinée pour notre API :
class
APIController
extends
AbstractController
{
#[Route(
'/a/p/i'
,
name
:
'app_a_p_i'
)]
public
function
index
():
Response
{
return
$this
->
render
(
'api/index.html.twig'
, [
]);
}
}
Par défaut, on constate que notre fonction index()
demande une réponse, dans le cas présent d'un return
$this
->
render
()
c'est correct, dans le cas d'une API ce ne les plus. Il faut changer Response
par JsonResponse
et supprimer le return
actuel, nous en appellerons un autre au moment voulu.
Vous devriez avoir ceci :
class
APIController
extends
AbstractController
{
#[Route(
'/a/p/i'
,
name
:
'app_a_p_i'
)]
public
function
index
():
JsonResponse
{
}
}
NB : Le JsonResponse
est souligné en rouge c'est normal.
Récupérons les données de notre table SQL avec un findAll
()
qui interagit avec notre répertoire API directement (nous aurions pu passer par un constructeur, mais restons simple pour l'apprentissage) :
class
APIController
extends
AbstractController
{
#[Route(
'/a/p/i'
,
name
:
'app_a_p_i'
)]
public
function
index
(
APIRepository
$aPIRepository
):
JsonResponse
{
$api
=
$aPIRepository
->
findAll
();
}
}
Si on vient à dump $api
nous aurons donc nos trois (3) entrées :
Nous sommes bons jusqu'à présent. En réalité, nous avons presque terminé. Dans notre cas, la structure du SQL est basique et adaptée pour être mise au format JSON, dans certains cas, il va falloir manipuler la structure pour rendre le tout cohérent à nos attentes (nous allons faire cela !).
Pour cela, nous devrons parcourir toutes les itérations possible grâce à un foreach
()
et nous allons créer chaque ligne manuellement :
class
APIController
extends
AbstractController
{
#[Route(
'/a/p/i'
,
name
:
'app_a_p_i'
)]
public
function
index
(
APIRepository
$aPIRepository
):
JsonResponse
{
$api
=
$aPIRepository
->
findAll
();
foreach
(
$api
as
$row
){
$data
[
"participant"
] =
$row
->
getParticipants
();
$data
[
"societe"
] =
$row
->
getSociete
();
$data
[
"date"
] =
$row
->
getDateReservation
();
$datas
[] =
$data
;
}
}
}
Le résultat si on viens à dump $datas
[]
:
Là nous sommes officiellement prêt à afficher notre API au format JSON. Il ne reste plus qu'à faire un return
:
class
APIController
extends
AbstractController
{
#[Route(
'/a/p/i'
,
name
:
'app_a_p_i'
)]
public
function
index
(
APIRepository
$aPIRepository
):
JsonResponse
{
$api
=
$aPIRepository
->
findAll
();
foreach
(
$api
as
$row
){
$data
[
"participant"
] =
$row
->
getParticipants
();
$data
[
"societe"
] =
$row
->
getSociete
();
$data
[
"date"
] =
$row
->
getDateReservation
();
$datas
[] =
$data
;
}
return
$this
->
json
(
$datas
);
}
}
Et voici le résultat en brut :
À chaque fois qu'une application utilisera votre lien qui contient votre API, vous pourrez interagir avec et l'utiliser. Dans cette formation, nous avons seulement utilisé le format GET, c'est-à-dire, récupérer les données.
J'espère que vous aurez appris des choses !
Mots clés:
php symfony api
Cours Du Dev
Recevez les dernières formations disponibles en vous inscrivant à la newsletter
Créé par arkunis