Apprenez à créer des API RESTful à l'aide de PHP et MySQL

Avec le développement du développement Web, l'API RESTful est devenue l'un des standards des applications Web modernes. Par rapport aux API traditionnelles, les API RESTful sont plus flexibles et évolutives. PHP et MySQL, en tant qu'outils de développement Web largement utilisés, peuvent également être utilisés pour créer des API RESTful. Cet article présentera en détail comment créer une API RESTful à l'aide de PHP et MySQL, et fournira des exemples de code et des considérations.

1. Introduction à l'API RESTful

L'API RESTful est un formulaire de conception d'API Web basé sur le protocole HTTP et le format de données standard. Il utilise généralement des verbes HTTP (GET, POST, PUT, DELETE, etc.) pour opérer sur les ressources et utilise des codes d'état HTTP pour représenter les résultats de l'opération. Les principes de conception de l'API RESTful incluent les ressources, le transfert d'état de représentation, l'interface unifiée, l'auto-confinement et l'hypermédia.

2. Créez une API RESTful en utilisant PHP et MySQL

1. Installez et configurez PHP et MySQL

Vous devez d'abord installer et configurer PHP et MySQL, qui ne seront pas décrits ici. Une fois l'installation terminée, vous pouvez utiliser la fonction phpinfo pour vérifier si PHP fonctionne correctement, ou créer une base de données de test dans MySQL pour vérifier si MySQL fonctionne correctement.

2. Créez la structure de base de l'API RESTful

Ensuite, vous devez créer la structure de base de l'API RESTful. La première est la connexion à la base de données, à l'aide du code suivant :

<?php
 
//数据库连接参数 
define('DB_HOST', 'localhost'); 
define('DB_USER', 'root'); 
define('DB_PASS', ''); 
define('DB_NAME', 'test');
 
//建立数据库连接 
function connect() {
    $mysqli = new mysqli(DB_HOST, DB_USER, DB_PASS, DB_NAME);
    if(mysqli_connect_errno()) {
        die("Database connection failed: " . mysqli_connect_error());
    }
    return $mysqli;
}
 
//关闭数据库连接 
function disconnect($mysqli) {
    $mysqli -> close();
}
 
?>

Il est à noter que la connexion mysqli orientée objet est utilisée ici à la place de la méthode de connexion mysql traditionnelle.

Ensuite, vous devez créer une classe API RESTful de base, qui définit le comportement des requêtes et des réponses HTTP. Quatre verbes HTTP sont définis ici : GET, POST, PUT et DELETE. Utilisez le code suivant :

<?php
 
require_once('db_connect.php');
 
class Rest {
 
    protected $request;
    protected $mysqli;
    protected $method;
    protected $args;
    protected $resource = '';
    protected $statusCodes = array(
        200 => 'OK',
        201 => 'Created',
        202 => 'Accepted',
        204 => 'No Content',
        400 => 'Bad Request',
        401 => 'Unauthorized',
        403 => 'Forbidden',
        404 => 'Not Found',
        406 => 'Not Acceptable',
        500 => 'Internal Server Error'
    );
 
    public function __construct() {
        $this -> mysqli = connect();
        $this -> request = explode('/', trim($_SERVER['PATH_INFO'], '/'));
        $this -> method = $_SERVER['REQUEST_METHOD'];
        $this -> args = $_SERVER['QUERY_STRING'];
        $this -> resource = array_shift($this -> request);
    }
 
    public function processRequest() {
 
        switch($this -> method) {
            case 'POST':
                $response = $this -> create();
                break;
            case 'PUT':
                $response = $this -> update();
                break;
            case 'DELETE':
                $response = $this -> delete();
                break;
            case 'GET':
            default:
                $response = $this -> read();
                break;
        }
 
        header('HTTP/1.1 ' . $this -> statusCodes[$response['status']]);
        header('Content-Type: application/json; charset=utf-8');
 
        return json_encode($response['data']);
    }
 
    protected function create() {}
    protected function read() {}
    protected function update() {}
    protected function delete() {}
 
}
 
?>

Le constructeur de cette classe analysera la méthode, le chemin et les paramètres dans la requête HTTP et les enregistrera dans les propriétés de l'objet. Appelez ensuite la méthode correspondante selon la méthode HTTP pour traiter la requête.

3. Implémentez les opérations CRUD de l'API RESTful

Ensuite, vous devez implémenter les opérations CRUD dans la classe API RESTful. En prenant l'utilisateur comme exemple, utilisez le code suivant :

class UserAPI extends Rest {
 
    public function create() {
        $data = json_decode(file_get_contents("php://input"), true);
        $username = $data['username'];
        $password = $data['password'];
        $email = $data['email'];
 
        if(!empty($username) && !empty($password) && !empty($email)) {
            $stmt = $this -> mysqli -> prepare("INSERT INTO users (username, password, email) VALUES (?, ?, ?)");
            $stmt -> bind_param("sss", $username, $password, $email);
            $stmt -> execute();
            $stmt -> close();
            $response['status'] = 201;
            $response['data'] = "User created successfully.";
        } else {
            $response['status'] = 400;
            $response['data'] = "Invalid parameters.";
        }
 
        return $response;
    }
 
    public function read() {
        $id = array_shift($this -> request);
        if(empty($id)) {
            $result = $this -> mysqli -> query("SELECT * FROM users");
            while($row = $result -> fetch_assoc()) {
                $data[] = $row;
            }
            $response['status'] = 200;
            $response['data'] = $data;
        } else {
            $result = $this -> mysqli -> query("SELECT * FROM users WHERE id = $id");
            if($result -> num_rows == 1) {
                $response['status'] = 200;
                $response['data'] = $result -> fetch_assoc();
            } else {
                $response['status'] = 404;
                $response['data'] = "User not found.";
            }
        }
        return $response;
    }
 
    public function update() {
        $id = array_shift($this -> request);
        $data = json_decode(file_get_contents("php://input"), true);
        $username = $data['username'];
        $password = $data['password'];
        $email = $data['email'];
 
        if(!empty($username) && !empty($password) && !empty($email)) {
            $stmt = $this -> mysqli -> prepare("UPDATE users SET username=?, password=?, email=? WHERE id=?");
            $stmt -> bind_param("sssi", $username, $password, $email, $id);
            $stmt -> execute();
            $stmt -> close();
            $response['status'] = 200;
            $response['data'] = "User updated successfully.";
        } else {
            $response['status'] = 400;
            $response['data'] = "Invalid parameters.";
        }
 
        return $response;
    }
 
    public function delete() {
        $id = array_shift($this -> request);
        $result = $this -> mysqli -> query("SELECT * FROM users WHERE id = $id");
        if($result -> num_rows == 1) {
            $this -> mysqli -> query("DELETE FROM users WHERE id = $id");
            $response['status'] = 200;
            $response['data'] = "User deleted successfully.";
        } else {
            $response['status'] = 404;
            $response['data'] = "User not found.";
        }
        return $response;
    }
 
}

Une classe UserAPI est définie ici et implémente les méthodes de création, de lecture, de mise à jour et de suppression. Pour les requêtes POST, les données Json seront analysées en noms d'utilisateur, mots de passe et adresses e-mail, et insérées dans la table des utilisateurs ; pour les requêtes GET, si l'URL contient le paramètre id, les informations utilisateur correspondantes seront renvoyées, sinon toutes les informations utilisateur seront être renvoyé ; pour la demande PUT, analyser les données Json en nom d'utilisateur, mot de passe et adresse e-mail, et mettre à jour les informations de l'utilisateur correspondant pour la demande DELETE, supprimer l'utilisateur correspondant en fonction du paramètre id dans l'URL ;

4. Utilisation de l'API RESTful

Après avoir créé l'API RESTful, vous pouvez utiliser des outils tels que curl pour tester si l'API fonctionne correctement. Utilisez la commande curl suivante pour créer des utilisateurs sur l'API RESTful :

curl -H "Content-Type: application/json" -X POST -d '{
    "username":"testuser",
    "password":"testpassword",
    "email":"testuser@example.com"
}' http://localhost/user

Utilisez la commande curl suivante pour renvoyer tous les utilisateurs :

curl http://localhost/user

Utilisez la commande curl suivante pour mettre à jour les informations utilisateur :

curl -H "Content-Type:application/json" -X PUT -d '{
    "username":"newusername",
    "password":"newpassword",
    "email":"newusername@example.com"
}' http://localhost/user/1

Utilisez la commande curl suivante pour supprimer des utilisateurs :

curl -X DELETE http://localhost/user/1

3. Précautions

Vous devez faire attention aux points suivants lors de la création d'une API RESTful :

1. Sécurité de la base de données. Les API RESTful doivent généralement interagir avec des bases de données, et des problèmes de sécurité tels que l'injection SQL peuvent survenir. Des requêtes paramétrées et d'autres méthodes doivent être utilisées pour garantir la sécurité des données.
2. Problèmes inter-domaines. L'API RESTful peut être appelée par des applications sous des noms de domaine différents, provoquant des problèmes entre domaines. Access-Control-Allow-Origin et d’autres en-têtes HTTP associés doivent être définis.
3. Contrôle de version API. Le contrôle de version doit être pris en compte lors de la conception des API RESTful pour éviter d'affecter les API existantes.
4. Code d'état HTTP. La valeur de retour de l'API RESTful doit utiliser correctement le code d'état HTTP pour représenter le résultat de la requête.

4. Résumé

Cet article explique comment utiliser PHP et MySQL pour créer une API RESTful et fournit des exemples de code et des précautions. Les avantages de l'API RESTful sont la flexibilité, l'évolutivité, la facilité de maintenance, etc. C'est un élément indispensable du développement Web. Lorsque vous utilisez des API RESTful, vous devez prêter attention aux problèmes tels que la sécurité, les problèmes inter-domaines, le contrôle de version et les codes d'état HTTP.

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!