Laravel macht API-Interaktionen sowohl für neue als auch für erfahrene Webentwickler zum Kinderspiel. Der Larvel-HTTP-Client baut auf dem Guzzle-HTTP-Client von PHP auf, um Entwicklern eine reibungslosere Erfahrung bei HTTP-Anfragen zu ermöglichen. Zu seinen wichtigsten Funktionen gehören Authentifizierung, Routing und ein effektives objektrelationales Mapping (ORM).

In diesem Artikel geht es um die Verwendung des HTTP-Clients von Laravel, um Anfragen zu stellen, Antworten zu debuggen, Middleware und Makros zu erstellen und vieles mehr.

Der Laravel-HTTP-Client erledigt die harte Arbeit für dich bei APIs

Guzzle ist ein einfacher HTTP-Client für PHP. Er bietet Funktionen für verschiedene Formularanfragen, darunter GET, POST, PUT und DELETE sowie Streaming-Funktionen und Multipart-Anfragen. Mit dem Guzzle HTTP-Client ist es möglich, synchrone und asynchrone Anfragen an den Server zu senden. Außerdem verfügt er über eine gute Middleware, mit der das Verhalten des Clients angepasst werden kann.

Der HTTP-Client von Laravel ist ein Wrapper, der auf Guzzle aufbaut, aber mit zusätzlichen Funktionen ausgestattet ist. Er unterstützt die Wiederholung fehlgeschlagener Anfragen und einige Hilfsfunktionen mit JSON-Daten. Die meisten Funktionen des Laravel-HTTP-Clients sind ähnlich wie die von Guzzle.

Voraussetzungen

In den folgenden Abschnitten erfährst du mehr über den HTTP-Client von Laravel. Um mitzumachen, brauchst du:

  • Grundkenntnisse über Laravel, PHP und APIs
  • PHP und Composer sind installiert
  • Postman

Wie man Anfragen stellt

Um zu verstehen, wie man einen HTTP-Client verwendet, um eine Anfrage zu stellen, kannst du viele gehostete APIs nutzen, wie z.B. ReqRes.

Beginne damit, das HTTP-Paket zu importieren, das bei der Erstellung der Anwendung enthalten ist. Füge in der Datei App/Http/Controllers/UserController.php den folgenden Code ein, beginnend mit der use-Anweisung am Anfang der Datei und dem restlichen Code innerhalb der index-Funktion.

use Illuminate\Support\Facades\Http;
return Http::get("https://reqres.in/api/users?page=2");

Hinweis: Für komplexe Anwendungsfälle kannst du die Anfrage auch mit Kopfzeilen senden, indem du die Methode withHeaders verwendest.

Erstelle in derselben Datei eine neue Methode post mit folgendem Code:

function post()
{
    $response = Http::withHeaders([
        'Content-Type' => 'application/json',
    ])->post('https://reqres.in/api/users', [
        'name' => 'morpheus',
        'job' => 'leader',
    ]);
    return $response;
}

Füge dann eine Route dafür in der Datei routes/web.php hinzu:

Route::get('post',[UserController::class,'post']);

Jetzt kann Postman verwendet werden, um diese Route zu testen. Öffne Postman und füge http://127.0.0.1:8000/post als URL hinzu, mit dem Typ der Anfrage GET. Wenn du auf Senden klickst, siehst du die folgende Antwort:

Anfragen mit Postman stellen
Anfragen mit Postman stellen

Parallele Anfragen

Parallele Anfragen verbessern die Leistung erheblich, da du in der gleichen Zeit mehr Daten abrufen kannst. Der HTTP-Client von Laravel macht es möglich, mit der Pool-Methode parallele Anfragen durchzuführen.

Füge in App/Http/Controllers/UserController.php den folgenden Code ein:

use Illuminate\Http\Client\Pool;
function concurrent()
{
    $responses = Http::pool(fn (Pool $pool) => [
        $pool->get('https://reqres.in/api/users?page=2'),
        $pool->get('https://reqres.in/api/users/2'),
        $pool->get('https://reqres.in/api/users?page=2'),
    ]);

    return $responses[0]->ok() &&
        $responses[1]->ok() &&
        $responses[2]->ok();
}

Füge dann die unterstützende Route in der Datei routes/web.php hinzu.

Route::get('concurrent',[UserController::class,'concurrent']);

Der Browser gibt die folgende Antwort, wenn die Route besucht wird:

Parallele Anfragen
Parallele Anfragen

Anfrage-Makros

Anfragemakros sind nützlich, wenn du mit gängigen API-Pfaden interagierst.

Um ein Makro zu erstellen, musst du es in der boot-Methode der Datei app/Http/Providers/AppServiceProvider.php mit dem unten stehenden Code definieren:

use Illuminate\Support\Facades\Http;
Http::macro('reqres', function () {
    return Http::baseUrl('https://reqres.in/api');
});

Hinweis: Achte darauf, dass du die use-Anweisung am Anfang der Datei einfügst.

Verwende dann das Makro innerhalb der UserController, indem du den folgenden Code hinzufügst:

function macro()
{
    $response = Http::reqres()->get('/users?page=2');
    return $response;
}

Wie du siehst, wird das Makro bereits erstellt, so dass du nicht noch einmal die vollständige URL hinzufügen musst.

Zum Schluss fügst du mit dem folgenden Code eine Route in die Datei routes/web.php ein:

Route::get('macro',[UserController::class,'macro']);
Makro-Anfrage
Makro-Anfrage

Antworten dekodieren

Um eine Antwort zu entschlüsseln und sicherzustellen, dass eine API-Anfrage erfolgreich war, verwendest du die im Client enthaltene Statusmethode. Diese Methode ruft den vom Server gesendeten Statuscode ab und zeigt ihn an.

Um dies auszuprobieren, ersetze den vorherigen Makrocode durch den folgenden Code in der Datei App/Http/Controllers/UserController.php:

function macro()
{
    $response = Http::reqres()->get('/users?page=2');
    return $response->status();
}

Hier bedeutet der Statuscode 200, dass die Anfrage erfolgreich war.

Erfolgreiche Dekodierungsantwort
Erfolgreiche Dekodierungsantwort

Wie man JSON-APIs testet

Laravel hat mehrere Hilfsfunktionen, um die JSON-APIs und ihre Antworten zu testen. Zu den Hilfsfunktionen gehören json, getJson, postJson, putJson, patchJson, deleteJson und so weiter.

Um das Testen besser zu verstehen, erstelle ein Testszenario für die Route des Benutzers GET. Wenn du die Laravel-Anwendung bootest, wird der Beispieltest bereits erstellt. Ersetze in der Datei tests/Feature/ExampleTest.php den vorhandenen Code durch den folgenden:

<?php
namespace Tests\Feature;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
class ExampleTest extends TestCase
{
    /**
     * A basic test example.
     *
     * @return void
     */
    public function test_example()
    {
        $response = $this->getJson('/users');

        $response->assertStatus(200);
    }
}

Der hinzugefügte Code holt die JSON-Daten von der Benutzerroute ab und prüft, ob der Statuscode 200 ist oder nicht.

Sobald du den Testcode hinzugefügt hast, führe den folgenden Befehl in deinem Terminal aus, um die Tests zu starten:

./vendor/bin/phpunit

Sobald die Tests abgeschlossen sind, wirst du sehen, dass zwei Tests durchgeführt wurden, die beide erfolgreich waren.

Testen von JSON-APIs
Testen von JSON-APIs

Auf ähnliche Weise kannst du verschiedene Arten von Anfragen prüfen und andere Hilfsmethoden für anspruchsvollere Tests verwenden.

Wie man mit Ereignissen umgeht

Laravel bietet drei Ereignisse, die bei der Bearbeitung von HTTP-Anfragen ausgelöst werden können.

  • RequestSending, d.h. bevor die Anfrage gesendet wird.
  • ResponseReceived, wenn eine Antwort empfangen wird.
  • ConnectionFailed, wenn keine Antwort empfangen wird.

Alle drei Ereignisse enthalten die Eigenschaft $request, um die Instanz Illuminate\Http\Client\Request zu überprüfen, und ResponseReceived hat eine zusätzliche $response property. Diese sind besonders nützlich, um nach einem Ereignis Aktionen auszuführen. Du könntest zum Beispiel eine E-Mail versenden, nachdem du eine erfolgreiche Antwort erhalten hast.

Um ein Ereignis und einen Listener zu erstellen, navigiere zur Datei app/Providers/EventServiceProvider.php und ersetze das listen-Array durch den folgenden Code.

protected $listen = [
    Registered::class => [
        SendEmailVerificationNotification::class,
    ],
    'Illuminate\Http\Client\Events\ResponseReceived' => [
        'App\Listeners\LogResponseReceived',
    ],
];

Führe dann den folgenden Befehl in deinem Terminal aus:

php artisan event:generate

Mit dem obigen Befehl wird der Listener app/Listeners/LogResponseReceived.php erstellt. Ersetze den Code in dieser Datei durch den folgenden Code:

<?php
namespace App\Listeners;
use Illuminate\Http\Client\Events\ResponseReceived;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Log;
class LogResponseReceived
{
    /**
     * Create the event listener.
     *
     * @return void
     */
    public function __construct(Request $request, Response $response)
    {
        Log::channel('stderr')->info($response->status());
    }

    /**
     * Handle the event.
     *
     * @param  \Illuminate\Http\Client\Events\ResponseReceived  $event
     * @return void
     */
    public function handle(ResponseReceived $event)
    {
        
    }
}

Das Infoprotokoll des Statuscodes wird im Terminal ausgegeben.

Terminalprotokolle, die den Statuscode anzeigen
Terminalprotokolle, die den Statuscode anzeigen

Zusammenfassung

Egal, ob eine Website oder eine Webanwendung von einem Unternehmen oder einem unabhängigen Entwickler erstellt wird, APIs sind der Schlüssel zu ihrem Erfolg. Sie zu nutzen, kann jedoch schwierig sein.

Viele Frameworks und Bibliotheken versprechen, diesen Prozess zu vereinfachen, aber Laravel zeichnet sich durch seinen Fokus auf Einfachheit und Benutzerfreundlichkeit aus. Der integrierte Client unterstützt einfache API-Aufrufe, gleichzeitige API-Aufrufe, API-Makros, Hilfsmethoden für JSON-basierte APIs und vieles mehr.

Steve Bonisteel Kinsta

Steve Bonisteel is a Technical Editor at Kinsta who began his writing career as a print journalist, chasing ambulances and fire trucks. He has been covering Internet-related technology since the late 1990s.