Laravel Eloquent is een eenvoudige manier om interactie met je database te beheren. Het is een Object-Relational Mapper (ORM) die de complexiteit van databases vereenvoudigt door een model te bieden voor interactie met tabellen.

Als zodanig heeft Laravel Eloquent uitstekende tools voor het maken en testen van API’s om je ontwikkeling te ondersteunen. In dit praktische artikel zie je hoe eenvoudig het is om API’s te maken en te testen met Laravel.

In deze demonstratie begin je met het maken van een model dat je kunt gebruiken om de API en database tabel te bouwen. Daarna zie je hoe je een controller toevoegt als bedrijfslogicalaag en een route om de API te voltooien. Vervolgens leer je hoe je API’s kunt testen met Postman, voordat je je als laatste richt op authenticatie en foutafhandeling.

Voorwaarden

Om te beginnen heb je het volgende nodig:

Grondbeginselen API

Begin met het maken van een nieuw Laravel project met composer:

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

Voer het volgende commando uit om de server te starten, waardoor de applicatieserver op poort 8000 draait:

cd laravel-api-create-test
php artisan serve

Je zou het volgende scherm moeten zien:

De Laravel landiingspagina
Laravel

Maak nu een model met een -m flag voor de migratie met de onderstaande code:

php artisan make:model Product -m

Upgrade nu het migratiebestand om het vereiste veld op te nemen. Voeg de velden title en description toe voor het productmodel en deze twee tabelvelden binnen het bestand database/migrations/{date_stamp}_create_products_table.php.

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

De volgende stap is om deze velden invulbaar te maken. Maak binnen app/Models/Product.php title en description invulbare velden.

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

Een controller maken

Maak nu een controllerbestand voor het product door het volgende commando uit te voeren. Dit zal het bestand app/Http/Controllers/Api/ProductController.php aanmaken.

php artisan make:controller Api\\ProductController --model=Product

Voeg nu de logica toe voor het aanmaken en ophalen van de producten. Voeg in de methode index de volgende code toe om alle producten op te halen:

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

Daarna moet je een klasse StoreProductRequest toevoegen voor het opslaan van de nieuwe producten in de database. Voeg bovenaan hetzelfde bestand de volgende klasse toe.

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

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

Nu maak je het verzoek aan, wat je kunt doen door het volgende commando uit te voeren:

php artisan make:request StoreProductRequest

Als je validaties wilt toevoegen, kun je het bestand app/Http/Requests/StoreProductRequest.php gebruiken. Voor deze demonstratie zijn er geen validaties.

Zo maak je een route aan

De laatste stap voor het testen van de API is het toevoegen van een route. Voeg daarvoor de volgende code toe in het bestand routes/api.php. Voeg het use statement toe aan het begin van het bestand en het Route statement in de body:

use App\Http\Controllers\Api\ProductController;
Route::apiResource('products', ProductController::class);

Voordat je de API gaat testen, moet je ervoor zorgen dat de Products tabel in je database staat. Als die niet bestaat, maak er dan een aan met een controlepaneel zoals XAMPP. Als alternatief kun je het volgende commando uitvoeren om de database te migreren:

php artisan migrate

Zo test je een API

Voordat je de API test, moet je ervoor zorgen dat de authorize methode in de app/Http/Requests/StoreProductRequest.php is ingesteld op true.

Nu kun je een nieuw product maken met Postman. Begin met het slaan van een POST verzoek naar deze URL: http://127.0.0.1:8000/api/products/. Omdat het een POST verzoek is om een nieuw product te maken, moet je een JSON object met een titel en beschrijving doorgeven.

{
    "title":"Apple",
    "description":"Best Apples of the world"
}
Een nieuw product maken in Postman
Een nieuw product maken in Postman

Nadat je op de knop Send hebt geklikt, zou je het volgende moeten zien:

Postman nadat je op Send hebt geklikt
Na het klikken op Send

Haal nu de aangemaakte producten op met het GET verzoek. De URL is hetzelfde. De resultaten zullen er als volgt uitzien:

De producten opgehaald met het GEt verzoek.
De producten opgehaald door het GET verzoek.

Zo authenticeer je een API met Sanctum

Authenticatie is cruciaal bij het beveiligen van een API. Laravel maakt het gemakkelijk door de functionaliteit van het Sanctum token te bieden, dat je kunt gebruiken als middleware. Het beveiligt de API met behulp van tokens die worden gegenereerd wanneer de gebruiker inlogt met de juiste gegevens. Vergeet niet dat gebruikers zonder token geen toegang hebben tot de beveiligde API.

De eerste stap om authenticatie toe te voegen is het toevoegen van een Sanctum pakket met de onderstaande code:

composer require laravel/sanctum

Publiceer vervolgens het Sanctum configuratiebestand:

php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"

Voeg daarna het token van Sanctum toe als middleware. Gebruik binnen het app/Http/Kernel.php bestand de volgende klasse en vervang middlewareGroups door de volgende code in de beschermde API van middleware groepen.

use Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful;
protected $middlewareGroups = [
    'web' => [
        \App\Http\Middleware\EncryptCookies::class,
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        // \Illuminate\Session\Middleware\AuthenticateSession::class,
        \Illuminate\View\Middleware\ShareErrorsFromSession::class,
        \App\Http\Middleware\VerifyCsrfToken::class,
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],

    'api' => [
        EnsureFrontendRequestsAreStateful::class,
        'throttle:api',
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],
];

De volgende stap is het maken van een UserController en het toevoegen van de code om het token te krijgen om te authenticeren.

php artisan make:controller UserController

Na het aanmaken van de UserController, navigeer je naar het bestand app/Http/Controllers/UserController.php en vervang de bestaande code door de volgende code:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\Hash;
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);
    }
}

Voordat je de authenticatie kunt testen, maak je een user employing seeder aan. Het volgende commando maakt een UsersTableSeeder bestand aan.

php artisan make:seeder UsersTableSeeder

Vervang in het bestand database/seeders/UsersTableSeeder.php de bestaande code door de volgende code om de gebruiker te zaaien:

<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;

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')
        ]);
    }
}

Voer nu de seeder uit met dit commando:

php artisan db:seed --class=UsersTableSeeder

De laatste stap die overblijft in de authenticatieflow is om de gemaakte middleware te gebruiken om de route te beveiligen. Navigeer naar het bestand routes/api.php en voeg de producten route toe binnen de middleware.

use App\Http\Controllers\UserController;

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

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

Na het toevoegen van een route aan de middleware krijg je een interne serverfout als je de producten probeert op te halen.

Een interne serverfout na het toevoegen van een route
Een interne serverfout na het toevoegen van een route

Maar zodra je inlogt, een token krijgt, en dat in de header gebruikt, zal het je authenticeren en beginnen te werken. Je kunt een POST verzoek sturen naar http://127.0.0.1:8000/api/login met de volgende body:

{
    "email":"[email protected]",
    "password":"password"
}
Succesvolle authenticatie en de Bearer token
Succesvolle authenticatie

Gebruik het ontvangen token als een Bearer token en voeg het toe als de Authorization header.

Het Bearer token toevoegen als Authorization header
Het Bearer token toevoegen als Authorization header

Zo handel je API fouten af

Wanneer je een verzoek naar de server stuurt, stuurt deze een respons. Met de respons stuurt hij ook een statuscode, afhankelijk van de aard van de respons. Een 200 statuscode geeft bijvoorbeeld aan dat het verzoek gelukt is, en een 404 suggereert dat de server de gevraagde bron niet kan vinden.

Een statuscode is echter niet genoeg. Een menselijk leesbare foutmelding is nodig. Laravel heeft vele manieren om fouten af te handelen. Je kunt een try-catch blok gebruiken, de fallback methode, of een custom respons sturen. De volgende code die je hebt toegevoegd aan de UserController demonstreert dit.

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

Samenvatting

Laravels Eloquent Model maakt het eenvoudig om API’s te maken, te valideren en te testen. De Object-Relational Mapping biedt een eenvoudige manier voor interactie met de database.

Bovendien kan Laravel’s Sanctum token als middleware helpen om je API’s snel te beveiligen.

En als je verdere optimalisatie nodig hebt, vereenvoudigt Kinsta’s Database Hosting oplossing het opzetten en beheren van databases voor al je webprojecten.

Jeremy Holcombe Kinsta

Content & Marketing Editor bij Kinsta, WordPress Web Developer en Content Writer. Buiten alles wat met WordPress te maken heeft, geniet ik van het strand, golf en films. En verder heb ik last van alle problemen waar andere lange mensen ook tegenaan lopen ;).