API Laravel: crea e testa un'API in Laravel

Laravel Eloquent è un modo semplice per interagire con il tuo database. È un mappatore relazionale a oggetti (ORM) che semplifica le complessità dei database fornendo un modello per interagire con le tabelle.

Pertanto, Laravel Eloquent dispone di strumenti eccellenti per creare e testare API per supportare il tuo sviluppo. In questo articolo pratico, vedrai quanto è facile creare e testare le API utilizzando Laravel.

In questa dimostrazione, inizierai creando un modello che puoi utilizzare per creare l'API e la tabella del database. Quindi, vedrai come aggiungere un controller come livello di logica aziendale e un percorso per completare l'API. Imparerai quindi come eseguire test delle API utilizzando Postman prima di concentrarti finalmente sull'autenticazione e sulla gestione degli errori.

Prerequisiti

Per iniziare, ecco cosa ti servirà:

• Laravel versione 8 o 9
• Compositore
• Postino
• XAMPP
• Conoscenza base di API e PHP

Nozioni di base sull'API

Inizia creando un nuovo progetto Laravel usando <code>composer</code>:

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

Per avviare il server, eseguire il seguente comando, che esegue il server delle applicazioni sulla porta 8000:

 cd laravel-api-create-test php artisan serve

Dovresti vedere la seguente schermata:

Quindi, crea un modello con un flag -m per la migrazione utilizzando il codice seguente:

 php artisan make:model Product -m

Ora aggiorna il file di migrazione per includere il campo richiesto. Aggiungi i campi del titolo e della descrizione per il modello del prodotto e questi due campi della tabella all'interno del file database/migrations/{date_stamp}_create_products_table.php .

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

Il passaggio successivo consiste nel rendere questi campi compilabili. All'interno di app/Models/ Product.php , rendi i campi title e description compilabili.

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

Come creare un controllore

Ora, crea un file controller per il prodotto eseguendo il seguente comando. Questo creerà il file app/Http/Controllers/Api/ProductController.php .

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

Aggiungere ora la logica per la creazione e il recupero dei prodotti. All'interno del metodo index , aggiungi il seguente codice per recuperare tutti i prodotti:

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

Successivamente, è necessario aggiungere una classe StoreProductRequest per archiviare i nuovi prodotti nel database. Aggiungere la seguente classe all'inizio dello stesso file.

 public function store(StoreProductRequest $request) { $product = Product::create($request->all()); return response()->json([ 'status' => true, 'message' => "Product Created successfully!", 'product' => $product ], 200); }

Ora creerai la richiesta, cosa che puoi fare eseguendo il seguente comando:

 php artisan make:request StoreProductRequest

Se desideri aggiungere convalide, puoi utilizzare il file app/Http/Requests/StoreProductRequest.php . Per questa dimostrazione non ci sono convalide.

Come creare un percorso

Il passaggio finale prima di testare l'API è l'aggiunta di un percorso. Per fare ciò, aggiungi il seguente codice all'interno del file route/api.php . Aggiungi l'istruzione use all'inizio del file e l'istruzione Route nel corpo:

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

Prima di iniziare a testare l'API, assicurati che la tabella dei prodotti sia nel tuo database. Se non esiste, creane uno usando un pannello di controllo come XAMPP. In alternativa, puoi eseguire il seguente comando per migrare il database:

 php artisan migrate

Come testare un'API

Prima di testare l'API, assicurati che il metodo <code>authorize</code> all'interno di app/Http/Requests/StoreProductRequest.php sia impostato per restituire <code>true</code>.

Ora puoi creare un nuovo prodotto utilizzando Postman. Inizia colpendo una richiesta POST a questo URL: http://127.0.0.1:8000/api/products/. Poiché si tratta di una richiesta POST per la creazione di un nuovo prodotto, devi passare un oggetto JSON con un titolo e una descrizione.

 { "title":"Apple", "description":"Best Apples of the world" }

Dopo aver fatto clic sul pulsante Invia , dovresti vedere quanto segue:

Ora recupera i prodotti creati utilizzando la richiesta GET . L'URL è lo stesso. I risultati saranno simili ai seguenti:

Come autenticare un'API utilizzando Sanctum

L'autenticazione è fondamentale quando si protegge un'API. Laravel lo semplifica fornendo la funzionalità del token Sanctum, che puoi utilizzare come middleware. Protegge l'API utilizzando i token generati quando l'utente accede utilizzando le credenziali corrette. Ricorda che gli utenti non possono accedere all'API protetta senza un token.

Il primo passaggio per aggiungere l'autenticazione consiste nell'aggiungere un pacchetto Sanctum utilizzando il codice seguente:

 composer require laravel/sanctum

Quindi, pubblica il file di configurazione di Sanctum:

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

Successivamente, aggiungi il token di Sanctum come middleware. All'interno del file app/Http/Kernel.php usare la classe seguente e sostituire middlewareGroups con il codice seguente nell'API dei gruppi middleware protetti.

 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, ], ];

Il passaggio successivo consiste nel creare un UserController e aggiungere il codice per ottenere l'autenticazione del token.

 php artisan make:controller UserController

Dopo aver creato UserController , vai al file app/Http/Controllers/UserController.php e sostituisci il codice esistente con il seguente codice:

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

Prima di poter testare l'autenticazione, crea un utente che utilizza seeder. Il comando seguente crea un file UsersTableSeeder .

 php artisan make:seeder UsersTableSeeder

All'interno del file database/seeders/UsersTableSeeder.php , sostituisci il codice esistente con il seguente codice per eseguire il seeding dell'utente:

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

Ora esegui il seeder usando questo comando:

 php artisan db:seed --class=UsersTableSeeder

L'ultimo passaggio rimasto nel flusso di autenticazione consiste nell'utilizzare il middleware creato per proteggere il percorso. Passare al file route/api.php e aggiungere il percorso dei prodotti all'interno del middleware.

 use App\Http\Controllers\UserController; Route::group(['middleware' => 'auth:sanctum'], function () { Route::apiResource('products', ProductController::class); }); Route::post("login",[UserController::class,'index']);

Dopo aver aggiunto un percorso al middleware, riceverai un errore interno del server se provi a recuperare i prodotti.

Ma una volta effettuato l'accesso, ottenuto un token e utilizzato nell'intestazione, ti autenticherà e inizierà a funzionare. Puoi inviare una richiesta POST a http://127.0.0.1:8000/api/login con il seguente corpo:

 { "email":"[email protected]", "password":"password" }

Utilizza il token ricevuto come token Bearer e aggiungilo come intestazione di autorizzazione.

Come gestire gli errori dell'API

Ogni volta che invii una richiesta al server, risponde. Con la risposta, invia anche un codice di stato in base alla natura della risposta. Ad esempio, un codice di stato 200 indica che la richiesta è andata a buon fine e un codice 404 suggerisce che il server non riesce a trovare la risorsa richiesta.

Tuttavia, un codice di stato non è sufficiente. È richiesto un messaggio di errore leggibile dall'uomo. Laravel offre molti modi per gestire gli errori. Puoi utilizzare un blocco try-catch, il metodo di fallback o inviare una risposta personalizzata. Il seguente codice aggiunto a UserController lo dimostra.

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

Riepilogo

Il modello eloquente di Laravel semplifica la creazione, la convalida e il test delle API. La sua mappatura oggetto-relazionale fornisce un approccio diretto all'interazione con il database.

Inoltre, fungendo da middleware, il token Sanctum di Laravel può aiutarti a proteggere rapidamente le tue API.

E se avete bisogno di ulteriore ottimizzazione, la soluzione di hosting di database di Kinsta semplifica l'impostazione e la gestione dei database per tutti i vostri progetti web.