Creare e Avviare un Progetto PHPixie su macOS con ServBay

PHPixie è un framework PHP leggero e ad alte prestazioni, pensato per lo sviluppo rapido di applicazioni web. Adotta il pattern HMVC (Hierarchical Model-View-Controller), offrendo una struttura di codice pulita e una gestione efficiente. La semplicità, flessibilità e velocità di PHPixie lo rendono la scelta preferita da molti sviluppatori.

Caratteristiche e Vantaggi Principali di PHPixie

Leggerezza: Il nucleo di PHPixie è estremamente snello, include solo i componenti essenziali per costruire applicazioni, offrendo avvio e runtime rapidi.
Alte Prestazioni: Il design del framework è focalizzato sull'efficienza, riuscendo a gestire richieste concorrenti con ottime performance. Ideale per applicativi che richiedono rapidità.
Facile da Apprendere: Fornisce API chiare e una documentazione dettagliata, facilitando un apprendimento veloce per sviluppatori di ogni livello.
Flessibilità: La struttura è debolmente accoppiata, permettendo la scelta e l'integrazione di librerie e componenti di terze parti in base alle esigenze di progetto.
Community Attiva: Una comunità vivace offre numerose estensioni e risorse di supporto.

PHPixie aiuta gli sviluppatori a costruire web app di qualità, scalabili dalle piccole alle grandi realtà aziendali.

Creazione e Avvio di un Progetto PHPixie con ServBay

Questa guida ti spiega come sfruttare ServBay come ambiente locale per lo sviluppo di un progetto PHPixie. Utilizzeremo ServBay con PHP integrato, il gestore di dipendenze Composer e la funzionalità "Siti web" per configurare il server web e consentire un facile accesso e integrazione con i database/cache supportati.

Prerequisiti

ServBay installato e funzionante su macOS. Include PHP, Composer, vari database (MySQL, PostgreSQL, MongoDB, Redis, ecc.) e il server web Caddy.
Familiarità con i comandi base da terminale.

Creare un Progetto PHPixie

Percorso consigliato per siti web

ServBay consiglia di salvare i siti locali in /Applications/ServBay/www per una gestione centralizzata e il corretto controllo degli accessi.

Verifica di Composer: ServBay include Composer preinstallato, quindi non serve alcuna installazione aggiuntiva. Apri il terminale e digita composer --version per verificare la presenza.
Crea la cartella di progetto: Nel percorso indicato, crea una nuova directory per il progetto PHPixie e accedici:
bash
```
cd /Applications/ServBay/www
mkdir servbay-phpixie-app
cd servbay-phpixie-app
```
1
2
3
Crea il progetto PHPixie con Composer: Esegui nel terminale il comando per scaricare il template di progetto:
bash
```
composer create-project phpixie/project .
```
1
Composer scaricherà PHPixie e tutte le dipendenze nella cartella corrente.

Configurare il Server Web

Usa la funzione Siti web di ServBay per impostare Caddy come server web e collegare correttamente il progetto PHPixie.

Avvia l’applicazione ServBay.
Vai alla sezione Siti web (Websites).
Aggiungi un nuovo sito.
Compila i dettagli di configurazione:
- Nome: Es. My First PHPixie Dev Site (identificativo interno ServBay).
- Dominio: Es. servbay-phpixie-test.local (il dominio locale da usare nel browser).
- Tipo di sito: Seleziona PHP.
- Versione PHP: Scegli quella preferita, ad esempio 8.3.
- Root del sito (Document Root): Imposta la cartella web del progetto: /Applications/ServBay/www/servbay-phpixie-app/web.
Perché la cartella /web?
Il file di ingresso del progetto PHPixie è web/index.php, quindi, per sicurezza e best practice, il root del server deve puntare alla cartella web e non alla radice del progetto. Si evita l'accesso ai file di configurazione o alla directory vendor.
Salva la configurazione. ServBay aggiornerà automaticamente Caddy e il file hosts locale (se necessario), facendo puntare servbay-phpixie-test.local al server ServBay sul tuo computer.

Per istruzioni dettagliate, consulta Aggiungi il primo sito.

Aggiunta di Codice di Esempio

Vediamo come aggiungere codice per verificare il funzionamento del progetto e la corretta integrazione con database e cache.

Crea un controller di esempio: Inserisci il codice qui sotto in src/App/HTTP/Controller/Home.php. Crea la cartella/file se non esistono.

php

<?php

namespace App\HTTP\Controller;

use PHPixie\HTTP\Request;
use PHPixie\Template;
use PHPixie\Database\Query; // Importa la classe Query

class Home extends \PHPixie\Controller
{
    protected $template;

    public function __construct(Template $template)
    {
        $this->template = $template;
    }

    // Action predefinita per la homepage
    public function action_index(Request $request)
    {
        // Renderizza il template assets/templates/app/home.php
        return $this->template->render('app:home');
    }

    // Action di esempio per Memcached
    public function action_memcached(Request $request)
    {
        $cache = $this->components->cache();
        $cache->set('key', 'Hello Memcached from ServBay!', 60); // Salva dati per 60 secondi
        $value = $cache->get('key'); // Recupera dati
        return $this->response()->string($value); // Risposta come stringa
    }

    // Action di esempio per Redis
    public function action_redis(Request $request)
    {
        $redis = $this->components->redis();
        $redis->set('key', 'Hello Redis from ServBay!'); // Salva dati
        $value = $redis->get('key'); // Recupera dati
        return $this->response()->string($value); // Risposta come stringa
    }

    // Action per aggiunta utente su MySQL/PostgreSQL
    public function action_add_user(Request $request)
    {
        // Ottieni il query builder dal componente database
        $query = $this->components->database()->query();
        // Inserisci un nuovo utente nella tabella 'users'
        $query->insert('users')->data([
            'name' => 'ServBay Demo User',
            'email' => 'demo-' . uniqid() . '@servbay.test', // Usa un’email univoca
        ])->execute(); // Esegui l’inserimento

        return $this->response()->string('User added successfully.'); // Messaggio di successo
    }

    // Action per elencare utenti da MySQL/PostgreSQL
    public function action_list_users(Request $request)
    {
        // Ottieni il query builder dal componente database
        $query = $this->components->database()->query();
        // Recupera tutti gli utenti dalla tabella 'users'
        $users = $query->select('*')->from('users')->execute()->fetchAll(); // Esegui la query e ottieni i risultati

        return $this->response()->json($users); // Risposta JSON con la lista utenti
    }
}

Crea un template di esempio: Inserisci il seguente codice nel file assets/templates/app/home.php. Crea la cartella/file se non esistono.

php

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Benvenuto su PHPixie con ServBay</title>
    <style>
        body { font-family: sans-serif; line-height: 1.6; margin: 20px; }
        h1 { color: #333; }
        p { margin-bottom: 15px; }
        code { background-color: #f4f4f4; padding: 2px 5px; border-radius: 4px; }
        ul { list-style: none; padding: 0; }
        li { margin-bottom: 10px; }
        li a { text-decoration: none; color: #007bff; }
        li a:hover { text-decoration: underline; }
    </style>
</head>
<body>
    <h1>Benvenuto su PHPixie con ServBay</h1>
    <p>Questa pagina è generata dinamicamente dalla tua applicazione PHPixie in esecuzione su ServBay.</p>

    <h2>Link alle funzionalità di esempio:</h2>
    <ul>
        <li><a href="/home/memcached">Testa Memcached</a></li>
        <li><a href="/home/redis">Testa Redis</a></li>
        <li><a href="/home/add_user">Aggiungi un utente al database</a></li>
        <li><a href="/home/list_users">Elenca utenti nel database</a></li>
    </ul>

    <p>Assicurati di aver completato la configurazione di database e cache.</p>

</body>
</html>

Accesso al Sito di Base

Al termine della configurazione in ServBay e dell’aggiunta del codice di esempio, puoi ora visitare il dominio configurato nel browser:

Apri il browser e visita https://servbay-phpixie-test.local.
Dovresti vedere la pagina con il messaggio "Benvenuto su PHPixie con ServBay" e i link alle funzionalità di esempio.

Se non riesci ad accedere:

Controlla che ServBay sia avviato.
Verifica la correttezza della configurazione del sito in ServBay: dominio, tipo di sito, root directory.
Controlla che il file hosts locale risolva servbay-phpixie-test.local (ServBay solitamente lo gestisce in automatico).
Assicurati che la versione PHP scelta sia abilitata.

Integrazione con Database e Cache

PHPixie supporta nativamente diversi database e sistemi di caching. ServBay fornisce i pacchetti MySQL, PostgreSQL, Redis, Memcached, che puoi integrare facilmente nel tuo progetto.

Nota importante: Prima di eseguire operazioni su database, assicurati di aver avviato il servizio richiesto (es. MySQL o PostgreSQL) su ServBay e di aver creato il database del progetto. In questo esempio il database si chiama servbay_phpixie_app. Puoi usare gli strumenti ServBay (Sequel Ace, Postico, TablePlus, ecc.) o il client da terminale per crearlo. Solitamente l’utente di default è root e la password è password (verifica con la tua configurazione).

Configurare la Connessione al Database

Modifica assets/config/database.php nella root del progetto, in base al database scelto. L’indirizzo locale predefinito ServBay è 127.0.0.1.

Esempio configurazione MySQL (assets/config/database.php):

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // Modifica la stringa in base al tuo database e alle impostazioni ServBay
        'connection' => 'mysql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Utente predefinito ServBay
        'password'  => 'password', // Password predefinita (modifica secondo la tua configurazione)
        'options'   => []
    ]
];

Esempio configurazione PostgreSQL (assets/config/database.php):

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // Modifica la stringa in base al tuo database e alle impostazioni ServBay
        'connection' => 'pgsql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Utente predefinito ServBay
        'password'  => 'password', // Password predefinita (modifica secondo la tua configurazione)
        'options'   => []
    ]
];

Creare le Tabelle del Database (Migrazioni)

PHPixie offre strumenti CLI per gestire le migrazioni, ovvero il versioning della struttura del database.

Apri il terminale: Posizionati nella cartella principale del progetto:
bash
```
cd /Applications/ServBay/www/servbay-phpixie-app
```
1
Crea un file di migrazione: Usa CLI PHPixie per generare una nuova migrazione che crea la tabella users:
bash
```
php pixie generate:migration create_users_table
```
1
Verrà generato un file PHP in assets/migrations con un timestamp nel nome.

Modifica il file di migrazione: Apri il nuovo file nella cartella assets/migrations (es. YYYY_MM_DD_HHMMSS_create_users_table.php) e definisci i metodi up() e down() per la tabella users:

php

<?php

use PHPixie\Database\Migration;
use PHPixie\Database\Schema\Table;

class CreateUsersTable extends Migration
{
    public function up()
    {
        // Usa lo schema builder per creare la tabella 'users'
        $this->schema->create('users', function(Table $table) {
            $table->increments('id'); // Chiave primaria auto-incrementale
            $table->string('name'); // Colonna nome
            $table->string('email')->unique(); // Colonna email, unica
            $table->timestamps(); // Colonne created_at e updated_at
        });
    }

    public function down()
    {
        // Elimina la tabella 'users'
        $this->schema->drop('users');
    }
}

Esegui la migrazione: Dal terminale nella root del progetto, esegui:
bash
```
php pixie migrate
```
1
Se il comando ha successo, vedrai la conferma e la tabella users sarà presente nel database, verificabile tramite strumenti ServBay.

Utilizzo di Database Relazionali (MySQL/PostgreSQL)

Nel controller di esempio src/App/HTTP/Controller/Home.php trovi già i metodi action_add_user e action_list_users per gestire l’interazione con MySQL o PostgreSQL.

Aggiunta utente: Visita https://servbay-phpixie-test.local/home/add_user per inserire un utente nella tabella users.
Elenco utenti: Visita https://servbay-phpixie-test.local/home/list_users per vedere la lista di utenti in formato JSON.

Configurazione e Utilizzo di Database NoSQL (Memcached/Redis)

ServBay include Memcached e Redis con le corrispondenti estensioni PHP. Basta configurare PHPixie per utilizzarli.

Configurazione Memcached (assets/config/cache.php):

Modifica/crea assets/config/cache.php e inserisci:

php

<?php

return [
    'default' => [
        'driver' => 'memcached',
        'servers' => [
            [
                'host'   => '127.0.0.1', // Indirizzo Memcached ServBay
                'port'   => 11211, // Porta predefinita
                'weight' => 100,
            ],
        ],
    ],
];

Configurazione Redis (assets/config/redis.php):

Modifica/crea assets/config/redis.php e inserisci:

php

<?php

return [
    'default' => [
        'hostname' => '127.0.0.1', // Indirizzo Redis ServBay
        'port'     => 6379, // Porta predefinita
        'timeout'  => 0,
        'database' => 0, // Indice database Redis
    ],
];

Usare Memcached/Redis:

Nel controller di esempio src/App/HTTP/Controller/Home.php sono presenti i metodi action_memcached e action_redis per testare la componentistica cache PHPixie.

Test Memcached: Visita https://servbay-phpixie-test.local/home/memcached per scrivere e leggere una coppia chiave/valore in Memcached.
Test Redis: Visita https://servbay-phpixie-test.local/home/redis per verificare analoga funzionalità con Redis.

Ricorda di attivare i corrispondenti pacchetti software in ServBay.

Conclusioni

Seguendo questi passaggi hai creato, configurato e avviato con successo un progetto PHPixie nell’ambiente locale macOS usando ServBay. Hai imparato a generare progetti con Composer, configurare il server web tramite la funzione Siti web, integrare database e sistemi di caching e testare il corretto funzionamento.

ServBay semplifica fortemente la creazione di ambienti di sviluppo PHP, permettendoti di concentrarti sul codice e sulle tue idee. Speriamo che questa guida ti aiuti a iniziare velocemente con PHPixie e a costruire il tuo prossimo progetto web!

Creare e Avviare un Progetto PHPixie su macOS con ServBay ​

Caratteristiche e Vantaggi Principali di PHPixie ​

Creazione e Avvio di un Progetto PHPixie con ServBay ​

Prerequisiti ​

Creare un Progetto PHPixie ​

Configurare il Server Web ​

Aggiunta di Codice di Esempio ​

Accesso al Sito di Base ​

Integrazione con Database e Cache ​

Configurare la Connessione al Database ​

Creare le Tabelle del Database (Migrazioni) ​

Utilizzo di Database Relazionali (MySQL/PostgreSQL) ​

Configurazione e Utilizzo di Database NoSQL (Memcached/Redis) ​

Conclusioni ​