Laravel Eloquent è uno strumento semplice per interagire con un database. È un object-relational mapper (ORM) che semplifica la complessità dei database offrendo un modello per interagire con le tabelle.
Per questo motivo, Laravel Eloquent dispone di strumenti eccellenti per creare e testare le API a supporto dello sviluppo. In questo articolo tutorial, vedremo come è facile creare e testare le API con Laravel.
In questa dimostrazione, inizieremo con la creazione di un modello da usare per costruire l’API e la tabella del database. Poi vedremo come aggiungere un controller come livello di logica aziendale e una route per completare l’API. Impareremo poi a testare le API con Postman prima di concentrarci sull’autenticazione e sulla gestione degli errori.
Prerequisiti
Ecco cosa serve per iniziare:
- Laravel versione 8 o 9
- Composer
- Postman
- XAMPP
- Conoscenza di base delle API e di PHP
Nozioni di base sulle API
Iniziate creando un nuovo progetto Laravel con composer:
composer create-project laravel/laravel laravel-api-create-testPer avviare il server, lanciate il seguente comando, che esegue l’application server sulla porta 8000:
cd laravel-api-create-test
php artisan serveDovreste vedere la seguente schermata:
Quindi, create un modello con un flag -m per la migrazione utilizzando il codice seguente:
php artisan make:model Product -mOra aggiornate il file di migrazione per includere il campo richiesto. Aggiungete i campi titolo e 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 passo successivo è rendere questi campi compilabili. All’interno di app/Models/Product.php, rendete compilabili i campi title e description.
protected $fillable = ['title', 'description'];Come creare un controller
Ora create un file controller per il prodotto eseguendo il seguente comando. In questo modo verrà creato il file app/Http/Controllers/Api/ProductController.php.
php artisan make:controller ApiProductController --model=ProductOra, aggiungete la logica per creare e recuperare i prodotti. All’interno del metodo index, aggiungete il seguente codice per recuperare tutti i prodotti:
$products = Product::all();
return response()->json([
'status' => true,
'products' => $products
]);Poi dovete aggiungere una classe StoreProductRequest per memorizzare i nuovi prodotti nel database. Aggiungete 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 dovrete creare la richiesta eseguendo questo comando:
php artisan make:request StoreProductRequestSe volete aggiungere delle convalide, potete usare il file app/Http/Requests/StoreProductRequest.php. Per questa dimostrazione non ci sono convalide.
Come creare una route
L’ultimo passo da fare prima di testare l’API è aggiungere una route. Per farlo, aggiungete il seguente codice all’interno del file routes/api.php. Aggiungete l’istruzione use all’inizio del file e l’istruzione Route nel corpo:
use AppHttpControllersApiProductController;
Route::apiResource('products', ProductController::class);Prima di iniziare a testare l’API, verificate che la tabella dei prodotti sia presente nel vostro database. Se non esiste, createla usando un pannello di controllo come XAMPP. In alternativa, potete eseguire il comando qui sotto per migrare il database:
php artisan migrateCome testare un’API
Prima di testare l’API, assicuratevi che il metodo authorize all’interno dell’app/Http/Requests/StoreProductRequest.php sia impostato per restituire true.
Ora potete creare un nuovo prodotto utilizzando Postman. Iniziate con una richiesta POST a questo URL: http://127.0.0.1:8000/api/products/. Poiché si tratta di una richiesta POST per creare un nuovo prodotto, dovete passare un oggetto JSON con un titolo e una descrizione.
{
"title":"Apple",
"description":"Best Apples of the world"
}
Dopo aver fatto clic sul pulsante Send, dovreste vedere quanto segue:
Ora recuperate i prodotti creati utilizzando la richiesta GET. L’URL è lo stesso. I risultati saranno i seguenti:
Come autenticare un’API con Sanctum
L’autenticazione è fondamentale per proteggere un’API. Laravel la semplifica fornendo la funzionalità del token Sanctum, che potete usare come middleware. L’API è protetta da token generati quando l’utente accede utilizzando le credenziali corrette. Ricordate che gli utenti non possono accedere all’API protetta senza un token.
Il primo passo per aggiungere l’autenticazione è aggiungere un pacchetto Sanctum con il codice sottostante:
composer require laravel/sanctumQuindi pubblicate il file di configurazione di Sanctum:
php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"Successivamente, aggiungete il token di Sanctum come middleware. All’interno del file app/Http/Kernel.php, usate la seguente classe e sostituite middlewareGroups con il seguente codice nelle API protette dei gruppi middleware.
use LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful;protected $middlewareGroups = [
'web' => [
AppHttpMiddlewareEncryptCookies::class,
IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
IlluminateSessionMiddlewareStartSession::class,
// IlluminateSessionMiddlewareAuthenticateSession::class,
IlluminateViewMiddlewareShareErrorsFromSession::class,
AppHttpMiddlewareVerifyCsrfToken::class,
IlluminateRoutingMiddlewareSubstituteBindings::class,
],
'api' => [
EnsureFrontendRequestsAreStateful::class,
'throttle:api',
IlluminateRoutingMiddlewareSubstituteBindings::class,
],
];Il passo successivo è creare un UserController e aggiungere il codice per ottenere il token di autenticazione.
php artisan make:controller UserControllerDopo aver creato UserController, andate al file app/Http/Controllers/UserController.php e sostituite il codice esistente con il seguente:
<?php
namespace AppHttpControllers;
use IlluminateHttpRequest;
use AppModelsUser;
use IlluminateSupportFacadesHash;
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 testare l’autenticazione, create un utente che impiega i seeders. Il comando seguente crea un file UsersTableSeeder.
php artisan make:seeder UsersTableSeederAll’interno del file database/seeders/UsersTableSeeder.php, sostituite il codice esistente con il seguente per creare l’utente:
<?php
namespace DatabaseSeeders;
use IlluminateDatabaseSeeder;
use IlluminateSupportFacadesDB;
use IlluminateSupportFacadesHash;
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 eseguite il seeder utilizzando questo comando:
php artisan db:seed --class=UsersTableSeederL’ultimo passo rimasto nel flusso di autenticazione è quello di usare il middleware creato per proteggere il percorso. Andate al file routes/api.php e aggiungete la route products all’interno del middleware.
use AppHttpControllersUserController;
Route::group(['middleware' => 'auth:sanctum'], function () {
Route::apiResource('products', ProductController::class);
});
Route::post("login",[UserController::class,'index']);Dopo aver aggiunto una route al middleware, otterrete un errore interno del server se cercate di recuperare i prodotti.
Ma una volta che avrete fatto la connessione, ottenuto un token da usare nell’header, il sistema vi autenticherà e inizierà a funzionare. Potete inviare una richiesta POST a http://127.0.0.1:8000/api/login con il seguente corpo:
{
"email":"[email protected]",
"password":"password"
}
Usate il token ricevuto come token Bearer e aggiungetelo all’header Authorization.
Come gestire gli errori API
Ogni volta che inviate una richiesta al server, questo risponde. Con la risposta, invia anche un codice di stato in base alla natura della risposta. Per esempio, un codice di stato 200 indica che la richiesta è andata a buon fine, mentre un 404 indica che il server non riesce a trovare la risorsa richiesta.
Tuttavia, un codice di stato non è sufficiente. È necessario un messaggio di errore leggibile dall’occhio umano. Laravel offre molti modi per gestire gli errori. Potete usare un blocco try-catch, il metodo fallback o inviare una risposta personalizzata. Il seguente codice aggiunto a UserController ne è la dimostrazione.
if (!$user || !Hash::check($request->password, $user->password)) {
return response([
'message' => ['These credentials do not match our records.']
], 404);
}Riepilogo
L’Eloquent Model di Laravel facilita la creazione, validazione e test delle API. La sua mappatura oggetto-relazionale fornisce un approccio semplice all’interazione con il database.
Inoltre, agendo come middleware, il token Sanctum di Laravel può aiutarvi a proteggere rapidamente le vostre API.
E se avete bisogno di un’ulteriore ottimizzazione, la soluzione Hosting di Database di Kinsta semplifica l’impostazione e la gestione dei database per tutti i vostri progetti web.
Lascia un commento