Vai al contenuto

Boson PHP – Mini-app completa, performance, confronto e best practices enterprise

Nel precedente articolo, abbiamo introdotto Boson PHP, una potente tecnologia che permette di creare applicativi eseguibili sfruttanto il linguaggio PHP. In questo capitolo finale entriamo nel cuore operativo di Boson PHP. Costruiremo una mini-app reale, analizzeremo le implicazioni sulle performance, confronteremo Boson con Electron, Tauri e Neutralino e chiuderemo con una guida di best practices pensata per contesti enterprise.

Mini-app completa: dashboard reattiva

L’obiettivo è creare una semplice applicazione desktop con:

  • un contatore reattivo
  • un pulsante di aggiornamento
  • logica completamente in PHP

HTML dell’applicazione

<dashboard-app></dashboard-app>

Il trattino non è una convenzione facoltativa, è un requisito tecnico obbligatorio dei Custom Elements (Web Components), e Boson segue rigorosamente lo standard. I Web Components si basano sullo standard ufficiale HTML Custom Elements (W3C / WHATWG). Il trattino serve a:

  1. Evitare collisioni future, perchè lo standard HTML potrebbe introdurre domani <dashboard>, mentre <dashboard-app> non entrerà mai in conflitto
  2. Permettere al browser di distinguere elementi nativi (<div>, <button>) da elementi personalizzati
  3. Garantire il parsing corretto del DOM

Il browser rifiuta la registrazione di un custom element senza trattino.

Bootstrap PHP

use Boson\Application;

$app = new Application();

$app->webview->components->add(
    'dashboard-app',
    App\Componenti\Dashboard::class
);

$app->webview->html = '<dashboard-app></dashboard-app>';
$app->run();

Componente Dashboard

use Boson\WebView\Api\WebComponents\ReactiveContext;

class Dashboard implements HasMethodsInterface
{
    private int $contatore = 0;

    public function __construct(private ReactiveContext $ctx)
    {
        $this->render();
    }

    private function render(): void
    {
        $this->ctx->content->html = "
            <h2>Dashboard</h2>
            <p>Valore: {$this->contatore}</p>
            <button onclick='this.incrementa()'>Incrementa</button>
        ";
    }

    public function incrementa(): void
    {
        $this->contatore++;
        $this->render();
    }

    public function onMethodCalled(string $metodo, array $argomenti = []): mixed
    {
        if ($metodo === 'incrementa') {
            $this->incrementa();
        }
        return null;
    }

    public static function getMethodNames(): array
    {
        return ['incrementa'];
    }
}

Questa mini-app dimostra chiaramente che:

  • non serve JavaScript applicativo
  • lo stato vive in PHP
  • il DOM viene aggiornato in modo diretto

Deployment

Boson NON funziona come un’app web. Nel deployment PHP viene incluso nell’app<, il codice viene impacchettato e la WebView è quella nativa del sistema. Infinenon esiste runtime esterno richiesto. Il risultato è simile a un’app nativa tradizionale.

Struttura consigliata del progetto prima del deployment

/app
  /Componenti
  /Servizi
/public
  index.html
  style.css
/main.php
/composer.json

Regola fondamentale: nessun path assoluto. Usa sempre percorsi relativi.

Step 1 – Preparazione dell’applicazione

Il file main.php deve essere l’unico punto di avvio:

use Boson\Application;

$app = new Application();

$app->webview->html = file_get_contents(__DIR__ . '/public/index.html');

$app->run();

Prima del deployment, togli o commenta tutte le righe che facciano riferimento a operazioni di debug:

  • var_dump, echo, print_r
  • log verbosi
  • gestisci le eccezioni

Step 2 – Gestione delle dipendenze

Installa tutte le dipendenze con Composer:

composer install --no-dev --optimize-autoloader

Questo riduce la dimensione finale e migliora le performance.

Step 3 – Build dell’eseguibile

Boson fornisce strumenti per il packaging dell’applicazione.

Concetto di build

  • PHP viene incluso
  • il codice viene compilato/impacchettato
  • le risorse statiche vengono inglobate (motivo per cui non è permesso caricare file esterni via HTTP, ma inglobare sempre tutte le risorse).
boson build

Questo comando genera una directory di output contenente l’eseguibile.

Step 4 – Output del build

Dopo il build, avrai una struttura simile:

/dist
  myapp.exe        (Windows)
  myapp            (Linux)
  myapp.app        (macOS)

Ogni file è un’applicazione completa e autonoma.

Deployment su Windows

Il file generato è un .exe standard eseguibile, quindi non è richiesta nessuna installazione. E’ altresi possibile creare un installer come ad esempio  (NSIS, Inno Setup).

Deployment su Linux

In questo caso, l’eseguibile è un ELF (Executable and Linkable Format), un formato standard per file binari usato su Linux e altri sistemi operativi Unix-like. E’ richiesta la disponibilità nel sistema della WebView e devono essere impostati i permessi di esecuzione, tramite il comando

chmod +x myapp

Deployment su macOS

Il formato è .app. E’ richiesta la notarizzazione Apple e la firma obbligatoria per distribuzione pubblica

Errori comuni da evitare

  • Usare path assoluti
  • Dipendere da PHP esterno
  • Caricare risorse remote
  • Bloccare il thread UI

Performance: come evitare problemi

Boson è estremamente veloce, ma va usato correttamente.

Errori comuni

  • Aggiornare l’intero HTML ad ogni evento
  • Eseguire query lente in risposta a eventi UI
  • Bloccare il thread principale con loop pesanti

Buone pratiche di performance

  • Usa aggiornamenti incrementali del DOM
  • Cache dei dati in memoria
  • Servizi separati per logica pesante

Esempio di caching

class CacheDati
{
    private array $cache = [];

    public function get(string $chiave, callable $loader)
    {
        if (!isset($this->cache[$chiave])) {
            $this->cache[$chiave] = $loader();
        }
        return $this->cache[$chiave];
    }
}

Confronto tecnico: Boson vs Electron vs Tauri vs Neutralino

Caratteristica Boson Electron Tauri Neutralino
Linguaggio backend PHP Node.js Rust Vari
Processi Singolo Multipli Minimali Minimali
Bridge JS Nativo IPC IPC IPC
Dimensione app Molto ridotta Molto grande Ridotta Ridotta
Curva di apprendimento Bassa (per PHP dev) Media Alta Media

Boson non è un clone di Electron: è un paradigma diverso, più vicino a un runtime applicativo che a un browser incapsulato.

Best practices enterprise

1. Separazione delle responsabilità

  • Componenti = UI + bridge
  • Servizi = logica
  • Repository = dati

2. Dependency Injection

class ReportComponent
{
    public function __construct(
        private GeneratoreReport $report
    ) {}
}

3. Stato centralizzato

class StatoGlobale
{
    private array $stato = [];

    public function set(string $k, mixed $v): void
    {
        $this->stato[$k] = $v;
    }

    public function get(string $k): mixed
    {
        return $this->stato[$k] ?? null;
    }
}

4. Sicurezza

  • Esporre solo i metodi necessari
  • Validare sempre gli input JS
  • Non fidarsi del DOM

5. Scalabilità del progetto

  • Namespace chiari
  • Registrazione automatica dei componenti
  • Test della logica fuori dalla UI

Quando Boson è la scelta giusta

  • Tool aziendali interni
  • Client desktop per API
  • Dashboard locali
  • Applicazioni multipiattaforma leggere

Conclusione finale

Boson PHP introduce un modello di sviluppo radicalmente nuovo per il mondo PHP. Non simula il web: lo supera. La comunicazione diretta tra PHP e DOM, l’assenza di rete e la semplicità architetturale lo rendono una scelta eccellente per applicazioni desktop moderne, robuste e manutenibili. Se usato correttamente, Boson non è solo un framework: è un runtime applicativo.

Post collegati:

Tag: