Laravel hace que las interacciones API sean pan comido tanto para los desarrolladores web nuevos como para los experimentados. El cliente HTTP de Laravel está construido sobre el cliente HTTP Guzzle de PHP para ofrecer a los desarrolladores una experiencia más fluida al realizar peticiones HTTP. Sus características principales incluyen autenticación, enrutamiento y mapeo objeto-relacional (ORM) eficaz.

Este artículo explorará el uso del cliente HTTP de Laravel para realizar peticiones, depurar respuestas, crear middleware y macros, y mucho más.

El Cliente HTTP de Laravel Hace el Trabajo Duro por Ti para las APIs

Guzzle es un sencillo cliente HTTP para PHP. Ofrece funcionalidad para diferentes solicitudes de formularios, incluyendo GET, POST, PUT, y DELETE junto con las capacidades de streaming y solicitudes multiparte. Con el cliente HTTP Guzzle, es posible enviar peticiones síncronas y asíncronas al servidor. Además, también viene con un middleware decente para personalizar el comportamiento del cliente.

El cliente HTTP de Laravel es una envoltura construida sobre Guzzle pero con funcionalidades extra. Incluye soporte para reintentar peticiones fallidas y algunas funciones de ayuda con datos JSON. La mayoría de las funcionalidades de los clientes HTTP de Laravel son similares a las de Guzzle.

Requisitos Previos

En las siguientes secciones, aprenderás más sobre el cliente HTTP de Laravel. Para seguir adelante, necesitarás:

  • Conocimientos básicos de Laravel, PHP y APIs
  • PHP y Composer instalados
  • Postman

Cómo Hacer Peticiones

Para saber cómo utilizar un cliente HTTP para hacer una solicitud, puedes aprovechar un montón de API alojadas, como ReqRes.

Empieza importando el paquete HTTP incluido al crear la aplicación. Dentro del archivo App/Http/Controllers/UserController.php, añade el siguiente código, empezando por la declaración use al principio del archivo y el código restante dentro de la función index.

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

Nota: Para casos de uso complejos, también puedes enviar la solicitud con cabeceras utilizando el método withHeaders.

En el mismo archivo, crea un nuevo método post utilizando el siguiente código:

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

A continuación, añade una ruta para él dentro del archivo routes/web.php:

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

Ahora, se puede utilizar Postman para probar esta ruta. Abre Postman y añade http://127.0.0.1:8000/post como URL, con el tipo de solicitud GET. Cuando hagas clic en enviar, verás la siguiente respuesta:

Realizar solicitudes con Postman
Realizar solicitudes con Postman

Peticiones Concurrentes

Las peticiones paralelas mejoran significativamente el rendimiento, ya que puedes obtener más datos en el mismo periodo. El cliente HTTP de Laravel permite realizar peticiones concurrentes utilizando el método pool.

Dentro de App/Http/Controllers/UserController.php, añade el siguiente código:

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

A continuación, añade la ruta de soporte dentro del archivo routes/web.php.

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

El navegador da la siguiente respuesta cuando se visita la ruta:

Peticiones concurrentes
Peticiones concurrentes

Macros de Solicitud

Las macros de petición son útiles cuando se interactúa con rutas comunes de la API.

Para crear la macro, tienes que definirla dentro del método boot del archivo app/Http/Providers/AppServiceProvider.php utilizando el código que aparece a continuación:

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

Nota: Asegúrate de añadir la declaración use al principio del archivo.

A continuación, utiliza la macro dentro de UserController añadiendo el siguiente código:

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

Como puedes ver, como la macro ya está creada, no tienes que volver a añadir la URL completa.

Por último, añade una ruta en el archivo routes/web.php utilizando el siguiente código:

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

Cómo Descodificar las Respuestas

Para descodificar una respuesta y asegurarte de que una solicitud de API se ha realizado correctamente, utiliza el método de estado incluido en el cliente. Este método obtiene el código de estado enviado desde el servidor y lo muestra.

Para probarlo, sustituye el código de la macro anterior por el código siguiente dentro del archivo App/Http/Controllers/UserController.php:

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

Aquí, el código de estado 200 significa que la solicitud se ha realizado correctamente.

Respuesta de descodificación correcta
Respuesta de descodificación correcta

Cómo Probar las API JSON

Laravel dispone de varios ayudantes para probar las API JSON y sus respuestas. Las funciones de ayuda incluyen json, getJson, postJson, putJson, patchJson, deleteJson, etc.

Para entender mejor las Pruebas, crea un escenario de prueba para la ruta del usuario GET. Cuando arrancas la aplicación Laravel, ya está creada la Prueba de Ejemplo. Dentro del archivo tests/Feature/ExampleTest.php, sustituye el código existente por el siguiente:

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

El código añadido obtiene los datos JSON en la ruta del usuario y comprueba si el código de estado es 200 o no.

Una vez que hayas añadido el código de prueba, ejecuta el siguiente comando en tu terminal para ejecutar las pruebas:

./vendor/bin/phpunit

Una vez finalizadas las pruebas, verás que ha ejecutado dos pruebas, ambas con éxito.

Probar las API JSON
Probar las API JSON

Del mismo modo, puedes comprobar distintos tipos de solicitudes y utilizar otros métodos de ayuda para realizar pruebas más sofisticadas.

Cómo Manejar los Eventos

Laravel ofrece tres eventos que se disparan cuando se trata de peticiones HTTP.

  • RequestSending, que se produce antes de enviar la solicitud.
  • ResponseReceived, que es cuando se recibe una respuesta.
  • ConnectionFailed, que es cuando no se recibe ninguna respuesta.

Los tres eventos incluyen la propiedad $request para inspeccionar la instancia Illuminate\Http\Client\Request, y ResponseReceived tiene una $response property adicional. Son especialmente útiles para realizar acciones después de un evento. Por ejemplo, puede que quieras enviar un correo electrónico después de obtener una respuesta satisfactoria.

Para crear un evento y un oyente, navega hasta el archivo app/Providers/EventServiceProvider.php y sustituye la matriz listen por el siguiente código.

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

A continuación, ejecuta el siguiente comando en tu terminal:

php artisan event:generate

El comando anterior creará el oyente app/Listeners/LogResponseReceived.php. Sustituye el código de ese archivo por el código que aparece a continuación:

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

El registro de información del código de estado se imprime en el terminal.

Registros del terminal que muestran el código de estado
Registros del terminal que muestran el código de estado

Resumen

Tanto si una organización como un desarrollador independiente crean un sitio web o una aplicación web, las API son la clave de su éxito. Sin embargo, utilizarlas puede resultar difícil.

Muchos frameworks y bibliotecas prometen simplificar este proceso, pero Laravel destaca por su enfoque en la simplicidad y facilidad de uso. Su cliente integrado admite llamadas API sencillas, llamadas API concurrentes, macros API, métodos de ayuda para API basadas en JSON y mucho más.

Steve Bonisteel Kinsta

Steve Bonisteel es un Editor Técnico de Kinsta que comenzó su carrera de redactor como periodista de prensa escrita, persiguiendo ambulancias y camiones de bomberos. Lleva tratando temas relacionados con la tecnología de Internet desde finales de la década de 1990.