Verwenden Sie das PHP-Framework Lumen, um einen einfachen und benutzerfreundlichen RESTful-API-Dienst zu entwickeln

Mit der rasanten Entwicklung der Internet-Technologie beginnen immer mehr Anwendungen, RESTful-APIs für die Datenübertragung und Interaktion zu verwenden. RESTful API ist ein leichtes Framework für die Kommunikation basierend auf dem HTTP-Protokoll, das die Vorteile einer einfachen Erweiterung und einer starken Kompatibilität bietet. PHP ist eine sehr beliebte serverseitige Programmiersprache und es stehen viele hervorragende Frameworks zur Auswahl. Darunter ist Lumen ein leichtes PHP-Framework, das schnell RESTful-API-Dienste erstellen kann.

In diesem Artikel werden die Schritte zur Verwendung von Lumen zur Entwicklung eines einfachen und benutzerfreundlichen RESTful-API-Dienstes vorgestellt. Die folgenden Aspekte werden behandelt:

1. Inführung in Lumen
2. restful -API -Grundlagen
Lumen ist ein Mikro-Framework des Laravel-Frameworks, das schnell und effizient ist. Im Vergleich zu Laravel ist Lumen leichter und hat eine schnellere Reaktionsgeschwindigkeit. Lumen verwendet Composer als Abhängigkeitsmanagement-Tool, das auf PHP 7 oder höher basiert und die RESTful-API-Kapselung unterstützt.
3. 2. Grundkenntnisse der RESTful API
4. RESTful API ist eine Datenübertragungs- und Interaktionsmethode, die auf dem HTTP-Protokoll für die Kommunikation basiert. Zu den grundlegenden Einschränkungen der RESTful API gehören:
6. Client/Server-Modell
7. Zustandslos

Cachebar

Einheitliche Schnittstelle

Schichtsystem

Zu den häufig verwendeten HTTP-Methoden gehören GET, POST, PUT und DELETE. Durch die Kombination dieser HTTP-Methoden und URL-Ressourcenpfade kann ein RESTful-API-Dienst erstellt werden.

3. Beginnen Sie mit dem Aufbau eines RESTful-API-Dienstes
• Zunächst müssen Sie das Lumen-Framework installieren. Geben Sie den folgenden Befehl in das Befehlszeilenterminal ein:

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

Nachdem Sie auf den Abschluss der Installation gewartet haben, geben Sie das Projektverzeichnis ein und erstellen Sie die erforderlichen Dateien wie Controller und Modell über das Artisan-Befehlszeilentool:

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

Jetzt haben wir die abgeschlossen Installation des Lumen-Frameworks und Erstellung der notwendigen Dateien für unsere nächste Arbeit.
4. Schreiben Sie einen Controller
Ein Controller ist eine PHP-Klasse, die zum Verarbeiten von Anfragen und zum Zurückgeben von Antworten verwendet wird. Im Lumen-Framework werden Controller normalerweise im Ordner /app/Http/Controllers gespeichert.

Schreiben Sie einen Controller, der CRUD-Operationen für Daten abwickelt. Hier gehen wir davon aus, dass wir eine Benutzerdatentabelle haben, einschließlich ID, Name, E-Mail und anderen Feldern:

<?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);
        }
    }
}

Hier schreiben wir eine Controller-Klasse namens UserController, die 5 Methoden enthält: Index, Store, Update, Show und Destroy. Sie entsprechen jeweils den fünf allgemeinen Vorgängen der RESTful-API: Ressourcen abrufen, Ressourcen erstellen, Ressourcen aktualisieren, bestimmte Ressourcen abrufen und Ressourcen löschen.

Im obigen Code verwenden wir den Responder (response()) und das Modell (User) des Lumen-Frameworks sowie den vom Lumen-Framework bereitgestellten Validator (Validator). Darüber hinaus können Sie auch andere Abhängigkeiten in den Controller einführen, um komplexere Vorgänge auszuführen.

5. Modelle schreiben

Modelle werden normalerweise verwendet, um Datentabellen auszudrücken, damit die Daten korrekt gelesen und verarbeitet werden können, wenn der Controller zur Verarbeitung von Datenanforderungen aufgerufen wird. Im Lumen-Framework werden Modelldateien normalerweise im Ordner /app/Models gespeichert.

Das Folgende ist ein einfaches Modell. In diesem Modell haben wir uns darauf geeinigt, dass der Name der Datentabelle „users“ lautet:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentModel;

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

Die User-Klasse im obigen Code erbt von der Model-Klasse des Lumen-Frameworks, die einige wesentliche Attributvariablen enthält und Methoden. Hier verwenden wir protected $table = 'users', um zuzustimmen, dass die diesem Modell entsprechende Datentabelle benannte Benutzer sind, und wir verwenden außerdem das Attribut fillable, um die Felder einzuschränken, die stapelweise zugewiesen werden können.

6. Schreibrouting

Routing gibt den URL-Pfad der Anfrage und die entsprechende Controller-Methode an, die zum Verteilen der Anfrage verwendet wird. Im Lumen-Framework werden Routing-Dateien normalerweise im Ordner /routes gespeichert.

<?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');

Im obigen Code geben wir die entsprechenden URL-Pfade und Verarbeitungsmethoden für die fünf Vorgänge an, bei denen das Abrufen, Posten, Setzen und Löschen des Routers ($router) verwendet wird, um die HTTP-Anforderungsmethode anzugeben.

7. API testen

Jetzt haben wir die Installation des Lumen-Frameworks, das Schreiben des Controller-Codes, die Definition des Modells und die Einstellung des Routings erfolgreich abgeschlossen und können getestet werden. Geben Sie im Befehlszeilenterminal den folgenden Befehl ein, um den Webdienst zu starten:

php -S 127.0.0.1:8000 -t public

Öffnen Sie dann den Browser und geben Sie localhost:8000/users ein, um auf den oben genannten API-Dienst zuzugreifen. Sie sehen eine Benutzerliste. Alternativ können Sie Postman oder andere HTTP-Client-Tools verwenden, um die Schnittstelle zu testen.

Zusammenfassung

Mit dem Lumen-Framework können wir ganz einfach einen einfachen und benutzerfreundlichen RESTful-API-Dienst erstellen. Mit der Unterstützung des Lumen-Frameworks können wir schnell notwendige Dateien wie Controller, Modelle und Routen schreiben und Webdienste über Befehlszeilentools zum Testen starten. Im Vergleich zur herkömmlichen PHP-Entwicklungsmethode kann diese Methode unsere Entwicklungseffizienz und die Effizienz des Programmbetriebs erheblich verbessern.

Das obige ist der detaillierte Inhalt vonVerwenden Sie das PHP-Framework Lumen, um einen einfachen und benutzerfreundlichen RESTful-API-Dienst zu entwickeln. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!