Comment créer une API avec Pure PHP ?

Dans ce projet, nous allons créer une API simple utilisant uniquement PHP dans n'importe quel framework. Tout ce dont nous aurons besoin sera :

• PHP - Essentiel
• Compositeur - Essentiel
• Éditeur/IDE comme VScode ou PHPStorm
• Docker - Préféré mais pas indispensable
• Facteur - Privilégié, mais pas indispensable

Commençons par définir notre fichier docker-compose.yml pour la configuration de notre base de données. Si vous ne souhaitez pas utiliser Docker pour créer une base de données dans des conteneurs, une solution consiste à installer la base de données sur votre machine. Pour ce tutoriel, nous utiliserons MySQL.

Paramètres

Après avoir créé le dossier où se trouvera notre application, on commence par configurer docker-compose.yaml :

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Divisons ce fichier en parties pour explication :

services:
  mysql:

Dans ce fichier nous définissons les services qui seront utilisés.
Je nomme ce service mysql. Attention, le nom de ce service sera utilisé pour se connecter à la base de données en tant qu'hébergeur

image: mysql:9.1.0

Ensuite, je définis quelle image sera utilisée pour créer notre base de données, pour ce projet j'utilise la version 9.1.0 de mysql.
Vous pouvez trouver cette version et d'autres versions sur Docker Hub.

ports:
      - '3306:3306'

Le port est défini sur 3306. C'est le port MySQL par défaut !

Vous pouvez remarquer que le port est comme 3306:3306, cela : signifie que nous voulons écouter ce port sur notre machine locale et pas seulement sur le conteneur docker, afin que nous puissions y accéder directement sur notre machine.

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

En tant qu'environnement, nous devons définir les informations d'identification de notre service MySQL.
Par conséquent, nous définissons l'utilisateur, le mot de passe et le nom de la base de données à l'aide de variables d'environnement :

MYSQL_USER: api_user // <--- Este é nosso usuário

MYSQL_PASSWORD: api_password // <--- Este é nosso password

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

MYSQL_ROOT_PASSWORD: useroot // <--- Está é a senha para o usuário root

Pour démarrer notre conteneur, soyez simplement dans le dossier où se trouve le fichier docker-compose.yaml et tapez la commande suivante dans notre terminal :

docker compose up -d

Cela initialisera le service mysql dans notre conteneur.
Si vous souhaitez accéder à MySQL depuis le terminal, vous pouvez utiliser cette commande :

docker exec -it <nome do container> bash

Après avoir tapé cette commande et appuyé sur Entrée, vous entrerez dans le conteneur dans lequel l'image MySQL est exécutée.

Le nom du conteneur est formé par nom de dossier-nom d'hôte-numéro
Dans ce cas, le nom de notre conteneur serait : create-api-php-mysql-1 si notre application a été créée dans le répertoire "create-api-php".

Nous allons également créer un fichier composer.json, ce fichier servira de base à l'installation des bibliothèques externes qui seront utilisées dans le projet. Dans ce projet, nous utiliserons uniquement Dotenv.

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Dans cette ligne, nous ajoutons la bibliothèque la plus utilisée pour dotenv en php.
Vous pouvez trouver le référentiel de cette bibliothèque sur : Github Vlucas Repository

services:
  mysql:

Dans la ligne ci-dessous, nous disons essentiellement que nous utiliserons le chargement automatique avec la configuration par défaut du PSR-4. Les PSR les plus utilisés actuellement sont le PSR-12 et le PSR-4, le 12 étant le plus utilisé à ce jour. Mais pour l'instant, nous continuerons à utiliser le PSR-4.

image: mysql:9.1.0

Avec ces deux fichiers créés nous pouvons donner la commande

ports:
      - '3306:3306'

Il installera la bibliothèque Dotenv et configurera les paramètres du PSR souhaité.
Après cette commande, le fichier composer.lock.

sera créé dans notre environnement

Pour ceux qui viennent du monde JavaScript, ces fichiers peuvent être comparés à package.json et package-lock.json.

Vous verrez également qu'un dossier a été ajouté à votre répertoire avec le nom supplier. Il contient notre lib Dotenv ainsi qu'un fichier très important : autoload.php.
Nous n'avons pas besoin de toucher ou de modifier quoi que ce soit dans ce fichier, car il sera responsable de la transaction des informations Dotenv entre nos autres fichiers.

Nous allons également créer un fichier appelé bootstrap.php, ce fichier est chargé d'initialiser notre application et de connecter certains paramètres importants pour que tout fonctionne comme prévu :

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Nous pouvons ensuite créer le fichier .env pour ajouter les variables d'environnement qui se chargeront de la connexion à notre base de données mysql.
On ajoute alors :

MYSQL_USER: api_user // <--- Este é nosso usuário

Nous créerons également un fichier .env.example où une copie de ces informations sera enregistrée au cas où quelqu'un voudrait cloner notre référentiel ou même pour nous à l'avenir si nous voulons continuer notre projet, de cette façon nous aurons les informations nécessaires pour savoir ce que nous devons définir et ce dont nous n'avons pas besoin.

MYSQL_PASSWORD: api_password // <--- Este é nosso password

La raison pour laquelle nous allons créer ces deux fichiers, l'un contenant toutes les informations et l'autre ne contenant qu'une partie des informations, est que le fichier .env ne doit pas être téléchargé dans le référentiel, car il contient des informations confidentielles. Disons qu'à l'avenir, nous souhaitons utiliser une API tierce où nous devons ajouter un jeton pour l'accès, puis nous stockerons ces informations dans le fichier .env.

Pour empêcher le téléchargement du fichier .env dans notre référentiel, nous allons créer un fichier appelé .gitignore et ajouter les informations suivantes :

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

De cette façon, nous définissons que le fichier .env et tout le contenu du dossier du fournisseur ne seront pas validés.

Avec cela, nous avons fini de configurer notre projet et sommes libres de continuer à coder.

Codification

Nous allons créer les répertoires suivants src/System et dans System le fichier DatabaseConnector.php

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Ici, nous définissons un espace de noms pour ce fichier, afin que nous puissions l'utiliser à l'avenir dans d'autres fichiers.

services:
  mysql:

Nous allons créer notre classe avec le même nom que le fichier et créer une variable privée avec le nom $dbConnection passant la valeur null.
Cette variable sera responsable d'une nouvelle instance de cette classe et nous connectera à la base de données.
Nous en verrons plus plus tard lorsque nous implémenterons try-catch.

image: mysql:9.1.0

Dans le constructeur, nous allons créer les variables suivantes et vérifier les valeurs capturées à partir du fichier .env avec Dotenv.

ports:
      - '3306:3306'

Toujours à l'intérieur du constructeur nous allons faire un try-catch pour valider l'action que nous voulons effectuer :

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Dans cet essai, nous essayons de créer une nouvelle instance de notre classe et de la transmettre à la variable $dbConnection. Nous utilisons pour cela un module PDO où il reçoit les paramètres

• DSN - Nom de la source de données ou URI
• - mysql : Étant le service/banque que nous utilisons.
• - hôte=$hôte; Notre Hôte
• - port=$port; Notre porte
• - charset=utf8mb4; Définition du charset utf8 pour la base de données
• - dbname=$db Le nom de notre base de données
• UTILISATEUR - Utilisateur pour se connecter à la base de données
• PASS - Mot de passe de connexion à la base de données

Cas d'erreur :

MYSQL_USER: api_user // <--- Este é nosso usuário

Nous déclencherons une exception de PDO et renverrons le message d'erreur.
Il s’agit clairement d’un exemple de la manière dont nous devrions présenter les erreurs dans un environnement de développement. Pour les environnements de production, il est recommandé de présenter des erreurs plus concises qui nous aident à comprendre le problème plus clairement.

En dehors du constructeur mais à l'intérieur de notre classe, nous allons créer la fonction suivante :

MYSQL_PASSWORD: api_password // <--- Este é nosso password

Être responsable de l'appel de notre variable contenant l'instance de notre connexion.

Vous vous souvenez de notre fichier bootstrap.php ? Ajoutons-y les lignes de code suivantes :

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

Ressemble à ceci :

MYSQL_ROOT_PASSWORD: useroot // <--- Está é a senha para o usuário root

Dans le dossier src nous allons créer un autre répertoire avec le nom Database et à l'intérieur le fichier database_seed.php.
Ce fichier sera chargé de remplir notre base de données pour la première fois, donc si nous voulons partager ce projet avec quelqu'un, il ne se retrouvera pas avec une base de données vide.

À l'intérieur de ce fichier, nous ajouterons les codes suivants :

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Nous importons require 'bootstrap.php' ; car dans notre fichier d'amorçage, nous avons déjà importé la variable responsable de l'instanciation de notre base de données.

services:
  mysql:

Nous créons une variable avec le nom $statement qui a une valeur de Heredoc

image: mysql:9.1.0

À l'intérieur de ce Heredoc nous ajouterons quelques requêtes :

ports:
      - '3306:3306'

Ici j'opte pour drop table pour supprimer toute la base puis en démarrer une nouvelle, cependant si vous le souhaitez vous pouvez supprimer cette ligne de code.

La ligne de code suivante précise que cette table servira à réaliser des transactions et aura une connexion entre les tables. Si vous souhaitez en savoir plus sur cette déclaration mysql : documentation innoDb

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Au sein du même Heredoc nous ajouterons une autre requête :

MYSQL_USER: api_user // <--- Este é nosso usuário

Ici, nous insérons quelques données dans la table des personnes.

On crée un try-catch à la fin du fichier où on essaie d'initialiser les requêtes et en cas d'erreur on renvoie un message d'erreur comme on l'a fait dans le traitement des données dans les codes ci-dessus .

MYSQL_PASSWORD: api_password // <--- Este é nosso password

À l'intérieur de src nous allons créer un autre répertoire avec le nom TableGateways et à l'intérieur nous créerons le fichier : PersonGateway.php.

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

Les fichiers contenus dans ce dossier seront chargés d'interagir avec notre base de données, presque comme un référentiel.

Dans notre classe PersonGateway nous ajouterons le constructeur suivant :

MYSQL_ROOT_PASSWORD: useroot // <--- Está é a senha para o usuário root

Nous ajouterons ce constructeur car notre classe sera appelée dans d'autres fichiers afin que nous puissions déclencher certaines méthodes de notre classe.

Voir les méthodes suivantes :

Méthode chargée de lister tous les utilisateurs dans notre tableau

docker compose up -d

Méthode responsable de lister un seul utilisateur de notre table

docker exec -it <nome do container> bash

Méthode responsable pour insérer un utilisateur dans notre table

{
  "require": {
      "vlucas/phpdotenv": "^2.4"
  },
  "autoload": {
      "psr-4": {
          "Src\": "src/"
      }
  }
}

Méthode responsable de la mise à jour des informations d'un utilisateur dans notre tableau

"require": {
      "vlucas/phpdotenv": "^2.4"
},

Méthode responsable de la suppression d'un utilisateur de notre table

"autoload": {
      "psr-4": {
          "Src\": "src/"
      }
  }

Nous allons créer au sein de src un répertoire avec le nom Controller et à l'intérieur le fichier : PersonController.php.
Les fichiers de ce répertoire sont chargés d'interagir avec notre route d'application. Ici, nous interagissons directement avec la banque, mais nous pourrions utiliser une couche de services et limiter toute la logique et les règles métier à cette couche.
Si vous souhaitez créer la couche services, ce serait comme ceci :

services:
  mysql:
    image: mysql:9.1.0
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Cependant, notre intention n'est pas d'approfondir ce type d'architecture, pour l'instant nous allons continuer avec le fichier du contrôleur :

services:
  mysql:

Dans notre classe PersonController, nous ajouterons :

image: mysql:9.1.0

De cette façon, nous garantissons que nous interagissons avec une nouvelle instance de notre base de données.

Nous avons également créé une méthode pour traiter nos demandes :

ports:
      - '3306:3306'

Ce en-tête est chargé de transmettre le code d'état et si un corps est créé, il renvoie ce même corps pour être visualisé.

environment:
      MYSQL_ROOT_PASSWORD: useroot
      MYSQL_USER: api_user
      MYSQL_PASSWORD: api_password
      MYSQL_DATABASE: api_example

Nous avons également créé les méthodes qui vont interagir avec les itinéraires :

Méthode chargée d'interagir avec l'itinéraire de référencement de l'utilisateur

MYSQL_USER: api_user // <--- Este é nosso usuário

Méthode chargée d'interagir avec l'itinéraire de création de l'utilisateur

MYSQL_PASSWORD: api_password // <--- Este é nosso password

Méthode responsable de l'interaction avec l'itinéraire de mise à jour de l'utilisateur

MYSQL_DATABASE: api_example // <--- Este é nosso banco de dados

Méthode responsable de l'interaction avec la route de suppression de l'utilisateur

MYSQL_ROOT_PASSWORD: useroot // <--- Está é a senha para o usuário root

Méthodes responsables de la validation

docker compose up -d

docker exec -it <nome do container> bash

{
  "require": {
      "vlucas/phpdotenv": "^2.4"
  },
  "autoload": {
      "psr-4": {
          "Src\": "src/"
      }
  }
}

Enfin, nous allons créer un répertoire en dehors de notre dossier src avec le nom Public.
Ce dossier est chargé de contenir le fichier d'affichage php.
Nous allons créer le fichier à l'intérieur : index.php
Nous ajouterons le code suivant :

"require": {
      "vlucas/phpdotenv": "^2.4"
},

Ce fichier est chargé de définir les en-têtes et de vérifier l'accès à l'url. Si l'accès réussit, il renvoie le contenu, sinon il renvoie une erreur.

Pour accéder à votre application, téléchargez simplement un serveur en utilisant le serveur PHP interne :

"autoload": {
      "psr-4": {
          "Src\": "src/"
      }
  }

si vous n'avez pas initialisé le conteneur, tapez la commande suivante dans le terminal :

composer install

Maintenant, utilisez simplement Postman ou toute autre application qui vous aide à interagir avec l'URL.

Mes réseaux sociaux :
Github Linkedin

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!