Comment créer un serveur API en utilisant PHP

Avec le développement rapide du mobile, du cloud computing, de l'Internet des objets et d'autres technologies, les API sont devenues un moyen important d'interaction de données entre diverses applications et systèmes. Dans le domaine du développement Web, PHP, en tant que langage back-end populaire, fournit de nombreuses bibliothèques et frameworks qui facilitent la mise en œuvre d'API. Cet article expliquera comment utiliser PHP pour créer un serveur API et partager l'ensemble du processus, de la conception à la mise en œuvre.

1. Analyse des exigences et idées de conception

Avant de mettre en œuvre le serveur API, nous devons clarifier les exigences et les idées de conception. Cet article implémente un serveur API simple, et ses exigences peuvent être résumées comme suit :

1. prend en charge le protocole HTTP et peut gérer GET, POST et d'autres requêtes ;
2. peut analyser les paramètres d'URL et implémenter l'API RESTful ; Format JSON ;
3. Prend en charge l'autorisation OAuth2 pour protéger la sécurité de l'API.
4. Afin de répondre aux exigences ci-dessus, nous pouvons envisager les idées de conception suivantes :

Utilisez le package d'extension PHP Slim ou Lumen pour créer le serveur API. Ils fournissent un bon routage, un middleware, des contrôleurs et d'autres outils de programmation structurés. Mécanisme de plug-in riche ;

1. Analyser les paramètres d'URL dans les routes et utiliser le framework OAuth2 pour protéger la sécurité de l'API 
2. Obtenir les paramètres de requête dans le contrôleur, appeler le modèle pour accéder à la base de données ou à d'autres sources de données et générer des données au format JSON ; .
3. 2. Construire un environnement de développement

Avant de construire le serveur API, nous devons préparer les environnements de développement nécessaires tels que PHP et MySQL. Vous pouvez choisir d'utiliser un environnement de développement intégré (IDE) tel que PHPStorm, Eclipse, etc., ou vous pouvez utiliser un éditeur léger tel que Visual Studio Code, Sublime Text, etc. Cet article prend PHPStorm comme exemple.

Installer PHPStorm et l'environnement PHP : Téléchargez PHPStorm Pendant le processus d'installation, vous serez invité à installer l'environnement PHP par défaut, ou vous pouvez choisir vous-même le chemin d'installation. Une fois l'installation terminée, exécutez PHPStorm, ouvrez les Préférences et ajoutez l'interpréteur PHP dans Langages et frameworks > PHP.

1. Installer MySQL : Téléchargez et installez MySQL, créez et configurez la base de données.
2. Installer Composer : Composer est un gestionnaire de dépendances pour PHP, qui peut grandement simplifier le travail de développement PHP. Exécutez la commande suivante dans la ligne de commande pour installer Composer :

3. php -r "readfile('https://getcomposer.org/installer');" | php

Une fois l'installation terminée, déplacez composer.phar vers un chemin disponible globalement, tel que /usr/bin/composer.

3. Construisez le serveur API

Avec l'environnement de développement ci-dessus, nous pouvons commencer à construire le serveur API.

Créer un projet : Créez un nouveau projet PHP dans PHPStorm et utilisez Composer pour installer le framework Slim ou Lumen :

1. composer require slim/slim

ou

composer require illuminate/routing illuminate/http

Remarque : Si vous choisissez d'utiliser le framework Lumen, vous devez l'installer dans le Fichier bootstrap/app.php Activez les commutateurs $app->withFacades() et $app->withEloquent() pour utiliser les fonctions Facade et Eloquent ORM fournies par Lumen.

Création de routes : la création de routes et de middleware est facile dans le framework Slim ou Lumen. Créez le fichier routes.php dans le répertoire racine, par exemple :

2. $app->get('/hello/{name}', function ($request, $response, $args) {
       $name = $args['name'];
       $response->getBody()->write("Hello, $name");
       return $response;
   });
   
   $app->get('/users', 'UsersController:index');
   
   $app->post('/users', 'UsersController:create');

Trois routes sont définies ici :

/hello/{name} : accepte un paramètre name et renvoie la chaîne "Bonjour, nom" ; /users : requête GET, appelle la méthode d'index de UsersController, renvoie toutes les données utilisateur ;

• /users : requête POST, appelle la méthode create de UsersController, crée un nouvel enregistrement utilisateur.
• Créer un middleware : l'ajout d'un middleware au routage peut implémenter certains prétraitements, filtrages, autorisations et autres fonctions. Créez le fichier middleware.php dans le répertoire racine, par exemple :

$app->add(new JwtAuthMiddleware());

Un middleware JwtAuthMiddleware est défini ici pour vérifier le token et les autorisations autorisées par OAuth2.

Créer un contrôleur : créez un fichier de contrôleur, tel que UsersController.php, dans le répertoire racine pour implémenter toutes les méthodes définies par la route. La structure du code du contrôleur peut faire référence à l'exemple suivant :

namespace App\Controllers;

use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Message\ResponseInterface as Response;
use App\Models\User;

class UsersController {
    
    public function index(Request $request, Response $response) {
        $users = User::all();
        $response = $response->withJson($users);
        return $response;
    }
    
    public function create(Request $request, Response $response) {
        $data = $request->getParsedBody();
        $user = new User;
        $user->name = $data['name'];
        $user->email = $data['email'];
        $user->password = password_hash($data['password'], PASSWORD_DEFAULT);
        $user->save();
        $response = $response->withJson($user);
        return $response;
    }
    
}

Un contrôleur UsersController est défini ici, y compris les méthodes index et create, qui correspondent respectivement aux requêtes /users GET et /users POST. Utilisez Eloquent ORM pour exploiter la table de données utilisateur (User::all() et $user->save()) et renvoyer une réponse au format JSON.

Exécutez le serveur API : entrez le répertoire du projet sur la ligne de commande et exécutez la commande suivante :

php -S localhost:8000 -t public

Un serveur Web PHP intégré est démarré ici, en écoute sur le port 8000. Accédez à http://localhost:8000/hello/world dans le navigateur Dans des circonstances normales, la chaîne « Hello, world » doit être renvoyée. Lors de l'accès à http://localhost:8000/users, les données au format JSON de tous les utilisateurs doivent être renvoyées.
5. 4. Autorisation OAuth2

Par défaut, le serveur API n'est pas sécurisé car n'importe qui peut accéder à l'interface et modifier les données. Pour sécuriser l'API, nous pouvons utiliser l'autorisation OAuth2. OAuth2 est un protocole d'autorisation standard qui peut autoriser des applications tierces à accéder aux ressources protégées d'un utilisateur spécifique sur un serveur de ressources sans révéler le nom d'utilisateur et le mot de passe. Dans cet article, nous utilisons le framework JWT de Firebase pour implémenter l'autorisation OAuth2.

Installez le framework Firebase JWT : Utilisez Composer pour installer le framework Firebase JWT :

composer require firebase/php-jwt

1. Créez un serveur d'autorisation : Créez le fichier AuthorizationServer.php dans le répertoire racine, par exemple :

namespace App;

use Firebase\JWT\JWT;
use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Message\ResponseInterface as Response;
use App\Models\User;

class AuthorizationServer {
    
    private static $key = 'your_secret_key';
    
    public static function getToken(Request $request, Response $response) {
        $data = $request->getParsedBody();
        $user = User::where('email', $data['email'])->first();
        if (!$user || !password_verify($data['password'], $user->password)) {
            return $response->withStatus(401)->withJson([
                'error' => 'Invalid email or password.'
            ]);
        }
        $now = time();
        $payload = array(
            'iat' => $now,
            'exp' => $now + 3600,
            'sub' => $user->id
        );
        $jwt = JWT::encode($payload, self::$key);
        
        return $response->withJson([
            'access_token' => $jwt,
            'token_type' => 'Bearer',
            'expires_in' => 3600
        ]);
    }
    
    public static function authenticate(Request $request) {
        $jwt = isset($request->getHeader('Authorization')[0]) ? explode(' ', $request->getHeader('Authorization')[0])[1] : null;
        if (!$jwt) {
            throw new Exception('Unauthorized.');
        }
        try {
            $decoded = JWT::decode($jwt, self::$key, array('HS256'));
            $user = User::find($decoded->sub);
            if (!$user) {
                throw new Exception('Unauthorized.');
            }
            return $user;
        } catch (Exception $e) {
            throw new Exception('Unauthorized.');
        }
    }
    
}

Un serveur d'autorisation AuthorizationServer est défini ici, comprenant deux Méthode :
2. • getToken：接受客户端传递的email和password，生成access token并返回给客户端；
   • authenticate：接受客户端传递的access token，验证并返回用户对象。

   这里使用了JWT加密框架，将用户信息存储在token中，并使用HS256算法加密。

   3. 创建中间件：在根目录下创建中间件文件JwtAuthMiddleware.php，例如：

   namespace App\Middlewares;
   
   use Psr\Http\Message\ServerRequestInterface as Request;
   use Psr\Http\Message\ResponseInterface as Response;
   use App\AuthorizationServer;
   
   class JwtAuthMiddleware {
       
       public function __invoke(Request $request, Response $response, $next) {
           try {
               $user = AuthorizationServer::authenticate($request);
               $request = $request->withAttribute('user', $user);
               return $next($request, $response);
           } catch (Exception $e) {
               return $response->withStatus(401)->withJson([
                   'error' => $e->getMessage()
               ]);
           }
       }
       
   }

   这里定义了一个JwtAuthMiddleware中间件，用户验证客户端请求的access token的有效性，并在后面的控制器中通过$request->getAttribute('user')获取到用户对象。

   4. 更新路由：在路由中加入OAuth2授权相关的路由和中间件。在routes.php文件中增加以下代码：

   $app->post('/auth/token', 'AuthorizationServer:getToken');
   
   $app->group('', function () use ($app) {
       $app->get('/users/@id', 'UsersController:getUser');
       $app->put('/users/@id', 'UsersController:updateUser');
       $app->delete('/users/@id', 'UsersController:deleteUser');
   })->add(new JwtAuthMiddleware());

   这里定义了一个/auth/token路由，用于获取访问令牌。另外，对于需要OAuth2授权的路由（getUser、updateUser和deleteUser），使用$app->group()方法包裹其中，并添加JwtAuthMiddleware中间件。

   五、总结

   本文介绍了如何使用PHP搭建API服务器，基于Slim或Lumen框架，解析URL参数、返回JSON格式的数据，并使用OAuth2框架保护API的安全性。使用这种方式搭建API服务器，可以快速、高效地开发出各种类型的RESTful API。但是，具体实现还需要根据实际需求进行适当调整和优化。

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!