Creare ed eseguire un progetto ThinkPHP 8 in ServBay

Questa guida ti accompagnerà passo dopo passo nell'utilizzo di ServBay, un potente ambiente per lo sviluppo web locale, per creare, configurare ed eseguire rapidamente un progetto PHP basato su ThinkPHP 8. ServBay offre un ambiente PHP preconfigurato, server web (Caddy o Nginx) e diversi database, rendendo molto più semplice la configurazione locale di un progetto ThinkPHP.

Cos'è ThinkPHP?

ThinkPHP è un framework PHP open source, veloce e orientato agli oggetti, nato in Cina. Segue principi di sviluppo semplici ed efficienti e mira a fornire agli sviluppatori un set di strumenti pratici per costruire applicazioni web moderne. Grazie alla sua facilità d’uso, alle funzionalità ricche (come un ORM potente, routing flessibile, motore template incorporato, supporto al caching e altro), e il supporto di una comunità attiva, ThinkPHP gode di vasta popolarità nel panorama PHP cinese.

Caratteristiche e vantaggi principali di ThinkPHP

• Semplice ed efficiente: Struttura chiara e ben organizzata, il che facilita la comprensione, manutenzione e rapidità di sviluppo.
• Funzionalità complete: Include tutti i componenti più usati nello sviluppo web come struttura MVC, ORM, motore di template, gestione cache, sessioni, autenticazione, token di form, ecc.
• ORM potente: Offre un sistema ORM facile e avanzato, semplificando le operazioni con il database.
• Routing flessibile: Supporta molteplici modalità per la definizione delle rotte, gestendo anche URL complessi.
• Ecosistema ricco: Numerose librerie e plugin disponibili, con una comunità ampia e attiva che fornisce risorse abbondanti.
• Aggiornamenti continui: Versioni rilasciate frequentemente, sempre al passo con PHP e le tendenze del web.

ThinkPHP si adatta a qualsiasi esigenza di sviluppo web, dai piccoli progetti alle applicazioni aziendali di grandi dimensioni.

Preparare un progetto ThinkPHP 8 con ServBay

ServBay offre l’ambiente ideale per lo sviluppo locale di progetti ThinkPHP 8, inclusi:

• PHP preinstallato in varie versioni e con le estensioni più comuni.
• Server web integrati (Caddy o Nginx) di facile configurazione.
• Integrazione con database come MySQL, PostgreSQL, MongoDB, Redis, Memcached.
• Composer già compreso per la gestione delle dipendenze.

Questa guida sfrutterà tutte queste caratteristiche per configurare rapidamente il tuo progetto ThinkPHP 8.

Prerequisiti

Prima di iniziare, assicurati di aver completato questi passaggi:

1. Hai scaricato e installato ServBay su macOS.
2. ServBay è in esecuzione, la versione PHP richiesta (ThinkPHP 8 richiede almeno PHP 8.0) e i servizi database necessari (come MySQL, PostgreSQL, Redis, Memcached, ecc.) sono attivi. Puoi verificare e avviare questi servizi dal pannello di controllo ServBay, nella scheda "Pacchetti software".

Creare un progetto ThinkPHP

ServBay consiglia di conservare tutti i file dei tuoi siti web locali nella cartella /Applications/ServBay/www. Questo aiuta la gestione e l’organizzazione tramite ServBay.

1. Verifica che Composer sia installato

   ServBay include già Composer preinstallato, quindi non serve installarlo manualmente. Puoi confermare l’installazione avviando il terminale di ServBay e digitando composer --version.

2. Crea un nuovo progetto ThinkPHP con Composer

   Apri il terminale di macOS ed esegui il seguente comando nella cartella root dei siti web ServBay:

   cd /Applications/ServBay/www
   composer create-project topthink/think servbay-thinkphp-app

   Questo comando crea una nuova cartella servbay-thinkphp-app dentro /Applications/ServBay/www e scarica i file principali e le dipendenze di ThinkPHP 8.

3. Entra nella cartella del progetto

   Una volta completata la creazione, accedi alla directory del progetto:

   cd /Applications/ServBay/www/servbay-thinkphp-app

Inizializzare la configurazione del progetto

Dopo aver creato il progetto, sono necessarie alcune configurazioni di base.

1. Configura la connessione al database

   Solitamente la configurazione database di ThinkPHP si trova nel file config/database.php. In base al servizio database attivo in ServBay, modifica questo file con i dati corretti.

   Esempio di configurazione per utilizzare il servizio MySQL predefinito ServBay:

   <?php
   // config/database.php
   
   return [
       // Configurazione di connessione database predefinita
       'default'         => env('database.driver', 'mysql'),
   
       // Configurazioni per ciascun database
       'connections'     => [
           'mysql' => [
               // Tipo di database
               'type'     => 'mysql',
               // Indirizzo del server
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nome database
               'database' => env('database.database', 'servbay_thinkphp_app'), // Consigliato creare un solo database per progetto
               // Nome utente
               'username' => env('database.username', 'root'),
               // Password
               'password' => env('database.password', 'password'), // Password predefinita ServBay, SOLO per sviluppo locale!
               // Porta
               'hostport' => env('database.hostport', '3306'),
               // ... altre configurazioni ...
           ],
           // ... altre configurazioni database ...
       ],
   ];

   Nota importante:

   • Modifica il valore di database con il vero nome del database che hai creato per il progetto (puoi creare un database tramite phpMyAdmin o Adminer in ServBay, consigliato chiamarlo servbay_thinkphp_app).
   • La password predefinita dell’utente root di ServBay è password. Usa questa combinazione solo per lo sviluppo locale – NON utilizzare in produzione! In produzione crea un utente con permessi minimi e una password robusta.
   • Se usi un file .env per le variabili d’ambiente, assicurati che le configurazioni lì indicate sovrascrivano i valori di default di config/database.php.

Configurare il server web

Il file di ingresso di ThinkPHP è public/index.php e il framework richiede regole di rewrite degli URL per la gestione delle rotte. Dal momento che il routing ThinkPHP non corrisponde a percorsi statici tradizionali, dovrai utilizzare le regole di rewrite integrate di ServBay.

Nel pannello di configurazione del sito web, seleziona ThinkPHP dal menu a tendina delle regole di rewrite e salva.

Per dettagli sulla configurazione del sito web in ServBay, consulta la guida Aggiungi il tuo primo sito web.

Aggiungere codice di esempio

Per verificare che la configurazione sia corretta e che routing e funzioni base ThinkPHP funzionino, aggiungi una semplice rotta e controller nel progetto.

Modifica il file /Applications/ServBay/www/servbay-thinkphp-app/route/app.php e aggiungi questo codice per definire una semplice rotta GET:

<?php
// route/app.php

use think\facade\Route;

// Definisci la rotta servbay, visita /servbay per eseguire la funzione anonima
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... altre rotte ...

Accedi al sito web

Terminata la configurazione, apri il browser e visita il dominio locale e la rotta di esempio:

https://thinkphp.servbay.demo/servbay

Se tutto è avvenuto correttamente, dovresti vedere Hello ServBay! a schermo. Questo significa che il progetto ThinkPHP 8 è attivo su ServBay e che Web Server e PHP-FPM sono configurati.

Esempio di database NoSQL

ServBay include diversi database NoSQL come Memcached e Redis. ThinkPHP offre un layer di astrazione per la cache, integrando facilmente servizi NoSQL come driver per la cache.

Esempio Memcached

1. Installazione dell’estensione Memcached

   L’estensione Memcached è già installata nei pacchetti PHP di ServBay. Basta assicurarsi che il servizio Memcached sia avviato dalla scheda "Pacchetti software" del pannello ServBay.

2. Configurazione della cache Memcached

   Modifica il file config/cache.php per usare Memcached come driver della cache:

   <?php
   // config/cache.php
   
   return [
       // Driver di cache predefinito
       'default' => env('cache.driver', 'memcached'),
   
       // Configurazione connessioni cache
       'stores'  => [
           'memcached' => [
               // Tipo cache
               'type'       => 'memcached',
               // Elenco server
               'host'       => '127.0.0.1', // Indirizzo predefinito Memcached ServBay
               'port'       => 11211, // Porta predefinita Memcached ServBay
               'persistent' => false,
               'expire'     => 0,
               'timeout'    => 0,
               'prefix'     => '',
           ],
           // ... altre configurazioni cache ...
       ],
   ];

3. Usare la cache Memcached nel codice

   Utilizza la Facade Cache di ThinkPHP nei controller o nelle callback delle route:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/memcached-example', function () {
       // Imposta una cache valida per 600 secondi
       Cache::set('my_memcached_key', 'Questo valore viene da Memcached!', 600);
   
       // Recupera il valore dalla cache
       $value = Cache::get('my_memcached_key');
   
       return 'Valore da Memcached: ' . $value;
   });

   Visita https://thinkphp.servbay.demo/memcached-example per testare.

Esempio Redis

1. Installazione dell’estensione Redis

   Anche Redis è già incluso tra le estensioni PHP di ServBay. Basta assicurarsi che il servizio Redis sia attivo tramite il pannello ServBay.

2. Configurazione della cache Redis

   Modifica config/cache.php per usare Redis come driver di cache:

   <?php
   // config/cache.php
   
   return [
       // Driver cache predefinito
       'default' => env('cache.driver', 'redis'),
   
       // Configurazione connessioni cache
       'stores'  => [
           'redis' => [
               // Tipo cache
               'type'       => 'redis',
               // Indirizzo server
               'host'       => env('cache.host', '127.0.0.1'), // Indirizzo predefinito Redis ServBay
               // Porta
               'port'       => env('cache.port', 6379), // Porta predefinita ServBay Redis
               // Password (nessuna di default)
               'password'   => env('cache.password', ''), // ServBay Redis predefinito senza password
               'select'     => 0,
               'timeout'    => 0,
               'expire'     => 0,
               'persistent' => false,
               'prefix'     => '',
           ],
           // ... altre configurazioni cache ...
       ],
   ];

   Attenzione: Di default il Redis di ServBay non ha password configurata. Se imposti manualmente una password, aggiornala anche nella configurazione.

3. Usare la cache Redis nel codice

   Utilizza la Facade Cache di ThinkPHP nel controller o nelle callback delle route:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/redis-example', function () {
       // Imposta una cache permanente (o fissa la scadenza col terzo parametro)
       Cache::set('my_redis_key', 'Ciao da Redis!');
   
       // Recupera il valore dalla cache
       $value = Cache::get('my_redis_key');
   
       return 'Valore da Redis: ' . $value;
   });

   Visita https://thinkphp.servbay.demo/redis-example per testare.

Esempio di database relazionali

ServBay integra MySQL e PostgreSQL, i principali database relazionali. L’ORM di ThinkPHP consente di interagire facilmente con questi database.

Utilizzare lo strumento di migrazione database di ThinkPHP

Con ThinkPHP puoi utilizzare un sistema di migrazione per gestire i cambiamenti nella struttura dei database, utile sia per la collaborazione che per il versionamento.

1. Installa lo strumento di migrazione

   Dalla root del progetto, usa Composer per installare l’estensione di migrazione ThinkPHP:

   cd /Applications/ServBay/www/servbay-thinkphp-app
   composer require topthink/think-migration

2. Crea un file di migrazione

   Usa la CLI ThinkPHP per generare una nuova migrazione, ad esempio per la tabella users:

   php think migrate:create CreateUserTable

   Questo comando genera un nuovo file PHP nella cartella database/migrations, intitolato con timestamp e nome scelto (ad esempio 20231027100000_create_user_table.php).

3. Modifica il file di migrazione

   Apri il nuovo file in database/migrations e definisci la struttura della tabella users nel metodo up():

   <?php
   // database/migrations/YYYYMMDDHHMMSS_create_user_table.php
   
   use think\migration\Migrator;
   use think\migration\db\Column;
   
   class CreateUserTable extends Migrator
   {
       /**
        * Metodo Change.
        *
        * Scrivi qui le migrazioni reversibili.
        *
        * Maggiori dettagli sulle migrazioni:
        * http://docs.phinx.org/en/latest/migrations.html#the-change-method
        *
        * I seguenti comandi possono essere usati e saranno automaticamente annullati in fase di rollback:
        *
        * createTable
        * renameTable
        * addColumn
        * addCustomColumn
        * renameColumn
        * addIndex
        * addForeignKey
        * createDatabase
        * renameDatabase
        * dropTable
        * dropColumn
        * dropIndex
        * dropForeignKey
        */
       public function change()
       {
           // Crea la tabella usando il metodo createTable
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nome utente'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Indirizzo email'])
                 ->addIndex(['email'], ['unique' => true]) // Aggiungi indice univoco
                 ->addTimestamps() // Aggiungi i campi created_at e updated_at
                 ->create(); // Crea la tabella
       }
   
       // Se non si utilizza change, è possibile definire separatamente up() e down()
       /*
       public function up()
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nome utente'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Indirizzo email'])
                 ->addIndex(['email'], ['unique' => true])
                 ->addTimestamps()
                 ->create();
       }
   
       public function down()
       {
           $this->dropTable('users');
       }
       */
   }

4. Esegui la migrazione database

   Dalla root del progetto nel terminale ServBay, esegui la migrazione per creare la tabella users:

   php think migrate:run

   Se tutto va a buon fine, troverai la nuova tabella users nel tuo database.

Esempio MySQL

Ipotesi: il servizio MySQL è avviato in ServBay e la connessione è configurata in config/database.php.

1. Configura la connessione MySQL

   Assicurati che la sezione mysql in config/database.php sia compilata come mostrato nel precedente esempio.

2. Scrivere dati utente nel codice

   Usa la Facade Db di ThinkPHP o l’ORM per inserire dati, ad esempio così:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/mysql-add-user', function () {
       try {
           Db::table('users')->insert([
               'name' => 'ServBay Demo User',
               'email' => '[email protected]', // Email di esempio con il brand
               'created_at' => date('Y-m-d H:i:s'), // Timestamp manuale se addTimestamps() non autoinserisce
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'Utente aggiunto con successo!';
       } catch (\Exception $e) {
           return 'Errore aggiunta utente: ' . $e->getMessage();
       }
   });

   Visita https://thinkphp.servbay.demo/mysql-add-user per testare l’inserimento.

3. Leggere dati utente nel codice

   Usa la Facade Db o l’ORM per recuperare i dati:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/mysql-users', function () {
       $users = Db::table('users')->select(); // Recupera tutti gli utenti
       return json($users); // Restituisce il risultato in formato JSON
   });

   Visita https://thinkphp.servbay.demo/mysql-users per vedere i dati nella tabella users.

Esempio PostgreSQL

Ipotesi: servizio PostgreSQL attivo e connessione configurata in config/database.php.

1. Configura la connessione PostgreSQL

   In config/database.php, controlla che la sezione seguente sia presente e aggiornata con i tuoi dati reali:

   <?php
   // config/database.php (sezione)
   
   return [
       // ... altre configurazioni ...
   
       'connections'     => [
           // ... configurazione MySQL ...
   
           'pgsql' => [
               // Tipo di database
               'type'     => 'pgsql',
               // Indirizzo server
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nome database
               'database' => env('database.database', 'servbay_thinkphp_app'), // Consigliato creare un database per progetto
               // Nome utente
               'username' => env('database.username', 'root'),
               // Password
               'password' => env('database.password', 'password'), // Password predefinita ServBay, SOLO per sviluppo locale!
               // Porta
               'hostport' => env('database.hostport', '5432'), // Porta default PostgreSQL
               // ... altre configurazioni ...
           ],
           // ... altre configurazioni database ...
       ],
   ];

   Nota importante:

   • Come per MySQL, crea un nuovo database PostgreSQL dedicato al progetto e aggiorna la configurazione.
   • La password di default per l’utente root in PostgreSQL su ServBay è anch’essa password. Usala solo in locale.

2. Scrivere dati utente nel codice

   Usa la Facade Db o l’ORM indicando il collegamento pgsql:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-add-user', function () {
       try {
           Db::connect('pgsql')->table('users')->insert([ // Usa la connessione pgsql
               'name' => 'ServBay PgSQL User',
               'email' => '[email protected]', // Email di esempio con il brand
               // I campi timestamp potrebbero richiedere inserimento manuale
               'created_at' => date('Y-m-d H:i:s'),
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'Utente PostgreSQL aggiunto con successo!';
       } catch (\Exception $e) {
            return 'Errore aggiunta utente PostgreSQL: ' . $e->getMessage();
       }
   });

   Visita https://thinkphp.servbay.demo/pgsql-add-user per testare l’inserimento.

3. Leggere dati utente nel codice

   Usa la Facade Db o l’ORM, specificando la connessione pgsql:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-users', function () {
       $users = Db::connect('pgsql')->table('users')->select(); // Recupera utenti tramite connessione pgsql
       return json($users); // Restituisce il risultato in JSON
   });

   Visita https://thinkphp.servbay.demo/pgsql-users per vedere i dati nella tabella users di PostgreSQL.

Conclusione

Seguendo le indicazioni di questa guida, sei riuscito a creare, configurare ed eseguire con successo un progetto ThinkPHP 8 usando l’ambiente di sviluppo locale ServBay. Hai appreso come creare un progetto tramite Composer, configurare il web server Caddy per gestire il routing ThinkPHP e come utilizzare i servizi database integrati ServBay, inclusi MySQL, PostgreSQL, Memcached e Redis.

ServBay facilita enormemente la configurazione di ambienti di sviluppo PHP locali, permettendoti di concentrarti solo sulla logica di business. Ora puoi proseguire nello sviluppo delle tue applicazioni ThinkPHP, sfruttando tutte le funzionalità offerte da ServBay.