Creare ed eseguire un progetto CodeIgniter

Cos’è CodeIgniter?

CodeIgniter è un framework PHP per lo sviluppo di applicazioni web leggero e ad alte prestazioni. Segue il pattern Model-View-Controller (MVC) e mira ad aiutare gli sviluppatori a costruire rapidamente applicazioni web ricche di funzionalità. Grazie alla sua struttura semplice, le elevate prestazioni e la facilità di apprendimento, CodeIgniter è diventato uno dei framework preferiti da molti sviluppatori PHP.

Caratteristiche principali e vantaggi di CodeIgniter

• Core leggero: Il sistema centrale di CodeIgniter è estremamente snello, contiene solo i componenti essenziali, e garantisce un caricamento rapidissimo.
• Prestazioni eccellenti: Il framework è progettato per l’efficienza, gestisce richieste ad alta concorrenza offrendo prestazioni applicative ottimali.
• Facile da apprendere: Offre documentazione chiara e API intuitive, abbassando la curva di apprendimento e permettendo agli sviluppatori di acquisire competenze velocemente.
• Grande flessibilità: Consente agli sviluppatori di scegliere e integrare liberamente librerie di terze parti secondo le necessità, facilitando l’espansione e la personalizzazione delle funzionalità.
• Supporto da una community attiva: Vanta una comunità ampia e dinamica che offre un ricco supporto di risorse e assistenza.

CodeIgniter si adatta a qualsiasi esigenza di sviluppo, dai piccoli progetti fino ad applicazioni enterprise, aiutando gli sviluppatori a creare soluzioni web di alta qualità in modo efficiente.

Creare un ambiente di sviluppo CodeIgniter con ServBay

ServBay è uno strumento progettato per macOS che permette di configurare facilmente un ambiente di sviluppo web locale. Integra PHP, database (MySQL, PostgreSQL, MongoDB), cache (Redis, Memcached), server web (Caddy, Nginx, Apache) e altre componenti, offrendo una comoda interfaccia di gestione. Con ServBay, puoi configurare e gestire facilmente tutto ciò che serve per lavorare con CodeIgniter.

In questa guida ti mostreremo come usare l’ambiente PHP e la funzione Siti web di ServBay per creare, configurare ed eseguire un progetto CodeIgniter, illustrando anche come integrare diversi servizi di database e cache.

Prerequisiti

Prima di iniziare, assicurati di aver completato le seguenti operazioni:

• ServBay è stato installato e avviato correttamente su macOS.
• La versione PHP che intendi usare (ad esempio PHP 8.3) è stata abilitata in ServBay.
• I pacchetti di database e cache che desideri utilizzare (come MySQL, PostgreSQL, Redis, Memcached) sono stati attivati in ServBay.

Creare un progetto CodeIgniter

ServBay consiglia di organizzare tutti i progetti web nella directory /Applications/ServBay/www, così da facilitarne la gestione.

1. Installare Composer

   ServBay include già Composer preinstallato, quindi non è necessario installarlo manualmente. Puoi utilizzarlo direttamente dal terminale con il comando composer.

2. Accedere alla cartella principale dei siti

   Apri il terminale e vai nella cartella principale consigliata:

   cd /Applications/ServBay/www

3. Creare il progetto CodeIgniter

   Usa Composer per creare un nuovo progetto CodeIgniter 4. Chiamiamo la cartella del progetto servbay-codeigniter-app:

   composer create-project codeigniter4/appstarter servbay-codeigniter-app

   Composer scaricherà l’applicazione base di CodeIgniter e tutte le dipendenze nella cartella servbay-codeigniter-app.

4. Accedere alla directory del progetto

   Vai nella nuova directory creata per il progetto:

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

Configurazione iniziale

Configurare la connessione al database

La configurazione del database di CodeIgniter si trova nel file app/Config/Database.php. Prima di utilizzare un database, devi impostare qui le informazioni per la connessione.

Per cominciare, assicurati di aver già creato un database denominato servbay_codeigniter_app usando uno degli strumenti di gestione database inclusi in ServBay (come Adminer o phpMyAdmin, accessibili dall’interfaccia di ServBay).

Poi, modifica il file app/Config/Database.php, individua l’array $default e compila le informazioni in base al tipo di database attivato (ad esempio MySQL o PostgreSQL). Le credenziali predefinite in ServBay sono di solito root per l’utente e password per la password.

Esempio di configurazione per MySQL:

public $default = [
    'DSN'      => '',
    'hostname' => '127.0.0.1', // Il database ServBay ascolta di solito su 127.0.0.1
    'username' => 'root',     // Nome utente predefinito ServBay
    'password' => 'password', // Password predefinita ServBay
    'database' => 'servbay_codeigniter_app', // Nome del database creato
    'DBDriver' => 'MySQLi',   // Imposta secondo il tipo di DB: MySQL usa MySQLi o Pdo
    'DBPrefix' => '',
    'pConnect' => false,
    'DBDebug'  => (ENVIRONMENT !== 'production'),
    'charset'  => 'utf8mb4',
    'DBCollat' => 'utf8mb4_general_ci',
    'swapPre'  => '',
    'encrypt'  => false,
    'compress' => false,
    'strictOn' => false,
    'failover' => [],
    'port'     => 3306,       // Porta predefinita MySQL
];

Se invece usi PostgreSQL, imposta DBDriver su 'Postgre', la porta sarà solitamente 5432 e potrebbe essere necessario regolare le impostazioni del charset.

Configurare la cache (Memcached/Redis)

Se prevedi di utilizzare Memcached o Redis come cache, dovrai configurare il file app/Config/Cache.php.

Apri app/Config/Cache.php e trova la sezione di riferimento. Memcached su ServBay ascolta sulla porta 11211, Redis sulla 6379, in genere senza password.

Esempio di configurazione per Memcached:

public $memcached = [
    'host'   => '127.0.0.1', // Memcached di ServBay di solito ascolta su 127.0.0.1
    'port'   => 11211,      // Porta predefinita Memcached
    'weight' => 1,
];

Esempio di configurazione per Redis:

public string $handler = 'redis'; // Imposta Redis come gestore di cache predefinito

public $default = [ // Le impostazioni di Redis sono nell’array default
    'host'     => '127.0.0.1', // Redis di ServBay ascolta su 127.0.0.1
    'password' => null,       // Redis di ServBay senza password di default
    'port'     => 6379,       // Porta predefinita Redis
    'timeout'  => 0,
    'database' => 0,
];

Assicurati di configurare la sezione relativa secondo il pacchetto cache che hai abilitato.

Configurare il server web (Impostazioni siti in ServBay)

Attraverso la funzione Siti web di ServBay puoi configurare il server Web in modo che punti direttamente alla tua applicazione CodeIgniter.

1. Apri l’interfaccia di ServBay.
2. Vai alla scheda Siti web (Websites).
3. Clicca sul pulsante + in basso a sinistra per aggiungere un nuovo sito.
4. Compila le informazioni richieste:
   • Nome (Name): Immetti un nome facilmente riconoscibile, ad esempio My First CodeIgniter Dev Site.
   • Dominio (Domain): Indica il dominio locale desiderato, ad esempio servbay-codeigniter-test.local (ServBay risolve automaticamente i .local sul tuo computer).
   • Tipo di sito (Site Type): Seleziona PHP.
   • Versione PHP (PHP Version): Scegli la release PHP desiderata, ad esempio 8.3.
   • Root del sito (Document Root): Passaggio cruciale. Il file di avvio di CodeIgniter (index.php) si trova nella cartella public all’interno della directory di progetto. Quindi, imposta la root del sito sulla cartella public del progetto: /Applications/ServBay/www/servbay-codeigniter-app/public.
5. Clicca su Aggiungi (Add) per salvare.
6. ServBay potrebbe chiederti di applicare le modifiche: conferma.

Per tutti i dettagli vedi Aggiungere il primo sito.

Aggiungere codice di esempio

Per verificare che il progetto funzioni e testare la connessione a database e cache, modifichiamo il controller predefinito Home aggiungendo alcuni metodi di esempio.

Modifica il file app/Controllers/Home.php e sostituisci il contenuto con il seguente codice:

<?php

namespace App\Controllers;

use CodeIgniter\Controller;
use CodeIgniter\Database\Exceptions\DatabaseException; // Importa l’eccezione del database
use CodeIgniter\Cache\Exceptions\CacheException; // Importa l’eccezione della cache

class Home extends Controller
{
    /**
     * Metodo predefinito della home
     */
    public function index(): string
    {
        // Restituisce una semplice informazione di benvenuto
        return '<h1>Hello ServBay and CodeIgniter!</h1><p>Your CodeIgniter project is running on ServBay.</p>';
    }

    /**
     * Metodo di esempio per Memcached
     */
    public function memcached(): string
    {
        try {
            $cache = \Config\Services::cache();

            // Prova a scrivere in cache
            $success = $cache->save('servbay_memcached_key', 'Hello Memcached from CodeIgniter!', 60); // Cache di 60 secondi

            if (!$success) {
                 return 'Error: Failed to save data to Memcached. Check Memcached service and configuration.';
            }

            // Prova a leggere dalla cache
            $value = $cache->get('servbay_memcached_key');

            if ($value === null) {
                return 'Error: Failed to get data from Memcached. Cache might have expired or service is down.';
            }

            return 'Memcached Test Success: ' . $value;

        } catch (CacheException $e) {
            // Cattura le eccezioni relative alla cache
            return 'Cache Error: ' . $e->getMessage() . '. Ensure Memcached service is running and configured correctly.';
        } catch (\Exception $e) {
            // Cattura tutte le altre possibili eccezioni
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }

    /**
     * Metodo di esempio per Redis
     */
    public function redis(): string
    {
        try {
            $cache = \Config\Services::cache();

            // Prova a scrivere in cache
            $success = $cache->save('servbay_redis_key', 'Hello Redis from CodeIgniter!', 60); // Cache di 60 secondi

             if (!$success) {
                 return 'Error: Failed to save data to Redis. Check Redis service and configuration.';
            }

            // Prova a leggere dalla cache
            $value = $cache->get('servbay_redis_key');

             if ($value === null) {
                return 'Error: Failed to get data from Redis. Cache might have expired or service is down.';
            }

            return 'Redis Test Success: ' . $value;

        } catch (CacheException $e) {
             // Cattura le eccezioni relative alla cache
            return 'Cache Error: ' . $e->getMessage() . '. Ensure Redis service is running and configured correctly.';
        } catch (\Exception $e) {
            // Cattura tutte le altre possibili eccezioni
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }

    /**
     * Inserisce dati utente nel database (MySQL/PostgreSQL)
     */
    public function addUser(): string
    {
        try {
            $db = \Config\Database::connect();

            // Verifica se la tabella 'users' esiste (prevenzione di base)
            if (!$db->tableExists('users')) {
                 return 'Error: "users" table does not exist. Please run database migrations first.';
            }

            // Inserisci un record
            $data = [
                'name' => 'ServBay Demo User',
                'email' => 'user_' . time() . '@servbay.demo', // Usa time() per email univoca
            ];

            $db->table('users')->insert($data);

            // Verifica l’inserimento (opzionale, insert() restituisce di solito true)
            // if ($db->affectedRows() > 0) {
                 return 'User added successfully: ' . $data['email'];
            // } else {
            //      return 'Error: Failed to add user.';
            // }

        } catch (DatabaseException $e) {
            // Cattura le eccezioni relative al database
            return 'Database Error: ' . $e->getMessage() . '. Check database connection and table structure.';
        } catch (\Exception $e) {
             // Cattura altre possibili eccezioni
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }

    /**
     * Legge dati utente dal database (MySQL/PostgreSQL)
     */
    public function listUsers(): string
    {
         try {
            $db = \Config\Database::connect();

             // Verifica se la tabella 'users' esiste
            if (!$db->tableExists('users')) {
                 return 'Error: "users" table does not exist. Please run database migrations first.';
            }

            // Recupera tutti gli utenti
            $users = $db->table('users')->get()->getResult();

            if (empty($users)) {
                return 'No users found in the database.';
            }

            // Restituisce lista utenti in formato JSON
            return json_encode($users);

        } catch (DatabaseException $e) {
             // Cattura le eccezioni relative al database
            return 'Database Error: ' . $e->getMessage() . '. Check database connection and table structure.';
        } catch (\Exception $e) {
            // Cattura altre possibili eccezioni
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }
}

Questo controller aggiornato fornisce output più chiari e una gestione di errori basilare per aiutare nella diagnosi dei problemi.

Configurazione delle rotte

Per poter accedere facilmente ai metodi d’esempio appena aggiunti nel controller Home, bisogna aggiungere le corrispondenti rotte nel file di configurazione di CodeIgniter.

Modifica il file app/Config/Routes.php. Trova la definizione di $routes e aggiungi queste regole:

// ... altre regole di routing ...

// Rotta per esempio Memcached
$routes->get('/memcached', 'Home::memcached');

// Rotta per esempio Redis
$routes->get('/redis', 'Home::redis');

// Rotte per esempio database
$routes->get('/add-user', 'Home::addUser');
$routes->get('/list-users', 'Home::listUsers');

// ... altre regole di routing ...

Assicurati di aggiungerle senza sovrascrivere le regole già esistenti.

Visitare il sito

Ora il tuo progetto CodeIgniter è configurato e funzionante su ServBay. Apri il browser e accedi tramite il dominio impostato:

• Homepage: https://servbay-codeigniter-test.local Dovresti vedere la scritta Hello ServBay and CodeIgniter!, a conferma che il progetto funziona tramite il server web ServBay.

• Esempio Memcached: https://servbay-codeigniter-test.local/memcached Se Memcached è attivo e correttamente configurato, dovresti visualizzare un messaggio come Memcached Test Success: Hello Memcached from CodeIgniter!.

• Esempio Redis: https://servbay-codeigniter-test.local/redis Se Redis è attivo e correttamente configurato, il messaggio sarà simile a Redis Test Success: Hello Redis from CodeIgniter!.

Esempi di operazioni su database (MySQL/PostgreSQL)

Per utilizzare gli esempi relativi al database, devi prima avviare la migrazione per creare la tabella users.

Creare la struttura del database (eseguire la migrazione)

1. Apri il terminale e accedi alla directory del progetto CodeIgniter:

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

2. Crea il file di migrazione: Usa l’interfaccia CLI di CodeIgniter per generare una migrazione per la tabella users:

   php spark make:migration create_users_table

   Questo comando crea un nuovo file PHP nella cartella app/Database/Migrations.

3. Modifica la migrazione: Apri il file appena generato (il nome sarà simile a YYYY-MM-DD-HHMMSS_CreateUsersTable.php), edita il metodo up() per definire colonne e indici per la tabella users. Nota: ci sono leggere differenze tra MySQL e PostgreSQL nella sintassi dei valori predefiniti dei timestamp (CURRENT_TIMESTAMP rispetto a NOW()). RawSql di CodeIgniter aiuta a gestire queste differenze. Ecco un esempio:

   <?php
   
   namespace App\Database\Migrations;
   
   use CodeIgniter\Database\Migration;
   use CodeIgniter\Database\RawSql; // Assicurati di importare RawSql
   
   class CreateUsersTable extends Migration
   {
       public function up()
       {
           $this->forge->addField([
               'id'          => [
                   'type'           => 'INT',
                   'constraint'     => 5,
                   'unsigned'       => true,
                   'auto_increment' => true,
               ],
               'name'       => [
                   'type'       => 'VARCHAR',
                   'constraint' => '100',
               ],
               'email'      => [
                   'type'       => 'VARCHAR',
                   'constraint' => '100',
                   'unique'     => true, // Campo email impostato come univoco
               ],
               'created_at' => [
                   'type'    => 'TIMESTAMP',
                   // Usa l’espressione giusta in base al database
                   // MySQL: 'default' => new RawSql('CURRENT_TIMESTAMP'),
                   // PostgreSQL: 'default' => new RawSql('NOW()'),
                   'default' => new RawSql($this->db->getPlatform() === 'MySQLi' ? 'CURRENT_TIMESTAMP' : 'NOW()'), // Selezione dinamica
               ],
               'updated_at' => [
                   'type'    => 'TIMESTAMP',
                   // MySQL: 'default' => new RawSql('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'),
                   // PostgreSQL: 'default' => new RawSql('NOW()'),
                    'default' => new RawSql($this->db->getPlatform() === 'MySQLi' ? 'CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP' : 'NOW()'), // Selezione dinamica
               ],
           ]);
           $this->forge->addKey('id', true); // Imposta id come chiave primaria
           $this->forge->createTable('users'); // Crea la tabella users
       }
   
       public function down()
       {
           // Servirà per annullare la migrazione: elimina la tabella users
           $this->forge->dropTable('users');
       }
   }

   Nota: L’esempio sopra usa una logica semplice per selezionare dinamicamente la sintassi dei timestamp in base al database. In progetti reali potresti optare per migrazioni più robuste o mantenere file diversi per ciascun database.

4. Esegui la migrazione: Lancia questo comando nel terminale per creare la tabella:

   php spark migrate

   Se tutto va a buon fine, vedrai la conferma a terminale. Puoi controllare anche con Adminer o altri tool la presenza della tabella users nel database servbay_codeigniter_app.

Usare gli esempi sul database

Assicurati di aver configurato correttamente i dati di connessione nel file app/Config/Database.php e di aver eseguito la migrazione per creare la tabella users.

• Aggiungere un utente: Vai all’indirizzo https://servbay-codeigniter-test.local/add-user Ogni volta che accedi a questo URL, verrà inserito un nuovo utente nella tabella; dovrebbe apparire un messaggio tipo User added successfully: [email protected].

• Elencare gli utenti presenti nel database: Visita https://servbay-codeigniter-test.local/list-users Verranno mostrati tutti gli utenti sotto forma di array JSON.

Conclusioni

Seguendo questa guida, hai creato, configurato ed eseguito con successo un progetto CodeIgniter nell’ambiente ServBay su macOS. Hai imparato come creare il progetto con Composer, configurare l’ambiente web in ServBay puntando alla cartella corretta, impostare le connessioni a database e cache in CodeIgniter e verificare tutto tramite esempi pratici. ServBay semplifica la configurazione e gestione degli ambienti locali, consentendoti di concentrarti sullo sviluppo della tua applicazione CodeIgniter.