Guida per Principianti alla Configurazione di un Progetto in Laravel

Tutorial
PHP

In questo articolo, passeremo in rassegna i fondamenti di Laravel e vedremo come possiamo utilizzare Laravel per impostare un piccolo progetto.

Laravel è un potente e elegante framework per applicazioni web PHP che ha guadagnato un’immensa popolarità tra gli sviluppatori grazie alla sua semplicità, versatilità e potente funzionalità. Negli anni, Laravel è diventato il framework PHP di riferimento sia per progetti grandi che piccoli.

Prerequisiti: Iniziare con Laravel

Prima di immergersi nello sviluppo con Laravel, dobbiamo assicurarci di avere tutti gli strumenti e il software necessari installati. Ecco cosa ci servirà:

  • PHP. Laravel funziona con PHP, quindi il primo passo è assicurarsi che PHP sia installato nel tuo sistema. Se non sei sicuro se PHP è installato, apri un terminale o un prompt dei comandi e digita php -v. Se PHP è installato, vedrai un numero di versione. Se non lo è, dovrai installarlo.

    Per installare PHP nel tuo computer abbiamo un paio di opzioni:

    Installazione locale. Puoi installare PHP direttamente sul tuo computer. Visita la pagina di download di PHP per ottenere la versione più recente per il tuo sistema operativo.

    Laravel Homestead. Per un setup più semplificato, specialmente se sei nuovo allo sviluppo PHP, considera l’utilizzo di Laravel Homestead. Homestead è una scatola Vagrant pre-configurata che fornisce un ambiente di sviluppo completo per Laravel. Puoi trovare le istruzioni di installazione qui.

  • Composer. Laravel utilizza Composer per la gestione delle dipendenze. Composer è il gestore di dipendenze predefinito per PHP, è ampiamente utilizzato e ben documentato.

  • Installer Laravel. Laravel può essere installato globalmente nel nostro sistema utilizzando il Installer Laravel, uno strumento di linea di comando conveniente che semplifica e velocizza il processo di creazione di nuovi progetti Laravel. Per installarlo globalmente nel tuo sistema, segui questi passaggi:

    1. Apri un terminale o un prompt dei comandi.
    2. Esegui il seguente comando di Composer:
    composer global require laravel/installer

    Una volta completata l’installazione, assicurati che la directory bin globale di Composer sia nel tuo sistema “PATH” in modo da poter eseguire il comando laravel da qualsiasi posizione.

    Se preferisci un’alternativa più leggera a Homestead, potresti considerare Laravel Herd. Herd è un ambiente di sviluppo locale basato su Docker specificamente adattato per progetti Laravel. Puoi saperne di più su Herd e su come configurarlo qui.

Configurando il tuo ambiente di sviluppo con PHP, Composer e l’Installer di Laravel (o esplorando opzioni come Homestead o Herd), sarai ben preparato per iniziare il tuo viaggio con Laravel. Nelle sezioni seguenti, esamineremo il processo di creazione di un nuovo progetto Laravel, esplorando la sua struttura di directory e configurando l’ambiente di sviluppo.

Configurazione di un Nuovo Progetto Laravel

Ora che abbiamo il nostro ambiente di sviluppo pronto, è il momento di creare un nuovo progetto Laravel. Per creare un nuovo progetto “vuoto”, possiamo utilizzare il seguente comando da terminale:

composer create-project --prefer-dist laravel/laravel project-name

project-name dovrebbe essere sostituito con il nome effettivo del progetto. Questo comando scaricherà la versione più recente di Laravel e configurerà una nuova directory del progetto con tutti i file e le dipendenze necessarie.

Struttura delle Directory: Navigazione in un Progetto Laravel

Dopo aver creato un nuovo progetto Laravel, ci troveremo di fronte a una struttura di directory ben organizzata. Comprendere questa struttura è cruciale per lo sviluppo efficace con Laravel. Ecco alcuni dei principali directory e le loro funzioni:

  • app. Questo directory ospita la logica centrale del nostro applicazione, comprendendo controller, modelli e provider di servizio.
  • bootstrap. I file di bootstrap e configurazione di Laravel risiedono qui.
  • config. I file di configurazione per vari componenti del nostro applicazione si trovano qui, permettendo di trovare e personalizzare impostazioni come connessioni di database e servizi da un unico punto nel progetto.
  • Database. In questo directory, definiremo le nostre migrazioni e semina del database da utilizzare con l’ORM Eloquent di Laravel. Eloquent semplifica la gestione del database.
  • public. Asset accessibili pubblicamente come CSS, JavaScript e immagini appartengono qui. Questo directory contiene anche il punto di ingresso per il nostro applicazione, il file index.php.
  • resources. I nostri asset crudi e non compilati dell’applicazione, come modelli Blade, Sass e JavaScript, sono memorizzati qui.
  • routes. La configurazione delle rotte di Laravel è gestita in questo directory.
  • storage. File temporanei e di cache, così come log, sono memorizzati qui.
  • vendor. Composer gestisce le dipendenze del nostro progetto in questo directory. Tutte le librerie scaricate saranno in questo directory.

Configurazione: Impostazione del Database e Variabili di Ambiente

Per configurare la connessione al nostro database, è necessario aprire il file .env nella directory principale del progetto. Qui, possiamo specificare il tipo di database, l’host, il nome utente, la password e il nome del database. Grazie a Eloquent ORM, Laravel supporta più connessioni a database, rendendolo versatile per varie esigenze dei progetti.

Comprendere il file .env

Il file .env è dove definiamo i valori di configurazione specifici dell’ambiente, come i dettagli della connessione al database, le chiavi API e altre impostazioni. Diamo un’occhiata a un semplice esempio di cosa potresti trovare in un file .env:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=my_database
DB_USERNAME=my_username
DB_PASSWORD=my_password

In questo esempio:

  • DB_CONNECTION specifica il tipo di driver di database che stiamo utilizzando (come MySQL, PostgreSQL, SQLite).
  • DB_HOST specifica l’host dove si trova il nostro server di database.
  • DB_PORT specifica la porta su cui il server di database è in esecuzione.
  • DB_DATABASE specifica il nome del database a cui vogliamo connetterci.
  • DB_USERNAME e DB_PASSWORD specificano il nome utente e la password richiesti per accedere al database.

Utilizzare le variabili di ambiente

È cruciale mantenere sicure informazioni sensibili come le credenziali del database. Laravel incoraggia l’uso delle variabili di ambiente per raggiungere questo obiettivo. Invece di codificare direttamente le nostre credenziali nel file .env, possiamo fare riferimento a esse nei nostri file di configurazione.

Ad esempio, nei nostri file di configurazione Laravel (situati nella directory config/), possiamo fare riferimento alla configurazione del database in questo modo:

'mysql' => [
    'driver' => env('DB_CONNECTION', 'mysql'),
    'host' => env('DB_HOST', '127.0.0.1'),
    'port' => env('DB_PORT', '3306'),
    'database' => env('DB_DATABASE', 'forge'),
    'username' => env('DB_USERNAME', 'forge'),
    'password' => env('DB_PASSWORD', ''),
    // ...
],

In questo caso, la funzione env() recupera il valore dell’ambiente specificato variabile dal file .env. Se la variabile non viene trovata, ricade su un valore predefinito fornito come secondo argomento.

Utilizzando i file di configurazione, possiamo memorizzare i dati sensibili in una posizione più sicura e facilmente passare tra configurazioni di ambienti (come sviluppo e produzione).

Con il nostro progetto Laravel creato, le directory organizzate e il database configurato, siamo pronti per iniziare a costruire la nostra applicazione web. Nelle prossime sezioni, ci concentreremo su routing, controller e lavorare con i modelli Blade per le nostre viste frontend.

Routing, Controllers e Viste: Il Cuore della Tua Applicazione Laravel

In Laravel, routing, controller e viste collaborano per gestire le richieste HTTP e per rendere le pagine web dinamiche. Comprendere questi concetti è essenziale per creare applicazioni web con Laravel.

In breve, le richieste HTTP vengono ricevute dal router, che poi sa quale controller dovrebbe gestire l’azione. Il controller è responsabile del trattamento delle informazioni e della visualizzazione delle informazioni processate attraverso le viste.

Routing

In Laravel, possiamo definire le rotte nel file routes/web.php. Una definizione di base della rotta appare così:

Route::get('/welcome', function () {
    return view('welcome');
});

Questo esempio configura una rotta che, quando viene acceduta, restituisce la vista welcome. Le rotte possono anche essere utilizzate per richiamare azioni del controller, come abbiamo detto sopra, permettendoci di organizzare il codice in modo più efficiente.

Creazione di un controller

Controllers fungono da ponte tra le nostre rotte e la logica del nostro applicativo. Per creare un controller, possiamo utilizzare il comando make:controller:

php artisan make:controller YourControllerName

Il nostro nuovo controller contiene metodi che corrispondono a diverse azioni nel nostro applicativo, come mostrare una pagina o elaborare i dati di un modulo.

Viste e template Blade

Le viste in Laravel sono responsabili della presentazione dei dati del nostro applicativo agli utenti. Out of the box, Laravel utilizza un motore di template chiamato Blade, che semplifica la creazione di viste dinamiche e riutilizzabili. Ecco un esempio di rendering di una vista in un metodo del controller:

public function index()
{
    $data = ['name' => 'John'];
    return view('welcome', $data);
}

In questo esempio, la vista welcome viene renderizzata con dati, in questo caso, 'name' viene passato dentro di essa.

Blade è un motore di template molto potente che permette la creazione di contenuto dinamico attraverso istruzioni condizionali, loop, e così via.

Migrazione e popolamento del database

Il sistema di migrazione e seeding dei database di Laravel ci permette di definire lo schema del nostro database e popolarlo con dati iniziali. Possiamo considerare le migrazioni come modifiche al database gestite in version control, e il seeding come il processo di aggiunta di dati di esempio.

Le migrazioni e lo seeding sono concetti estremamente potenti che consentono la coerenza del database tra diversi ambienti.

Per creare una migrazione, possiamo utilizzare il comando make:migration:

php artisan make:migration create_table_name

Successivamente, possiamo modificare il file di migrazione generato per definire la struttura della nostra tabella e poi utilizzare Artisan per eseguire la migrazione:

php artisan migrate

Lo seeding viene spesso utilizzato per popolare le tabelle con dati iniziali per test e sviluppo. Per creare seeders possiamo utilizzare il comando make:seeder e eseguirli con:

php artisan db:seed

Creazione di Modelli per l’Interazione con il Database

L’ORM Eloquent di Laravel semplifica le interazioni con il database consentendoci di lavorare con i database come se fossero oggetti. Per creare un modello, utilizziamo il comando make:model:

php artisan make:model YourModelName

Definisci la tabella e le relazioni nel modello per facilitare il recupero e la manipolazione dei dati. Ad esempio, per recuperare tutti i record da una tabella users:

$users = YourModelName::all();

Dotati di tutte queste conoscenze, incorporando routing, controller, viste, migrazione del database, seeding e modelli, siamo sulla buona strada per costruire applicazioni web dinamiche con Laravel. Nelle prossime sezioni approfondiremo la creazione di un semplice applicazione CRUD e esploreremo funzionalità avanzate di Laravel.

Creazione di un Semplice CRUD Application in Laravel

Portiamo il nostro viaggio con Laravel al livello successivo costruendo un’applicazione CRUD — in questo caso, un semplice sistema di registrazione di libri, dove possiamo creare, leggere, aggiornare e eliminare libri. Questo esercizio pratico ci aiuterà a capire come implementare operazioni CRUD in Laravel.

Per ragioni di spazio in questo articolo, ci concentreremo solo sulla creazione della pagina iniziale dell’applicazione, quindi dipende da te completare questa applicazione!

Passo 1: Creare una migrazione per la tabella dei libri

Per generare una migrazione per la tabella books, utilizziamo il seguente comando:

php artisan make:migration create_books_table

Questo comando genera un file di migrazione per la creazione della tabella books nel database. Successivamente, modifichiamo il file di migrazione appena creato (database/migrations/AAAA_MM_GG_create_books_table.php) per definire la struttura della tabella:

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateBooksTable extends Migration
{
    public function up()
    {
        Schema::create('books', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->string('author');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('books');
    }
}

In questo file di migrazione, definiamo la struttura della tabella books, inclusa la definizione delle colonne (id, title, author, timestamps). Quindi vogliamo eseguire la migrazione per creare la tabella:

php artisan migrate

Questo comando esegue il file di migrazione e crea la tabella books nel database.

Passo 2: Creare un seeder per la tabella dei libri

Successivamente, vogliamo generare un seeder per la tabella books per popolarla con alcuni dati iniziali:

php artisan make:seeder BooksTableSeeder

Questo comando genera un file di seeder per popolare la tabella books con dati iniziali.

Modifica il file del seeder (database/seeders/BooksTableSeeder.php) per definire i dati di esempio dei libri:

use Illuminate\Database\Seeder;

class BooksTableSeeder extends Seeder
{
    public function run()
    {
        DB::table('books')->insert([
            ['title' => 'Book 1', 'author' => 'Author A'],
            ['title' => 'Book 2', 'author' => 'Author B'],
            ['title' => 'Book 3', 'author' => 'Author C'],
        ]);
    }
}

In questo file di seed, definiamo dati di esempio di libri che saranno inseriti nella tabella books. In questo caso specifico stiamo creando libri da 1 a 3 e autori da A a C.

Esegui il seed per popolare la tabella books:

php artisan db:seed --class=BooksTableSeeder

Questa comando esegue il file di seed e popola la tabella books con i dati di esempio definiti.

Passo 3: Creare un controller

Genera un controller per la gestione dei libri:

php artisan make:controller BookController

Questo comando genera un file controller (BookController.php) che contiene metodi per gestire operazioni CRUD relative ai libri. Con il controller creato, concentriamoci sull’implementazione dei metodi CRUD nel BookController. Si trova in app/Http/Controllers/BookController.php:

use App\Book; // Importa il modello Book

public function index()
{
    $books = Book::all();
    return view('books.index', compact('books'));
}

public function create()
{
    return view('books.create');
}

public function store(Request $request)
{
    $book = new Book;
    $book->title = $request->input('title');
    $book->author = $request->input('author');
    $book->save();

    return redirect()->route('books.index');
}

// Implementa metodi similmente per edit, update, show e delete

In questo file controller, definiamo metodi per gestire operazioni CRUD relative ai libri. Ad esempio, il metodo index recupera tutti i libri dal database e li passa alla vista index, mentre il metodo store crea una nuova registrazione di libro basata sui dati inviati attraverso un form. Il metodo create() è responsabile di visualizzare il form per creare una nuova registrazione di libro. Quando un utente naviga alla rotta associata a questo metodo, Laravel eseguirà questa funzione e restituirà una vista chiamata books.create.

Passo 4: Creare viste

Crea viste per elencare, creare ed editare libri nella cartella resources/views.

Esempio di Vista (create.blade.php):

@extends('layout')

@section('content')
  <h1>Create a New Book</h1>
  <form method="POST" action="{{ route('books.store') }}">
    @csrf
    <div class="form-group">
      <label for="title">Title</label>
      <input type="text" name="title" class="form-control" id="title" placeholder="Enter book title">
    </div>
    <div class="form-group">
      <label for="author">Author</label>
      <input type="text" name="author" class="form-control" id="author" placeholder="Enter author name">
    </div>
    <button type="submit" class="btn btn-primary">Submit</button>
  </form>
  <a href="{{ route('books.index') }}">Back to the list</a>
@endsection

In questo esempio, la vista create contiene un form per aggiungere un nuovo libro. Il form invia i dati al metodo store del BookController. La direttiva @csrf genera un token CSRF per proteggere contro gli attacchi di richiesta forzata tra siti.

Con questo esempio, dovresti essere in grado di implementare i metodi del controller e le viste per il resto delle operazioni CRUD da solo, quindi mettiti al lavoro!

Conclusione

In questo articolo, abbiamo esaminato le basi di un’applicazione Laravel: come possiamo utilizzare la riga di comando per aiutarci a costruire un’applicazione, la struttura di un’applicazione Laravel e come creare un’applicazione CRUD in Laravel.

I hope this article was useful and that you’re now capable of using Laravel to create your applications and expand the information here with more advanced topics. More information on Laravel can be found at the official Laravel website.

Source:
https://www.sitepoint.com/laravel-project-setup-beginners-guide/