Laravel è un framework PHP molto popolare per la creazione di applicazioni web moderne e dinamiche nel panorama dello sviluppo web odierno, in continua e rapida evoluzione. Una delle sue caratteristiche principali è Laravel Eloquent, un mapper relazionale a oggetti (ORM) che consente a chi sviluppa di eseguire in modo efficiente le operazioni di creazione, lettura, aggiornamento e cancellazione (Create, Read, Update, e Delete, che compongono l’acronimo CRUD) su un database.
Questo tutorial mostra come eseguire queste operazioni in un’applicazione Laravel usando l’ORM Eloquent di Laravel e come distribuire un’applicazione Laravel CRUD con MyKinsta.
Funzionalità CRUD in Laravel
Le operazioni CRUD sono la spina dorsale di qualsiasi applicazione fondata su database. Permettono di eseguire le operazioni più basilari ed essenziali del database, come la creazione di nuovi record, la lettura di quelli esistenti, l’aggiornamento e la cancellazione. Queste operazioni sono fondamentali per la funzionalità di qualsiasi applicazione Laravel che interagisce con un database.
Eloquent offre un modo semplice e intuitivo di interagire con il database, riducendo le complessità della gestione del database in modo che possiate concentrarvi sulla creazione della vostra applicazione. I suoi metodi e le sue classi integrate permettono di eseguire facilmente il CRUD dei record nel database.
Prerequisiti
Per seguire questo tutorial, è necessario avere i seguenti requisiti:
- XAMPP
- Composer
- Un account MyKinsta
- Un account su GitHub, GitLab o Bitbucket per inviare il vostro codice
- Bootstrap versione 5
Passaggi
- Installare Laravel e creare una nuova applicazione
- Creare un database
- Creare una tabella
- Creare un controller
- Impostare il modello
- Aggiungere un percorso
- Generare i file Blade
- Distribuire e testare la vostra applicazione CRUD
Per avere una guida lungo il percorso, date un’occhiata al codice completo del tutorial.
Installare Laravel e creare una nuova applicazione
Aprite il terminale in cui volete creare la vostra applicazione Laravel e seguite i passaggi qui sotto.
- Per installare Laravel, eseguite:
composer global require laravel/installer- Per creare una nuova applicazione Laravel, eseguite:
laravel new crudpostsCreare un database
Per creare un nuovo database per la vostra applicazione:
- Avviate i server Apache e MySQL nel pannello di controllo di XAMPP e visitate
http://localhost/phpmyadminnel browser.
- Fate clic su New nella barra laterale sinistra. Dovreste vedere quanto segue:
- Aggiungete un nome al database e fate clic su Create.
- Modificate il file .env della vostra applicazione nella root dell’applicazione Laravel. Esso contiene tutte le variabili d’ambiente utilizzate dall’applicazione. Individuate le variabili con il prefisso
DB_e modificatele con le credenziali del vostro database:
DB_CONNECTION=
DB_HOST=
DB_PORT=
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=Creare una tabella
Le righe di dati della vostra applicazione sono memorizzate in tabelle. Per questa applicazione avete bisogno di una sola tabella, creata usando le migrazioni di Laravel.
- Per creare una tabella e generare un file di migrazione utilizzando l’interfaccia a riga di comando di Laravel, Artisan, eseguite questo codice:
php artisan make:migration create_posts_tableIl comando precedente crea un nuovo file,
yyyy_mm_dd_hhmmss_create_posts_table.php, in database/migrazioni.
- Aprite yyyy_mm_dd_hhmmss_create_posts_table.php per definire le colonne che desiderate all’interno della tabella del database nella funzione up:
public function up()
{
Schema::create('posts', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text('body');
$table->timestamps();
});
}Questo codice definisce il contenuto della tabella dei post. Ha quattro colonne: id, title, body, e timestamps.
- Eseguite i file di migrazione nella cartella database/migrations per creare le tabelle nel database:
php artisan migrateL’output appare come questo:
- Andate al database creato in precedenza per confermare la creazione delle tabelle:
Creare un controller
Il controller contiene tutte le funzioni per il CRUD dei post dal database.
Generate un file controller all’interno della vostra applicazione Laravel usando Artisan:
php artisan make:controller PostController --apiL’esecuzione di questo comando crea un file PostController.php in app/Http/Controllers, con codice boilerplate e dichiarazioni di funzioni vuote index, store, show, update, e destroy.
Creare le funzioni
Quindi, create le funzioni che memorizzano, indicizzano, aggiornano, distruggono, creano, mostrano e modificano i dati.
Potete aggiungerle al file app/Http/Controller/PostController.php mostrato di seguito.
La funzione store
La funzione store aggiunge un post al database.
Scorrete fino alla funzione store e aggiungete il seguente codice all’interno delle parentesi graffe vuote:
$request->validate([
'title' => 'required|max:255',
'body' => 'required',
]);
Post::create($request->all());
return redirect()->route('posts.index')
->with('success','Post created successfully.');Questo codice prende un oggetto contenente il titolo e il corpo del post, convalida i dati, aggiunge un nuovo post al database se i dati sono validi e reindirizza l’utente alla homepage con un messaggio di successo.
La funzione index
La funzione index recupera tutti i post dal database e invia i dati al file posts.index della pagina posts.index.
La funzione update
La funzione update contiene l’id del post da aggiornare, il nuovo post title e il body. Dopo aver convalidato i dati, trovate il post con lo stesso id. Se lo trovate, la funzione update aggiorna il post nel database con i nuovi title e body. Quindi, reindirizzate l’utente alla homepage con un messaggio di successo.
La funzione destroy
La funzione destroy trova un post con il dato id e lo cancella dal database, quindi reindirizza l’utente alla homepage con un messaggio di successo.
Le funzioni di cui sopra sono le funzioni utilizzate per il CRUD dei post dal database. Tuttavia, dovete definire altre funzioni all’interno del controller per rendere le pagine necessarie in resources/views/posts/.
La funzione create
La funzione create rende la pagina resources/views/posts/create.blade.php che contiene il modulo per aggiungere i post al database.
La funzione show
La funzione show trova nel database un post con il nome id indicato e visualizza la pagina resources/views/posts/show.blade.php con il post.
La funzione edit
La funzione edit trova un post con il dato id nel database e visualizza il file resources/views/posts/edit.blade.php con i dettagli del post all’interno di un modulo.
Configurare il modello
Il modello Post interagisce con la tabella dei post del database.
- Per creare un modello con Artisan, eseguite:
php artisan make:model PostQuesto codice crea un file Post.php all’interno della cartella App/Models.
- Create un array
<fillable. Aggiungete il seguente codice all’interno della classePoste sotto la rigause HasFactory;
protected $fillable = [
'title',
'body',
];Questo codice crea un array fillable che vi permette di aggiungere elementi al database dalla vostra applicazione Laravel.
- Collegate il modello
Postal file PostController.php. Aprite PostController.php e aggiungete la riga sottostante sottouse Illuminate\Http\Request;. Il risultato è il seguente:
use Illuminate\Http\Request;
use App\Models\Post;Il file PostController.php dovrebbe ora avere questo aspetto:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Models\Post;
class PostController extends Controller
{
/**
* Display a listing of the resource.
*
* @return \Illuminate\Http\Response
*/
public function index()
{
$posts = Post::all();
return view('posts.index', compact('posts'));
}
/**
* Store a newly created resource in storage.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
public function store(Request $request)
{
$request->validate([
'title' => 'required|max:255',
'body' => 'required',
]);
Post::create($request->all());
return redirect()->route('posts.index')
->with('success', 'Post created successfully.');
}
/**
* Update the specified resource in storage.
*
* @param \Illuminate\Http\Request $request
* @param int $id
* @return \Illuminate\Http\Response
*/
public function update(Request $request, $id)
{
$request->validate([
'title' => 'required|max:255',
'body' => 'required',
]);
$post = Post::find($id);
$post->update($request->all());
return redirect()->route('posts.index')
->with('success', 'Post updated successfully.');
}
/**
* Remove the specified resource from storage.
*
* @param int $id
* @return \Illuminate\Http\Response
*/
public function destroy($id)
{
$post = Post::find($id);
$post->delete();
return redirect()->route('posts.index')
->with('success', 'Post deleted successfully');
}
// routes functions
/**
* Show the form for creating a new post.
*
* @return \Illuminate\Http\Response
*/
public function create()
{
return view('posts.create');
}
/**
* Display the specified resource.
*
* @param int $id
* @return \Illuminate\Http\Response
*/
public function show($id)
{
$post = Post::find($id);
return view('posts.show', compact('post'));
}
/**
* Show the form for editing the specified post.
*
* @param int $id
* @return \Illuminate\Http\Response
*/
public function edit($id)
{
$post = Post::find($id);
return view('posts.edit', compact('post'));
}
}Aggiungere le route
Dopo aver creato le funzioni del controller e il modello Post, dovete aggiungere le route per le funzioni del controller.
- Aprite routes/web.php e cancellate la route boilerplate generata dall’applicazione. Sostituitela con il codice seguente per collegare le funzioni del controller alle rispettive route:
// returns the home page with all posts
Route::get('/', PostController::class .'@index')->name('posts.index');
// returns the form for adding a post
Route::get('/posts/create', PostController::class . '@create')->name('posts.create');
// adds a post to the database
Route::post('/posts', PostController::class .'@store')->name('posts.store');
// returns a page that shows a full post
Route::get('/posts/{post}', PostController::class .'@show')->name('posts.show');
// returns the form for editing a post
Route::get('/posts/{post}/edit', PostController::class .'@edit')->name('posts.edit');
// updates a post
Route::put('/posts/{post}', PostController::class .'@update')->name('posts.update');
// deletes a post
Route::delete('/posts/{post}', PostController::class .'@destroy')->name('posts.destroy');- Per collegare le route, aprite app/Http/Controllers/PostController.php e aggiungete la riga sottostante sotto la linea
use Illuminate\Support\Facades\Route;:
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\PostController;Il file routes/web.php dovrebbe ora avere questo aspetto:
<?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\PostController;
// returns the home page with all posts
Route::get('/', PostController::class .'@index')->name('posts.index');
// returns the form for adding a post
Route::get('/posts/create', PostController::class . '@create')->name('posts.create');
// adds a post to the database
Route::post('/posts', PostController::class .'@store')->name('posts.store');
// returns a page that shows a full post
Route::get('/posts/{post}', PostController::class .'@show')->name('posts.show');
// returns the form for editing a post
Route::get('/posts/{post}/edit', PostController::class .'@edit')->name('posts.edit');
// updates a post
Route::put('/posts/{post}', PostController::class .'@update')->name('posts.update');
// deletes a post
Route::delete('/posts/{post}', PostController::class .'@destroy')->name('posts.destroy');Generare i file Blade
Ora che avete le route, potete creare i file Laravel Blade. Prima di usare Artisan per generare i file Blade, create il comando make:view, con il quale potrete generare i file blade.php.
- Eseguite il seguente codice nella CLI per creare un file di comando MakeViewCommand all’interno della cartella app/Console/Commands :
php artisan make:command MakeViewCommand- Create un comando per generare i file .blade.php dalla CLI sostituendo il codice nel file MakeViewCommand con il seguente:
<?php
namespace App\Console\Commands;
use Illuminate\Console\Command;
use File;
class MakeViewCommand extends Command
{
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'make:view {view}';
/**
* The console command description.
*
* @var string
*/
protected $description = 'Create a new blade template.';
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
$view = $this->argument('view');
$path = $this->viewPath($view);
$this->createDir($path);
if (File::exists($path))
{
$this->error("File {$path} already exists!");
return;
}
File::put($path, $path);
$this->info("File {$path} created.");
}
/**
* Get the view full path.
*
* @param string $view
*
* @return string
*/
public function viewPath($view)
{
$view = str_replace('.', '/', $view) . '.blade.php';
$path = "resources/views/{$view}";
return $path;
}
/**
* Create a view directory if it does not exist.
*
* @param $path
*/
public function createDir($path)
{
$dir = dirname($path);
if (!file_exists($dir))
{
mkdir($dir, 0777, true);
}
}
}Creare una homepage
Successivamente, create la homepage. La homepage è il file index.blade.php, che elenca tutti i post.
- Per creare la homepage, eseguite:
php artisan make:view posts.indexQuesto crea una cartella posts all’interno della cartella /resources/views e un file index.blade.php sotto di essa. Il percorso risultante è /resources/views/posts/index.blade.php.
- Aggiungete il seguente codice all’interno del file index.blade.php:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet"
integrity="sha384-GLhlTQ8iRABdZLl6O3oVMWSktQOp6b7In1Zl3/Jr59b6EGGoI1aFkw7cmDA6j6gD" crossorigin="anonymous">
<title>Posts</title>
</head>
<body>
<nav class="navbar navbar-expand-lg navbar-light bg-warning">
<div class="container-fluid">
<a class="navbar-brand h1" href={{ route('posts.index') }}>CRUDPosts</a>
<div class="justify-end ">
<div class="col ">
<a class="btn btn-sm btn-success" href={{ route('posts.create') }}>Add Post</a>
</div>
</div>
</div>
</nav>
<div class="container mt-5">
<div class="row">
@foreach ($posts as $post)
<div class="col-sm">
<div class="card">
<div class="card-header">
<h5 class="card-title">{{ $post->title }}</h5>
</div>
<div class="card-body">
<p class="card-text">{{ $post->body }}</p>
</div>
<div class="card-footer">
<div class="row">
<div class="col-sm">
<a href="{{ route('posts.edit', $post->id) }}"
class="btn btn-primary btn-sm">Edit</a>
</div>
<div class="col-sm">
<form action="{{ route('posts.destroy', $post->id) }}" method="post">
@csrf
@method('DELETE')
<button type="submit" class="btn btn-danger btn-sm">Delete</button>
</form>
</div>
</div>
</div>
</div>
</div>
@endforeach
</div>
</div>
</body>
</html>Il codice qui sopra crea una semplice pagina HTML che si serve di Bootstrap per lo styling. Crea una barra di navigazione e un modello a griglia che elenca tutti i post del database con i dettagli e due pulsanti di azione – modifica e cancellazione – utilizzando l’helper @foreach Blade.
Il pulsante Edit porta l’utente alla pagina Edit post, dove può modificare il post. Il pulsante Delete elimina il post dal database utilizzando {{ route('posts.destroy', $post->id) }} con un metodo DELETE.
Nota: il codice della navbar per tutti i file è lo stesso del file precedente.
- Create la pagina create.blade.php. Il file Blade chiamato create aggiunge post al database. Usate il seguente comando per generare il file:
php artisan make:view posts.createQuesto genera un file create.blade.php all’interno della cartella /resources/views/posts .
- Aggiungete il seguente codice al file create.blade.php:
// same as the previous file. Add the following after the nav tag and before the closing body tag.
<div class="container h-100 mt-5">
<div class="row h-100 justify-content-center align-items-center">
<div class="col-10 col-md-8 col-lg-6">
<h3>Add a Post</h3>
<form action="{{ route('posts.store') }}" method="post">
@csrf
<div class="form-group">
<label for="title">Title</label>
<input type="text" class="form-control" id="title" name="title" required>
</div>
<div class="form-group">
<label for="body">Body</label>
<textarea class="form-control" id="body" name="body" rows="3" required></textarea>
</div>
<br>
<button type="submit" class="btn btn-primary">Create Post</button>
</form>
</div>
</div>
</div>Il codice qui sopra crea un modulo con i campi title e body e un pulsante submit per aggiungere un post al database attraverso l’azione {{ route('posts.store') }} con un metodo POST.
- Create la pagina Edit post per modificare i post nel database. Usate il seguente comando per generare il file:
php artisan make:view posts.editQuesto crea un file edit.blade.php all’interno della cartella /resources/views/posts.
- Aggiungete il seguente codice al file edit.blade.php:
<div class="container h-100 mt-5">
<div class="row h-100 justify-content-center align-items-center">
<div class="col-10 col-md-8 col-lg-6">
<h3>Update Post</h3>
<form action="{{ route('posts.update', $post->id) }}" method="post">
@csrf
@method('PUT')
<div class="form-group">
<label for="title">Title</label>
<input type="text" class="form-control" id="title" name="title"
value="{{ $post->title }}" required>
</div>
<div class="form-group">
<label for="body">Body</label>
<textarea class="form-control" id="body" name="body" rows="3" required>{{ $post->body }}</textarea>
</div>
<button type="submit" class="btn mt-3 btn-primary">Update Post</button>
</form>
</div>
</div>
</div>
Il codice qui sopra crea un modulo con i campi title e body e un pulsante di invio per modificare un post con il nome id specificato nel database attraverso l’azione {{ route('posts.update') }} con un metodo PUT.
- Quindi riavviate il server dell’applicazione usando il codice seguente:
php artisan serveVisitate http://127.0.0.1:8000 sul browser per visualizzare il nuovo blog. Fate clic sul pulsante Add post per aggiungere nuovi post.
Distribuire e testare l’applicazione CRUD
Preparate la vostra applicazione per la distribuzione come segue.
- Semplificate il deploy e rendetelo immediato dichiarando la cartella pubblica. Aggiungete un file .htaccess alla radice della cartella dell’applicazione con il seguente codice:
<IfModule mod_rewrite.c >
RewriteEngine On
RewriteRule ^(.*)$ public/$1 [L]
</IfModule >- Forzate l’applicazione a usare
HTTPSaggiungendo il seguente codice sopra i vostri percorsi all’interno del file routes/web.php:
use Illuminate\Support\Facades\URL;
URL::forceScheme('https');- Inviate il vostro codice a un repository Git. Kinsta supporta le distribuzioni da GitHub, GitLab o Bitbucket.
Creare un progetto su MyKinsta
- Create un account MyKinsta se non ne avete già uno.
- Accedete al vostro account e fate clic sul pulsante Aggiungi servizio nella dashboard per creare una nuova applicazione.
- Se l’applicazione è nuova, collegatevi al vostro account GitHub, GitLab o Bitbucket e fornite le autorizzazioni specifiche.
- Compilate il modulo e aggiungete
APP_KEY. Potete trovare il valore corrispondente nel vostro file .env.
- Selezionate le risorse di build e scegliete se usare il percorso di build della vostra applicazione o se compilare l’applicazione con Dockerfile. Per questa dimostrazione, lasciate che MyKinsta costruisca l’applicazione sulla base del vostro repository.
- Specificate i diversi processi che volete eseguire durante la distribuzione. A questo punto potete lasciarlo vuoto.
- Infine, aggiungete il metodo di pagamento.
Dopo aver confermato il metodo di pagamento, MyKinsta distribuisce la vostra applicazione e vi assegna un URL come mostrato di seguito:
Potete visitare il link, ma vi appare una pagina 500 | Server Error perché l’applicazione ha bisogno di una connessione al database valida per funzionare. La sezione seguente risolve questo problema.
Creare un database tramite MyKinsta
- Per creare un database, accedete alla dashboard di MyKinsta e fate clic su Aggiungi servizio.
- Selezionate Database e completate il modulo con il nome, il tipo, il nome utente e la password del database che preferite. Aggiungete la posizione del centro dati e la dimensione del database adatta alla vostra applicazione.
- La pagina successiva mostra il riepilogo dei costi e il metodo di pagamento. Fate clic su Crea database per completare la procedura.
- Dopo aver creato il database, MyKinsta vi reindirizza all’elenco dei servizi. Fate clic sul database appena creato e scorrete verso il basso fino a Connessioni esterne. Copiate le credenziali del database.
- Tornate alla pagina di distribuzione dell’applicazione e fate clic su Impostazioni. Quindi, scorrete fino a Variabili d’ambiente e fate clic su Aggiungi variabili d’ambiente. Aggiungete le credenziali del database come variabili d’ambiente nel seguente ordine:
DB_CONNECTION=mysql
DB_HOST=External hostname
DB_PORT=External port
DB_DATABASE=Database name
DB_USERNAME=Username
DB_PASSWORD=PasswordL’elenco delle variabili d’ambiente dell’applicazione dovrebbe ora apparire come segue:
- Andate alla pagina Distribuzioni della vostra applicazione e distribuite manualmente l’applicazione facendo clic su Distribuisci ora per applicare queste modifiche. Finora avete creato un database e lo avete collegato alla vostra applicazione.
- Infine, per creare le tabelle del database di MyKinsta, connettete il database alla vostra applicazione locale aggiornando il file .env con le stesse credenziali che avete inserito nell’applicazione di MyKinsta. Eseguite il seguente comando:
php artisan migrateQuesto comando esegue tutti i file di migrazione. Crea tutte le tabelle definite nella vostra applicazione MyKinsta.
Ora potete testare l’applicazione con l’URL assegnato dopo la prima distribuzione.
Riepilogo
Laravel è un framework completo per creare applicazioni web robuste e scalabili che richiedono funzionalità CRUD. Grazie alla sua sintassi intuitiva e alle sue potenti funzionalità, Laravel permette di integrare facilmente le operazioni CRUD nelle vostre applicazioni.
In questo articolo abbiamo visto i concetti fondamentali delle operazioni CRUD e come implementarle utilizzando le funzionalità integrate di Laravel. Inoltre abbiamo spiegato:
- Come creare un database in MyKinsta e collegarlo alla vostra applicazione
- Come usare le migrazioni di Laravel per definire la tabella del database, creare il file del controller e le sue funzioni
- Definire un modello e collegarlo al controller. Il routing di Laravel genera i file Blade per creare le pagine e i moduli corrispondenti e per distribuire e testare l’applicazione utilizzando MyKinsta
Ora che avete visto quanto è facile eseguire operazioni CRUD in Laravel, date un’occhiata a MyKinsta per lo sviluppo e l’hosting di applicazioni web.
Lascia un commento