Utilisez le framework PHP Lumen pour développer un service API RESTful simple et facile à utiliser

Avec le développement rapide de la technologie Internet, de plus en plus d'applications commencent à utiliser les API RESTful pour la transmission et l'interaction de données. L'API RESTful est un framework léger de communication basé sur le protocole HTTP, qui présente les avantages d'une expansion facile et d'une forte compatibilité. PHP est un langage de programmation côté serveur très populaire, et il existe de nombreux excellents frameworks parmi lesquels choisir, Lumen est un framework PHP léger qui peut créer rapidement des services API RESTful.

Cet article présentera les étapes à suivre pour utiliser Lumen pour développer un service API RESTful simple et facile à utiliser. Les aspects suivants seront abordés :

1. Introduction à Lumen
2. Bases de l'API RESTful
3. Commencer à créer des services API RESTful
4. Contrôleurs d'écriture
5. Modèles d'écriture
6. Routes d'écriture
7. API de test

1. les hommes

Lumen est un micro-framework du framework Laravel, rapide et efficace. Comparé à Laravel, Lumen est plus léger et a une vitesse de réponse plus rapide. Lumen utilise Composer comme outil de gestion des dépendances, basé sur PHP 7 ou supérieur et prenant en charge l'encapsulation de l'API RESTful.

2. Connaissance de base de l'API RESTful

L'API RESTful est une méthode de transmission de données et d'interaction pour la communication basée sur le protocole HTTP. Les contraintes de base de l'API RESTful incluent :

• Modèle client/serveur
• Sans état
• Cacheable
• Interface unifiée
• Système en couches

Les méthodes HTTP couramment utilisées incluent GET, POST, PUT et DELETE. En combinant ces méthodes HTTP et chemins de ressources URL, un service API RESTful peut être créé.

3. Commencez à créer un service API RESTful

Tout d'abord, vous devez installer le framework Lumen. Entrez la commande suivante dans le terminal de ligne de commande :

composer create-project --prefer-dist laravel/lumen your-project-name

Après avoir attendu la fin de l'installation, entrez dans le répertoire du projet et créez les fichiers nécessaires tels que le contrôleur et le modèle via l'outil de ligne de commande artisanal :

php artisan make:controller YourControllerName
php artisan make:model YourModelName

Maintenant, nous avons terminé le installation du framework Lumen, et Les fichiers nécessaires sont créés pour notre prochain travail.

4. Écrire un contrôleur

Un contrôleur est une classe PHP utilisée pour traiter les requêtes et renvoyer des réponses. Dans le framework Lumen, les contrôleurs sont généralement enregistrés dans le dossier /app/Http/Controllers.

Écrivez un contrôleur pour gérer les opérations CRUD sur les données. Ici, nous supposons que nous avons une table de données utilisateur, comprenant l'identifiant, le nom, l'e-mail et d'autres champs :

<?php

namespace AppHttpControllers;

use AppModelsUser;
use IlluminateHttpRequest;
use IlluminateSupportFacadesValidator;

class UserController extends Controller
{
    public function index()
    {
        return response()->json(User::all());
    }

    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|max:255',
            'email' => 'required|email|unique:users'
        ]);

        if ($validator->fails()) {
            return response()->json($validator->errors(), 400);
        } else {
            $user = User::create([
                'name' => $request->input('name'),
                'email' => $request->input('email')
            ]);
            return response()->json($user, 201);
        }
    }

    public function update(Request $request, $id)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'max:255',
            'email' => 'email|unique:users'
        ]);

        if ($validator->fails()) {
            return response()->json($validator->errors(), 400);
        } else {
            $user = User::find($id);
            if ($user) {
                $user->name = $request->input('name');
                $user->email = $request->input('email');
                $user->save();
                return response()->json($user);
            } else {
                return response()->json(['error' => 'User not found'], 404);
            }
        }
    }

    public function show($id)
    {
        $user = User::find($id);
        if ($user) {
            return response()->json($user);
        } else {
            return response()->json(['error' => 'User not found'], 404);
        }
    }

    public function destroy($id)
    {
        $user = User::find($id);
        if ($user) {
            $user->delete();
            return response()->json(['message' => 'User deleted']);
        } else {
            return response()->json(['error' => 'User not found'], 404);
        }
    }
}

Ici, nous écrivons une classe de contrôleur nommée UserController, qui contient 5 méthodes : index, store, update, show et destroy . Elles correspondent respectivement aux cinq opérations courantes de l'API RESTful : obtention de ressources, création de ressources, mise à jour de ressources, obtention de ressources spécifiées et suppression de ressources.

Dans le code ci-dessus, nous utilisons le répondeur (response()) et le modèle (User) du framework Lumen, ainsi que le validateur (Validator) fourni par le framework Lumen. En plus de cela, vous pouvez également introduire d'autres dépendances dans le contrôleur pour effectuer des opérations plus complexes.

5. Modèle d'écriture

Les modèles sont généralement utilisés pour exprimer des tableaux de données afin que lorsque le contrôleur est appelé pour gérer les demandes de données, les données puissent être lues et traitées correctement. Dans le framework Lumen, les fichiers de modèles sont généralement stockés dans le dossier /app/Models.

Ce qui suit est un modèle simple. Dans ce modèle, nous avons convenu que le nom de la table de données est utilisateurs :

<?php

namespace AppModels;

use IlluminateDatabaseEloquentModel;

class User extends Model
{
    protected $table = 'users';
    protected $fillable = ['name', 'email'];
}

La classe User dans le code ci-dessus hérite de la classe Model du framework Lumen, qui contient certaines variables d'attribut essentielles. et les méthodes. Ici, nous utilisons protected $table = 'users' pour accepter que la table de données correspondant à ce modèle soit nommée users, et nous utilisons également l'attribut fillable pour limiter les champs pouvant être attribués par lots.

6. Routage d'écriture

Routing spécifie le chemin URL de la requête et la méthode de contrôleur correspondante, qui est utilisée pour distribuer la requête. Dans le framework Lumen, les fichiers de routage sont généralement stockés dans le dossier /routes.

<?php

$router->get('/', function () use ($router) {
    return $router->app->version();
});

$router->get('/users', 'UserController@index');
$router->post('/users', 'UserController@store');
$router->get('/users/{id}', 'UserController@show');
$router->put('/users/{id}', 'UserController@update');
$router->delete('/users/{id}', 'UserController@destroy');

Dans le code ci-dessus, nous spécifions les chemins d'URL et les méthodes de traitement correspondants pour les cinq opérations, dans lesquelles l'obtention, la publication, la mise et la suppression du routeur ($router) sont utilisées pour spécifier la méthode de requête HTTP.

7. Test de l'API

Nous avons désormais terminé avec succès l'installation du framework Lumen, l'écriture du code du contrôleur, la définition du modèle et le paramétrage du routage, et pouvons être testés. Entrez la commande suivante dans le terminal de ligne de commande pour démarrer le service Web :

php -S 127.0.0.1:8000 -t public

Ouvrez ensuite le navigateur et entrez localhost:8000/users pour accéder au service API ci-dessus. Vous verrez une liste d'utilisateurs. Vous pouvez également utiliser Postman ou d'autres outils clients HTTP pour tester l'interface.

Résumé

En utilisant le framework Lumen, nous pouvons facilement créer un service API RESTful simple et facile à utiliser. Avec la prise en charge du framework Lumen, nous pouvons écrire rapidement les fichiers nécessaires tels que les contrôleurs, les modèles et les routes, et démarrer des services Web via des outils de ligne de commande à des fins de test. Par rapport à la méthode de développement PHP traditionnelle, cette méthode peut considérablement améliorer notre efficacité de développement et l'efficacité de notre fonctionnement du programme.

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!