Använda Laravel’s inbyggda klient för interaktion med externa API: er

Laravel gör API-interaktioner till en barnlek för både nya och erfarna webbutvecklare. Dess HTTP-klient är byggd på PHP’s Guzzle HTTP-klient. Allt för att ge utvecklare en smidigare upplevelse när de gör HTTP-förfrågningar. Dess primära funktioner inkluderar autentisering, routing och effektiv objekt-relationell mappning (ORM).

I den här artikeln kommer vi att utforska hur man använder Larvel HTTP-klient för att exempelvis göra förfrågningar, felsöka svar, skapa middleware och makron med mera.

Laravel’s HTTP-klient gör det svåra arbetet för API: er åt dig

Guzzle är en enkel HTTP-klient för PHP. Den erbjuder funktionalitet för olika formulär-förfrågningar. Detta inkluderar exempelvis GET, POST, PUT och DELETE tillsammans med streaming-funktioner och flerparts-förfrågningar. Med Guzzle HTTP-klienten är det dessutom möjligt att skicka synkrona och asynkrona förfrågningar till servern. Den levereras även med hygglig middleware för att anpassa klientens beteende.

Laravel’s HTTP-klient är en wrapper som bygger på Guzzle men med extra funktioner. Den inkluderar stöd för att återuppta misslyckade förfrågningar och några hjälpfunktioner med JSON-data. De flesta funktionaliteterna i Laravels HTTP-klienter liknar Guzzle.

Förutsättningar

I följande avsnitt lär du dig mer om Laravel’s HTTP-klient. För att följa med behöver du följande:

• Grundläggande kunskaper om Laravel, PHP och API: er
• Installationer av PHP och Composer
• Postman

Hur man gör förfrågningar

För att förstå hur man använder en HTTP-klient för att göra en förfrågan kan du utnyttja många hosting-baserade API: er, exempelvis ReqRes.

Börja med att importera HTTP-paketet som ingår när du skapar applikationen. I filen App/Http/Controllers/UserController.php lägger du till följande kod. börja med use-angivelsen i början av filen och resterande kod i index-funktionen.

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

Obs: För komplexa användningsområden kan du dessutom skicka förfrågningar med rubriker genom att använda metoden withHeaders.

I samma fil skapar du en ny metodpost med koden nedan:

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

Lägg sedan till en route för den i filen routes/web.php :

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

Nu kan Postman användas för att testa denna väg. Öppna Postman och lägg till http://127.0.0.1:8000/post som webbadress, med GET som typ av begäran. När du klickar på skicka får du följande svar:

Parallella begäranden

Parallella begäranden förbättrar prestandan avsevärt eftersom du kan hämta fler data under samma period. Laravels HTTP-klient gör det möjligt att utföra samtidiga begäranden med hjälp av poolmetoden.

Lägg till följande kod i App/Http/Controllers/UserController.php:

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

Lägg sedan till den stödjande routen i filen routes/web.php.

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

Webbläsaren ger följande svar när routen besöks:

Makron för begäran

Förfrågnings-makron är användbara när du interagerar med vanliga API-router.

För att skapa makrot måste du definiera makrot i boot-metoden i filen app/Http/Providers/AppServiceProvider.php med hjälp av koden nedan:

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

Observera: Se till att du lägger till use-angivelsen i början av filen.

Använd sedan makrot i UserController genom att lägga till följande kod:

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

Som du kan se behöver du inte lägga till hela webbadressen igen eftersom makrot redan är skapat.

Slutligen lägger du till en route i filen routes/web.php med hjälp av koden nedan:

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

Hur man avkodar svaren

För att avkoda ett svar och säkerställa att en API-förfrågan är framgångsrik använder du status-metoden som ingår i klienten. Den här metoden hämtar status-koden som skickas från servern och visar den.

För att testa detta ersätter du den tidigare makro-koden med koden nedan inne i filen App/Http/Controllers/UserController.php:

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

Här betyder statuskoden 200 att förfrågan lyckades.

Hur man testar JSON API: er

Laravel har flera hjälpmedel för att testa JSON API: er och deras svar. Hjälpfunktionerna inkluderar json, getJson, postJson, putJson, patchJson, deleteJson och så vidare.

För att förstå testningen bättre skapar du ett testscenario för GET-användarens route. När du startar upp Laravel-applikationen är Example Test redan skapat. I filen tests/Feature/ExampleTest.php ersätter du sedan den befintliga koden med följande:

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

Den tillagda koden hämtar JSON-data på användarens route och kontrollerar om status-koden är 200 eller inte.

När du har lagt till test-koden kör du sedan följande kommando i din terminal för att köra testerna:

./vendor/bin/phpunit

När testerna är klara ser du att den körde två tester, som båda var framgångsrika.

På samma sätt kan du kontrollera olika typer av förfrågningar och använda andra hjälpmetoder för mer sofistikerade tester.

Hur man hanterar händelser

Laravel erbjuder tre händelser som kan utlösas när du hanterar HTTP-förfrågningar.

• RequestSending, som inträffar innan begärandet skickas.
• ResponseReceived, som inträffar när ett svar tas emot.
• ConnectionFailed, som inträffar när inget svar tas emot.

Alla tre händelserna inkluderar egenskapen $request för att inspektera instansen Illuminate\Http\Client\Request. ResponseReceived har dessutom ytterligare en $response property. Dessa är särskilt användbara för att utföra åtgärder efter en händelse. Du kanske exempelvis vill skicka ett e-postmeddelande efter att du har fått ett lyckat svar.

Om du vill skapa en händelse och en lyssnare navigerar du till filen app/Providers/EventServiceProvider.php och ersätter matrisen listen med följande kod.

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

Kör därefter följande kommando i din terminal:

php artisan event:generate

Ovanstående kommando skapar lyssnaren app/Listeners/LogResponseReceived.php. Ersätt sedan koden i den filen med koden nedan:

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

Info-loggen med status-koden skrivs ut i terminalen.

Sammanfattning

Oavsett om en webbplats eller webb-applikation skapas av en organisation eller en oberoende utvecklare är API: er viktiga för att de ska bli framgångsrika. Det kan dock vara svårt att använda dem.

Många ramverk och bibliotek lovar att förenkla den här processen. Laravel sticker dock ut tack vare sitt fokus på enkelhet och användarvänlighet. Deras inbyggda klient stöder enkla API-anrop, samtidiga API-anrop, API-makroner, hjälp-metoder för JSON-baserade API: er och mycket mer.

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.