PHP REST Api

Repos-api

Il s'agit d'un PHP REST-API utilisant l'authentification HTTP de base. Étant donné que l'authentification HTTP de base est codée mais non cryptée, il est fortement recommandé d'utiliser une connexion sécurisée (HTTPS) et un mot de passe fort.

Si vous utilisez cette API pour gérer les données sensibles, vous le faites à vos propres risques.

Table des matières

1. Configuration
   • Configurez une base de données MySQL
   • Lance PHP Build dans Webserver
   • Authentification
   • Définir les informations d'identification
2. Créer un service
3. Comment utiliser l'API
   • Obtenir une collection
   • Obtenez un seul article
   • Créer un nouvel élément
   • Mettre à jour un article
   • Supprimer un article
4. Utilisation prolongée
   • Effectuer des tâches spéciales
5. Codes d'état HTTP
6. Ajout de middleware
7. Auteur
8. Licence

Configuration

Configurez une base de données MySQL

Configurez un serveur MySQL et exécutez example_database.sql . Entrez les paramètres MySQL associés dans settings.php .

Lance PHP Build dans Webserver

 $ php -S localhost:2400 -t public

Authentification

L'authentification est activée par défaut. Vous pouvez le désactiver dans settings.php .

Définir les informations d'identification

Les informations d'identification ci-dessous sont actuellement codées en dur dans le middleware lib/Authentication . C'est à vous d'implémenter une logique appropriée.

 $ username = " rest " ;
$ password = " test " ;

Créer un service

Vous créez des services dans le répertoire services et le dossier de version spécifique. Un service hérite toujours de la classe de classe abstraite. Voici un modèle de base que vous pouvez utiliser pour commencer rapidement:

 use RESTapi  Sources  Request ;
use RESTapi  Sources  Response ;
use RESTapi  Sources  WebService ;
use RESTapi  Library  Database ;

class YourService extends WebService {

    private Database | null $ db ;

    public function __construct ()
    {
        $ this -> db = Database:: getInstance ();
    }

    public function get ( Request $ request , Response $ response ): void 
    {
        // Your logic here ...
        $ affectedRows = 12 ;
        $ response -> write ( " JSON " ); // Add a JSON object
        $ response -> addHeader ( " X-Data-Count " , $ affectedRows );
        $ response -> setStatus ( 200 );
    }

    public function post ( Request $ request , Response $ response ): void 
    {
        // Your logic here ...
        $ affectedRows = 12 ;
        $ response -> write ( " JSON " ); // Add a JSON object
        $ response -> addHeader ( " X-Insert-Count " , $ affectedRows );
        $ response -> setStatus ( 201 );
    }

    public function put ( Request $ request , Response $ response ): void 
    {
        // Your logic here ...
        $ affectedRows = 1 ;
        $ response -> write ( " JSON " ); // Add a JSON object
        $ response -> addHeader ( " X-Update-Count " , $ affectedRows );
        $ response -> setStatus ( 204 );
    }

    public function delete ( Request $ request , Response $ response ): void 
    {
        // Your logic here ...
        $ affectedRows = 1 ;
        $ response -> write ( " JSON " ); // Add a JSON object
        $ response -> addHeader ( " X-Delete-Count " , $ affectedRows );
        $ response -> setStatus ( 205 );
    }
}

Travailler avec la base de données:
Veuillez vérifier le service Users pour apprendre et comprendre comment créer des requêtes pour effectuer des opérations CRUD.

Comment utiliser l'API

Obtenir une collection

Utilisation: GET domain.tld/[version]/[service]

 $ ch = curl_init ( " http://localhost:2400/v1/Users/ " );
curl_setopt ( $ ch , CURLOPT_HTTPAUTH , CURLAUTH_BASIC );
curl_setopt ( $ ch , CURLOPT_USERPWD , " $ username : $ password " );
curl_setopt ( $ ch , CURLOPT_HEADER , true );

if (! $ output = curl_exec ( $ ch )) {
    trigger_error ( curl_error ( $ ch ));
}

curl_close ( $ ch );

Obtenez un seul article

Utilisation: GET domain.tld/[version]/[service]/[id]

 $ ch = curl_init ( " http://localhost:2400/v1/Users/3 " );
curl_setopt ( $ ch , CURLOPT_HTTPAUTH , CURLAUTH_BASIC );
curl_setopt ( $ ch , CURLOPT_USERPWD , " $ username : $ password " );
curl_setopt ( $ ch , CURLOPT_HEADER , true );

if (! $ output = curl_exec ( $ ch )) {
    trigger_error ( curl_error ( $ ch ));
}

curl_close ( $ ch );

Créer un nouvel élément

Utilisation: POST domain.tld/[version]/[service]

 $ body = [
    " name " => " Greta Garbo " ,
    " age " => " 93 " ,
    " city " => " Hollywood " ,
    " country " => " California "
];
$ ch = curl_init ( " http://localhost:2400/v1/Users " );
curl_setopt ( $ ch , CURLOPT_POST , true );
curl_setopt ( $ ch , CURLOPT_POSTFIELDS , http_build_query ( $ body ));
curl_setopt ( $ ch , CURLOPT_HTTPAUTH , CURLAUTH_BASIC );
curl_setopt ( $ ch , CURLOPT_USERPWD , " $ username : $ password " );
curl_setopt ( $ ch , CURLOPT_HEADER , true );

if (! $ output = curl_exec ( $ ch )) {
    trigger_error ( curl_error ( $ ch ));
}

curl_close ( $ ch );

Mettre à jour un article

Utilisation: PUT domain.tld/[version]/[service]/[id]

 $ body = [
    " name " => " John Rambo " ,
    " age " => " 42 " ,
    " city " => " Seattle " ,
    " country " => " Washington "
];
$ ch = curl_init ( " http://localhost:2400/v1/Users/4 " );
curl_setopt ( $ ch , CURLOPT_CUSTOMREQUEST , " PUT " );
curl_setopt ( $ ch , CURLOPT_POSTFIELDS , http_build_query ( $ body ));
curl_setopt ( $ ch , CURLOPT_HTTPAUTH , CURLAUTH_BASIC );
curl_setopt ( $ ch , CURLOPT_USERPWD , " $ username : $ password " );
curl_setopt ( $ ch , CURLOPT_HEADER , true );

if (! $ output = curl_exec ( $ ch )) {
    trigger_error ( curl_error ( $ ch ));
}

curl_close ( $ ch );

Supprimer un article

Utilisation: DELETE domain.tld/[version]/[service]/[id]

 $ ch = curl_init ( " http://localhost:2400/v1/Users/1 " );
curl_setopt ( $ ch , CURLOPT_CUSTOMREQUEST , " DELETE " );
curl_setopt ( $ ch , CURLOPT_HTTPAUTH , CURLAUTH_BASIC );
curl_setopt ( $ ch , CURLOPT_USERPWD , " $ username : $ password " );
curl_setopt ( $ ch , CURLOPT_HEADER , true );

if (! $ output = curl_exec ( $ ch )) {
    trigger_error ( curl_error ( $ ch ));
}

curl_close ( $ ch );

Utilisation prolongée

Effectuer des tâches spéciales

Un service hérite de quatre fonctions get , post , put et delete de la classe de service Web abstrait par défaut. Ceux-ci sont parfaits pour effectuer des actions CRUD sur une base de données. Mais que se passe-t-il si vous avez besoin d'un service qui devrait effectuer des tâches spéciales? Dans un tel cas, vous pouvez utiliser le PATCH de méthode de demande HTTP et fournir le nom de l'action dans l'URI.

Vous trouverez ci-dessous un exemple de service de caliculation qui multiplie deux nombres:

Utilisation: PATCH domain.tld/[version]/[service]/[action]

 $ ch = curl_init ( " http://localhost:2400/v1/Calculator/multiply " );
$ body = [
    " a " => 12 ,
    " b " => 2.5
];
$ ch = curl_init ( $ url );
curl_setopt ( $ ch , CURLOPT_CUSTOMREQUEST , " PATCH " );
curl_setopt ( $ ch , CURLOPT_POSTFIELDS , http_build_query ( $ body ));
curl_setopt ( $ ch , CURLOPT_HTTPAUTH , CURLAUTH_BASIC );
curl_setopt ( $ ch , CURLOPT_USERPWD , " $ username : $ password " );
curl_setopt ( $ ch , CURLOPT_HEADER , true );

if (! $ output = curl_exec ( $ ch )) {
    trigger_error ( curl_error ( $ ch ));
}

curl_close ( $ ch );

Codes d'état HTTP

L'API répond avec les codes d'état suivants. Vous pouvez changer cela à votre goût:

Sur le succès:

• Obtenez: 200 ok
• Message: 201 créée
• Put: 204 aucun contenu ou 202 accepté
• Supprimer: 205 Réinitialiser le contenu

Sinon:

• 400 MAUVAISE DEMANDE
• 401 non autorisé
• 404 introuvable
• Erreur de serveur interne 500

Ajout de middleware

Vous trouverez ci-dessous un exemple de modèle que vous pouvez utiliser pour créer votre propre middleware. Vous pouvez créer votre propre middleware en créant une classe dans le dossier lib qui implémente l'interface imiddleware :

 class YourMiddleware implements IMiddleware {

    public function handle ( Request $ request , Response $ response ): void {}
}

Pour injecter le middleware dans un autre middleware, utilisez le constructeur de ce middleware:

 class YourMiddleware implements IMiddleware {

    public function __construct ( private IMiddleware $ anotherMiddleware ) {}

    public function handle ( Request $ request , Response $ response ): void
    {
        // 1. Add your logic ...

        // 2. Handle Middleware ...
        $ this -> anotherMiddleware -> handle ( $ request , $ response );

        // 3. Do something afterwards ...
    }
}

$ anotherMiddleware = new AnotherMiddleware ();
$ yourMiddleware = new YourMiddleware ( $ anotherMiddleware );
$ yourMiddleware -> handle ( $ request , $ response );

Auteur

Martin Wolf

Licence

Mit