Laravel Eloquent ist eine einfache Möglichkeit, mit deiner Datenbank zu interagieren. Es ist ein objektrelationaler Mapper (ORM), der die Komplexität von Datenbanken vereinfacht, indem er ein Modell für die Interaktion mit Tabellen bereitstellt.

Daher verfügt Laravel Eloquent über hervorragende Werkzeuge zum Erstellen und Testen von APIs, die deine Entwicklung unterstützen. In diesem praktischen Artikel erfährst du, wie einfach es ist, mit Laravel APIs zu erstellen und zu testen.

In dieser Demonstration erstellst du zunächst ein Modell, mit dem du die API und die Datenbanktabelle erstellen kannst. Dann erfährst du, wie du einen Controller als Geschäftslogikschicht und eine Route zur Vervollständigung der API hinzufügst. Anschließend lernst du, wie du APIs mit Postman testen kannst, bevor du dich auf die Authentifizierung und Fehlerbehandlung konzentrierst.

Voraussetzungen

Um loszulegen, brauchst du Folgendes:

API-Grundlagen

Beginne damit, ein neues Laravel-Projekt mit <code>composer</code> zu erstellen:

composer create-project laravel/laravel laravel-api-create-test

Um den Server zu starten, führe den folgenden Befehl aus, der den Anwendungsserver auf Port 8000 ausführt:

cd laravel-api-create-test
php artisan serve

Du solltest den folgenden Bildschirm sehen:

Laravel Landing Page
Laravel

Erstelle dann ein Modell mit einem -m Flag für die Migration, indem du den folgenden Code verwendest:

php artisan make:model Product -m

Aktualisiere nun die Migrationsdatei, um das erforderliche Feld aufzunehmen. Füge die Felder Titel und Beschreibung für das Produktmodell und diese beiden Tabellenfelder in der Datei database/migrations/{date_stamp}_create_products_table.php hinzu.

$table->string('title');
$table->longText('description');

Der nächste Schritt besteht darin, diese Felder ausfüllbar zu machen. Erstelle in app/Models/Product.php die ausfüllbaren Felder title und description.

protected $fillable = ['title', 'description'];

Wie man einen Controller erstellt

Erstelle nun eine Controller-Datei für das Produkt, indem du den folgenden Befehl ausführst. Dadurch wird die Datei app/Http/Controllers/Api/ProductController.php erstellt.

php artisan make:controller ApiProductController --model=Product

Füge nun die Logik zum Erstellen und Abrufen der Produkte hinzu. Füge in der Methode index den folgenden Code ein, um alle Produkte abzurufen:

$products = Product::all();
return response()->json([
    'status' => true,
    'products' => $products
]);

Danach musst du eine StoreProductRequest Klasse hinzufügen, um die neuen Produkte in der Datenbank zu speichern. Füge die folgende Klasse am Anfang der gleichen Datei hinzu.

public function store(StoreProductRequest $request)
 {
    $product = Product::create($request->all());

    return response()->json([
        'status' => true,
        'message' => "Product Created successfully!",
        'product' => $product
    ], 200);
 }

Jetzt erstellst du die Anfrage, indem du den folgenden Befehl ausführst:

php artisan make:request StoreProductRequest

Wenn du Validierungen hinzufügen möchtest, kannst du die Datei app/Http/Requests/StoreProductRequest.php verwenden. Für diese Demonstration sind keine Validierungen vorgesehen.

Wie man eine Route erstellt

Der letzte Schritt vor dem Testen der API ist das Hinzufügen einer Route. Dazu fügst du den folgenden Code in die Datei routes/api.php ein. Füge die Anweisung use am Anfang der Datei und die Anweisung Route im Textkörper ein:

use AppHttpControllersApiProductController;
Route::apiResource('products', ProductController::class);

Bevor du mit dem Testen der API beginnst, vergewissere dich, dass die Produkttabelle in deiner Datenbank vorhanden ist. Wenn sie nicht vorhanden ist, erstelle sie mit einem Control Panel wie XAMPP. Alternativ kannst du auch den folgenden Befehl ausführen, um die Datenbank zu migrieren:

php artisan migrate

So testest du eine API

Bevor du die API testest, stelle sicher, dass die Methode <code>authorize</code> in der Datei app/Http/Requests/StoreProductRequest.php <code>true</code> zurückgibt.

Jetzt kannst du mit Postman ein neues Produkt erstellen. Beginne, indem du eine POST Anfrage an diese URL stellst: http://127.0.0.1:8000/api/products/. Da es sich um eine POST Anfrage zur Erstellung eines neuen Produkts handelt, musst du ein JSON-Objekt mit einem Titel und einer Beschreibung übergeben.

{
    "title":"Apple",
    "description":"Best Apples of the world"
}
Ein neues Produkt in Postman erstellen
Ein neues Produkt in Postman erstellen

Nachdem du auf die Schaltfläche Senden geklickt hast, solltest du folgendes sehen:

Nachdem du auf Senden geklickt hast
Nachdem du auf Senden geklickt hast

Jetzt holst du die erstellten Produkte mit der Anfrage GET ab. Die URL ist die gleiche. Die Ergebnisse sehen dann wie folgt aus:

Die Produkte, die mit der GET-Anfrage abgerufen werden
Die Produkte, die mit der GET-Anfrage abgerufen werden

Wie man eine API mit Sanctum authentifiziert

Die Authentifizierung ist entscheidend für die Sicherung einer API. Laravel macht es dir leicht, indem es die Funktionalität des Sanctum-Tokens bereitstellt, das du als Middleware verwenden kannst. Es sichert die API mit Token, die generiert werden, wenn sich der Nutzer mit den richtigen Anmeldedaten anmeldet. Vergiss nicht, dass die Nutzer ohne Token keinen Zugriff auf die gesicherte API haben.

Der erste Schritt zum Hinzufügen der Authentifizierung ist das Hinzufügen eines Sanctum-Pakets mit dem unten stehenden Code:

composer require laravel/sanctum

Veröffentliche dann die Sanctum-Konfigurationsdatei:

php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"

Danach fügst du das Token von Sanctum als Middleware hinzu. Verwende in der Datei app/Http/Kernel.php die folgende Klasse und ersetze middlewareGroups durch den folgenden Code in der API der geschützten Middleware-Gruppen.

use LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful;
protected $middlewareGroups = [
    'web' => [
        AppHttpMiddlewareEncryptCookies::class,
        IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
        IlluminateSessionMiddlewareStartSession::class,
        // IlluminateSessionMiddlewareAuthenticateSession::class,
        IlluminateViewMiddlewareShareErrorsFromSession::class,
        AppHttpMiddlewareVerifyCsrfToken::class,
        IlluminateRoutingMiddlewareSubstituteBindings::class,
    ],

    'api' => [
        EnsureFrontendRequestsAreStateful::class,
        'throttle:api',
        IlluminateRoutingMiddlewareSubstituteBindings::class,
    ],
];

Im nächsten Schritt erstellst du eine UserController und fügst den Code hinzu, um das Token für die Authentifizierung zu erhalten.

php artisan make:controller UserController

Nachdem du die UserController erstellt hast, navigiere zur Datei app/Http/Controllers/UserController.php und ersetze den vorhandenen Code durch den folgenden Code:

<?php

namespace AppHttpControllers;

use IlluminateHttpRequest;
use AppModelsUser;
use IlluminateSupportFacadesHash;
class UserController extends Controller
{
    // 

    function index(Request $request)
    {
        $user= User::where('email', $request->email)->first();
        // print_r($data);
            if (!$user || !Hash::check($request->password, $user->password)) {
                return response([
                    'message' => ['These credentials do not match our records.']
                ], 404);
            }
        
             $token = $user->createToken('my-app-token')->plainTextToken;
        
            $response = [
                'user' => $user,
                'token' => $token
            ];
        
             return response($response, 201);
    }
}

Bevor du die Authentifizierung testen kannst, musst du einen Benutzer erstellen, der Seeder einsetzt. Der folgende Befehl erstellt eine UsersTableSeeder-Datei.

php artisan make:seeder UsersTableSeeder

Ersetze in der Datei database/seeders/UsersTableSeeder.php den vorhandenen Code durch den folgenden Code, um den Benutzer zu seeden:

<?php

namespace DatabaseSeeders;

use IlluminateDatabaseSeeder;
use IlluminateSupportFacadesDB;
use IlluminateSupportFacadesHash;

class UsersTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        DB::table('users')->insert([
            'name' => 'John Doe',
            'email' => '[email protected]',
            'password' => Hash::make('password')
        ]);
    }
}

Führe nun den Seeder mit diesem Befehl aus:

php artisan db:seed --class=UsersTableSeeder

Der letzte Schritt im Authentifizierungsablauf besteht darin, die erstellte Middleware zu verwenden, um die Route zu schützen. Navigiere zur Datei routes/api.php und füge die Route products innerhalb der Middleware hinzu.

use AppHttpControllersUserController;

Route::group(['middleware' => 'auth:sanctum'], function () {
    Route::apiResource('products', ProductController::class);
});

Route::post("login",[UserController::class,'index']);

Nachdem du eine Route zur Middleware hinzugefügt hast, bekommst du einen internen Serverfehler, wenn du versuchst, die Produkte abzurufen.

Ein interner Serverfehler nach dem Hinzufügen einer Route
Ein interner Serverfehler nach dem Hinzufügen einer Route

Aber sobald du dich anmeldest, ein Token bekommst und es in der Kopfzeile verwendest, wirst du authentifiziert und kannst arbeiten. Du kannst eine POST-Anfrage an http://127.0.0.1:8000/api/login mit folgendem Text senden:

{
    "email":"[email protected]",
    "password":"password"
}
Erfolgreiche Authentifizierung und das Bearer-Token
Erfolgreiche Authentifizierung

Verwende das erhaltene Token als Bearer-Token und füge es als Authorization-Header hinzu.

Hinzufügen des Bearer-Tokens als Authorization-Header
Hinzufügen des Bearer-Tokens als Authorization-Header

Wie man mit API-Fehlern umgeht

Jedes Mal, wenn du eine Anfrage an den Server sendest, antwortet er. Mit der Antwort sendet er auch einen Statuscode, der der Art der Antwort entspricht. Ein 200-Statuscode bedeutet zum Beispiel, dass die Anfrage erfolgreich war, und ein 404-Statuscode bedeutet, dass der Server die angeforderte Ressource nicht finden kann.

Ein Statuscode reicht jedoch nicht aus. Es wird eine für Menschen lesbare Fehlermeldung benötigt. Laravel bietet viele Möglichkeiten, Fehler zu behandeln. Du kannst einen Try-Catch-Block, die Fallback-Methode oder eine benutzerdefinierte Antwort verwenden. Der folgende Code, den du in UserController eingefügt hast, demonstriert dies.

if (!$user || !Hash::check($request->password, $user->password)) {
    return response([
        'message' => ['These credentials do not match our records.']
    ], 404);
}

Zusammenfassung

Mit dem Eloquent Model von Laravel ist es mühelos möglich, APIs zu erstellen, zu validieren und zu testen. Das objektrelationale Mapping bietet einen unkomplizierten Ansatz für die Interaktion mit der Datenbank.

Das Sanctum Token von Laravel fungiert als Middleware und hilft dir, deine APIs schnell zu sichern.

Und wenn du noch mehr Optimierung brauchst, vereinfacht die Datenbank-Hosting-Lösung von Kinsta die Einrichtung und Verwaltung von Datenbanken für alle deine Webprojekte.

Jeremy Holcombe Kinsta

Content & Marketing Editor bei Kinsta, WordPress Web Developer und Content Writer. Außerhalb von WordPress genieße ich den Strand, Golf und Filme. Außerdem habe ich Probleme mit großen Menschen ;).