Creazione e Avvio di un Progetto ThinkPHP 8 con ServBay

In questa guida scoprirai come utilizzare ServBay, potente ambiente di sviluppo web locale, per creare, configurare e avviare rapidamente un progetto PHP basato sul framework ThinkPHP 8. ServBay offre ambienti PHP pre-configurati, server web (Caddy o Nginx) e molteplici opzioni di database, semplificando drasticamente la gestione locale di progetti ThinkPHP.

Cos’è ThinkPHP?

ThinkPHP è un framework PHP open-source nato in Cina; rapido, semplice, orientato agli oggetti e progettato per favorire lo sviluppo snello ed efficiente. Offre agli sviluppatori un ricco set di strumenti per costruire applicazioni web moderne. ThinkPHP è molto popolare nel panorama PHP cinese, grazie alla sua facilità d'uso, funzionalità avanzate (come ORM, routing flessibile, motore di template integrato, supporto caching, ecc.) e una community vivace e attiva.

Caratteristiche e Vantaggi Principali di ThinkPHP

• Pulito ed Efficiente: Design del framework semplice, struttura del codice chiara e facile da mantenere, alta velocità di sviluppo.
• Funzionalità Complete: Moduli integrati per sviluppo web come struttura MVC, ORM, motore di template, cache, gestione sessioni, autenticazione, token form e altro.
• ORM Potente: Sistema di mappatura relazionale intuitivo che semplifica le interazioni con il database.
• Routing Flessibile: Supporto a svariati stili di definizione delle rotte, ideale per gestire URL complessi.
• Ecosistema Ricco: Estensibilità tramite numerose librerie e plugin, e ampia community di sviluppatori.
• Aggiornato Costantemente: Rilasci frequenti che seguono le evoluzioni di PHP e del web.

Idealmente, ThinkPHP si adatta a progetti di qualsiasi dimensione, dai piccoli siti alle applicazioni enterprise complesse.

Preparare un Progetto ThinkPHP 8 con ServBay

ServBay offre un ambiente ideale per lo sviluppo locale di ThinkPHP 8, includendo:

• Versioni PHP multiple pre-installate con estensioni comuni.
• Server web integrati (Caddy o Nginx) per una configurazione rapida.
• Supporto integrato per database come MySQL, PostgreSQL, MongoDB, Redis, Memcached.
• Composer incluso per la gestione delle dipendenze.

Questa guida ti mostrerà come usare ServBay per avviare il tuo progetto ThinkPHP 8 in pochi minuti.

Prerequisiti

Verifica di aver completato i seguenti passaggi prima di procedere:

1. Scarica e installa ServBay su macOS o Windows (Istruzioni dettagliate).
2. Avvia ServBay e avvia la versione PHP richiesta (ThinkPHP 8 richiede almeno PHP 8.0) e i servizi database necessari (MySQL, PostgreSQL, Redis, Memcached, ecc.) dal pannello “Pacchetti” di ServBay.

Creare un Progetto ThinkPHP

ServBay consiglia di organizzare i siti locali nella cartella /Applications/ServBay/www, favorendo così una gestione ottimale.

1. Verifica che Composer sia installato

   ServBay include già Composer preinstallato, quindi non servono altri passaggi. Puoi confermare l'installazione tramite terminale ServBay con il comando composer --version.

2. Crea il Progetto ThinkPHP con Composer

   Apri il terminale su macOS ed esegui:

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

   Verrà creata la cartella servbay-thinkphp-app in /Applications/ServBay/www, e scaricati i file principali di ThinkPHP 8 e le sue dipendenze.

3. Accedi alla cartella del progetto

   Al termine della creazione, entra nella directory:

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

Configurazione Iniziale del Progetto

Dopo aver creato il progetto, esegui le configurazioni di base.

1. Configura le credenziali del database

   La configurazione del database ThinkPHP si trova tipicamente in config/database.php. Personalizza questo file in base al servizio database avviato su ServBay.

   Ecco un esempio per MySQL, usando i parametri di default di ServBay:

   <?php
   // config/database.php
   
   return [
       // Configurazione di default della connessione al database
       'default'         => env('database.driver', 'mysql'),
   
       // Configurazioni delle varie connessioni database
       'connections'     => [
           'mysql' => [
               // Tipo di database
               'type'     => 'mysql',
               // Indirizzo server
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nome database
               'database' => env('database.database', 'servbay_thinkphp_app'), // Crea un database separato per ogni 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 connessioni database ...
       ],
   ];

   Nota Importante:

   • Cambia il valore di database usando il nome del database realmente creato (ad es. con phpMyAdmin o Adminer di ServBay crea servbay_thinkphp_app).
   • La password utente root di ServBay è password. Usala solo per lo sviluppo locale! Per l'ambiente di produzione utilizza password robuste e utenti con permessi minimi necessari.
   • Se gestisci le variabili di ambiente con .env, assicurati che sovrascrivano i valori di default in config/database.php.

Configurazione del server web

Il file di ingresso di ThinkPHP è public/index.php e necessita di regole URL rewrite per il routing. Siccome il routing ThinkPHP differisce da quello dei file statici, dovrai applicare le regole di rewrite preimpostate di ServBay.

Nel menu delle regole di rewrite nella configurazione del sito, scegli ThinkPHP e salva.

Per dettagli sulla configurazione del sito ServBay, consulta Aggiungi il primo sito.

Aggiunta di codice di esempio

Per verificare la configurazione e il routing di ThinkPHP, aggiungi una semplice rotta e controller.

Modifica il file /Applications/ServBay/www/servbay-thinkphp-app/route/app.php aggiungendo una rotta GET:

<?php
// route/app.php

use think\facade\Route;

// Definisci la rotta servbay: su /servbay esegue una funzione anonima
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... Altre rotte ...

Accedi al sito web

Ora, dal browser, apri il dominio locale e la rotta di esempio:

https://thinkphp.servbay.demo/servbay

Se la configurazione è corretta, visualizzerai Hello ServBay!. Questo significa che il progetto ThinkPHP 8 è correttamente funzionante in ambiente ServBay, con server web e PHP-FPM configurati.

Esempio di database NoSQL

ServBay include diversi database NoSQL, come Memcached e Redis. ThinkPHP fornisce un livello di cache astratto per integrare facilmente questi servizi come driver di caching.

Esempio Memcached

1. Installa l'estensione Memcached

   L'estensione PHP per Memcached è già installata in ServBay. Assicurati dal pannello “Pacchetti” che il servizio Memcached sia attivo.

2. Configura Memcached come cache

   Modifica config/cache.php per usare Memcached:

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

3. Usa Memcached nel codice

   Nei controller o nelle rotte ThinkPHP:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/memcached-example', function () {
       // Imposta una cache con durata di 600 secondi
       Cache::set('my_memcached_key', 'Questo valore proviene da Memcached!', 600);
   
       // Recupera valore dalla cache
       $value = Cache::get('my_memcached_key');
   
       return 'Value from Memcached: ' . $value;
   });

   Accedi a https://thinkphp.servbay.demo/memcached-example per la prova.

Esempio Redis

1. Installa l'estensione Redis

   Anche Redis è già installato in ServBay. Attiva il servizio Redis dal pannello “Pacchetti”.

2. Configura Redis come cache

   Modifica config/cache.php per usare Redis:

   <?php
   // config/cache.php
   
   return [
       // Driver di cache predefinito
       'default' => env('cache.driver', 'redis'),
   
       // Configurazioni delle connessioni di cache
       'stores'  => [
           'redis' => [
               // Tipo di cache
               'type'       => 'redis',
               // Indirizzo server
               'host'       => env('cache.host', '127.0.0.1'), // Indirizzo Redis di default ServBay
               // Porta
               'port'       => env('cache.port', 6379), // Porta Redis di default ServBay
               // Password (di default nessuna su ServBay)
               'password'   => env('cache.password', ''), // Lascia vuoto se non hai impostato password
               'select'     => 0,
               'timeout'    => 0,
               'expire'     => 0,
               'persistent' => false,
               'prefix'     => '',
           ],
           // ... Altre configurazioni cache ...
       ],
   ];

   Attenzione: ServBay non imposta password di default su Redis. Se l'hai configurata manualmente, aggiorna il campo password di conseguenza.

3. Usa Redis nel codice

   Nei controller o nelle rotte ThinkPHP:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/redis-example', function () {
       // Scrivi cache permanente (o con scadenza tramite terzo parametro)
       Cache::set('my_redis_key', 'Ciao da Redis!');
   
       // Recupera valore dalla cache
       $value = Cache::get('my_redis_key');
   
       return 'Value from Redis: ' . $value;
   });

   Accedi a https://thinkphp.servbay.demo/redis-example per la prova.

Esempi con database relazionale

ServBay integra database relazionali come MySQL e PostgreSQL. L’ORM di ThinkPHP consente interazioni semplici e veloci.

Utilizzo dello strumento di migrazione ThinkPHP

Per gestire le modifiche strutturali del database, ThinkPHP offre un sistema di migrazione utile per il lavoro in team e il versionamento.

1. Installa la libreria di migrazione

   Dal terminale del progetto installa l'estensione:

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

2. Genera un file di migrazione

   Con il tool CLI ThinkPHP genera una migrazione, ad esempio per la tabella users:

   php think migrate:create CreateUserTable

   Troverai un nuovo file PHP in database/migrations (ad esempio 20231027100000_create_user_table.php).

3. Personalizza il file di migrazione

   Modifica il metodo up() per definire la struttura della tabella utenti:

   <?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.
        *
        * Tutti i comandi saranno gestiti anche per il rollback:
        *
        * createTable, renameTable, addColumn, addCustomColumn, renameColumn, addIndex,
        * addForeignKey, createDatabase, renameDatabase, dropTable, dropColumn,
        * dropIndex, dropForeignKey
        */
       public function change()
       {
           // Crea la tabella utilizzando 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]) // Indicizza in modo unico l'email
                 ->addTimestamps() // Aggiungi campi created_at e updated_at
                 ->create(); // Esegui la creazione
       }
   
       // In alternativa a change(), puoi definire 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

   Dal terminale, sempre nella cartella del progetto, crea la tabella:

   php think migrate:run

   Se l’operazione ha successo, troverai la tabella users sul database.

Esempio MySQL

Dopo aver avviato il servizio MySQL su ServBay e configurato la connessione (config/database.php), puoi interagire tramite codice.

1. Configura la connessione MySQL

   Consulta la sezione “Configurazione Iniziale del Progetto” che copre la configurazione di MySQL.

2. Scrivi dati utenti con il codice

   Usa il Facade Db di ThinkPHP per l'inserimento:

   <?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' => 'demo@servbay.demo', // Esempio email
               'created_at' => date('Y-m-d H:i:s'), // Timestamp
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'User added successfully!';
       } catch (\Exception $e) {
           return 'Error adding user: ' . $e->getMessage();
       }
   });

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

3. Leggi dati utenti dal database

   Usa Db o il modello ORM per la selezione:

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

   Accedi a https://thinkphp.servbay.demo/mysql-users per visualizzare gli utenti.

Esempio PostgreSQL

Avvia PostgreSQL su ServBay e configura la corrispondente connessione in config/database.php.

1. Configura la connessione PostgreSQL

   Nel file di configurazione, verifica la sezione relativa a PostgreSQL:

   <?php
   // config/database.php (estratto)
   
   return [
       // ... Altro ...
   
       'connections'     => [
           // ... Configurazione MySQL ...
   
           'pgsql' => [
               // Tipo database
               'type'     => 'pgsql',
               // Indirizzo server
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nome database
               'database' => env('database.database', 'servbay_thinkphp_app'), // Consigliato database separato
               // 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 PostgreSQL
               // ... Altre configurazioni ...
           ],
           // ... Altro ...
       ],
   ];

   Nota Importante:

   • Come per MySQL, crea un database dedicato per il progetto e aggiorna la configurazione.
   • La password utente root PostgreSQL su ServBay è ancora password, solo per sviluppo locale.

2. Scrivi dati utenti con il codice

   Usa Db indicando la connessione 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' => 'pgsql-demo@servbay.demo', // Esempio email
               'created_at' => date('Y-m-d H:i:s'), // Eventuale timestamp
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'PostgreSQL User added successfully!';
       } catch (\Exception $e) {
            return 'Error adding PostgreSQL user: ' . $e->getMessage();
       }
   });

   Accedi a https://thinkphp.servbay.demo/pgsql-add-user per la prova.

3. Leggi dati utenti dal database

   Consulta gli utenti tramite la connessione pgsql:

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

   Accedi a https://thinkphp.servbay.demo/pgsql-users per vedere i dati users da PostgreSQL.

Conclusione

Con questi passaggi hai creato, configurato e avviato con successo un progetto ThinkPHP 8 usando ServBay come ambiente locale. Hai imparato a creare il progetto con Composer, configurare il server web Caddy per gestire le rotte di ThinkPHP e a collegare i database MySQL, PostgreSQL, Memcached e Redis integrati in ServBay.

ServBay semplifica lo sviluppo locale di framework PHP come ThinkPHP, aiutandoti a concentrarti direttamente sulla logica applicativa. Ora puoi andare avanti con lo sviluppo del tuo sito ThinkPHP, beneficiando dell’ampio ventaglio di strumenti e servizi fornito da ServBay.