---
title: "Refactoring del codice PHP legacy: guida pratica per modernizzare un'applicazione senza riscriverla"
description: "Refactoring PHP legacy incrementale: Strangler Fig Pattern, Dependency Injection, PHPStan, Rector e characterization test. Caso reale di gestionale PMI modernizzato in 3 mesi."
canonical: "https://www.mauriziofonte.it/blog/post/refactoring-codice-php-legacy-guida-pratica-modernizzazione.html"
author: "Maurizio Fonte"
date: "2025-09-05T08:14:33+02:00"
modified: "2026-04-14T17:48:55+02:00"
section: "Refactoring"
tags: ["Refactoring", "Testing"]
license: "Riuso e citazione consentiti con attribuzione e link alla fonte"
---

[Refactoring](https://www.mauriziofonte.it/blog/cat/refactoring.html) [Testing](https://www.mauriziofonte.it/blog/cat/testing.html)

# [Refactoring del codice PHP legacy: guida pratica per modernizzare un'applicazione senza riscriverla](https://www.mauriziofonte.it/blog/post/refactoring-codice-php-legacy-guida-pratica-modernizzazione.html)

Venerdì 5 Settembre 2025, alle 08:14 ![Refactoring del codice PHP legacy: guida pratica per modernizzare un'applicazione senza riscriverla](https://www.mauriziofonte.it/image/002250200-refactoring-codice-php-legacy-guida-pratica-modernizzazione.jpg)

Il refactoring più costoso della mia carriera non è stato il più complesso tecnicamente - è stato quello su un gestionale PHP 5.6 di una PMI emiliana che gestiva ordini, magazzino e contabilità per un'azienda di 25 dipendenti. Il gestionale funzionava, il business dipendeva da quello, e ogni nuova funzionalità richiesta dal titolare - una dashboard, un report, un'integrazione con il corriere - costava tre volte quello che avrebbe dovuto costare, perché lo sviluppatore che la implementava passava il 70% del tempo a capire il codice esistente e il 30% a scrivere la modifica, pregando di non rompere qualcos'altro. Il debito tecnico aveva raggiunto il punto in cui il costo di manutenzione superava il costo di sviluppo.

Il titolare aveva chiesto un preventivo per riscrivere tutto da zero in Laravel. Due agenzie avevano quotato tra 80.000 e 120.000 euro, con tempi di 8-12 mesi durante i quali avrebbe dovuto mantenere operativi entrambi i sistemi. La mia proposta era diversa: refactoring incrementale. Non riscrivere, ma modernizzare pezzo per pezzo, senza mai fermare la produzione. Costo: un terzo del rewrite completo. Tempo: tre mesi per raggiungere un livello di manutenibilità dove ogni nuova funzionalità costa quello che dovrebbe costare. In questo articolo ti racconto come.

> Stai cercando un **Consulente Informatico** esperto per modernizzare il tuo applicativo PHP legacy? Nel mio [profilo professionale](https://www.mauriziofonte.it/pages/about) trovi l'esperienza concreta su refactoring incrementale, Strangler Fig Pattern e migrazione da PHP 5.x a 8.x. [Contattami per una consulenza diretta](https://www.mauriziofonte.it/pages/contattami).

## Perché il "big rewrite" fallisce e il refactoring incrementale funziona?

Joel Spolsky lo scrisse nel 2000 e resta vero nel 2025: la riscrittura completa è [la cosa peggiore che un'azienda software possa fare](https://www.joelonsoftware.com/2000/04/06/things-you-should-never-do-part-i/). La ragione è che il codice legacy, per quanto brutto, contiene anni di decisioni di business, bug fix, edge case e comportamenti che nessuna specifica documenterebbe mai. Quando riscrivi da zero, perdi tutta quella conoscenza codificata. Il risultato è un'applicazione nuova e pulita che però non gestisce i 200 edge case che il vecchio sistema gestiva - e li scopri uno alla volta in produzione, sotto pressione, mentre il business si ferma.

Il refactoring incrementale - che Martin Fowler definisce nel suo libro [Refactoring](https://refactoring.com/) come "cambiare la struttura interna del codice senza modificarne il comportamento osservabile" - evita questo rischio perché lavora sul codice esistente. Ogni modifica è piccola, testata e reversibile. Il sistema continua a funzionare durante tutto il processo. E la conoscenza di business codificata nel vecchio codice viene preservata.

## La tecnica: Strangler Fig Pattern su PHP legacy

Lo [Strangler Fig Pattern](https://martinfowler.com/bliki/StranglerFigApplication.html), documentato da Martin Fowler, è la strategia di refactoring che uso per applicazioni PHP legacy monolitiche. Il nome viene dalla pianta tropicale strangler fig che cresce intorno a un albero esistente, eventualmente sostituendolo - ma l'albero originale continua a vivere durante l'intero processo.

In pratica, significa costruire le nuove funzionalità (o le riscritture di quelle vecchie) in un layer moderno che coesiste con il codice legacy. Un reverse proxy (Nginx) instrada le richieste: le URL nuove vanno all'applicazione moderna, quelle vecchie vanno ancora al codice legacy. Man mano che le funzionalità vengono riscritte, il proxy instrada sempre più traffico verso il codice moderno, fino a che il codice legacy non serve più.

```nginx
# Nginx: Strangler Fig routing
# Le nuove rotte vanno all'applicazione Laravel
location /api/v2/ {
    proxy_pass http://127.0.0.1:8080;  # Laravel su porta 8080
}

location /dashboard/ {
    proxy_pass http://127.0.0.1:8080;  # Dashboard riscritta in Laravel
}

# Tutto il resto va ancora al codice legacy
location / {
    root /var/www/legacy;
    index index.php;
    try_files $uri $uri/ /index.php?$query_string;
}
```

Sul gestionale emiliano, il primo modulo migrato è stato il report vendite - un'area critica per il business ma con poche dipendenze dal resto del sistema. In due settimane è stato riscritto in Laravel con Eloquent, test automatici e una UI moderna. L'URL è cambiata da `/report_vendite.php` a `/dashboard/report/vendite` e Nginx instradava la nuova URL a Laravel. Tutto il resto del gestionale continuava a funzionare esattamente come prima.

## Il prerequisito: characterization test prima di toccare il codice

Non inizio mai un refactoring senza una suite di [characterization test](https://www.mauriziofonte.it/blog/post/test-automatici-codebase-php-legacy-senza-riscrittura.html) che catturi il comportamento attuale del sistema. Questi test sono la mia garanzia che ogni modifica al codice non cambia il comportamento osservabile - se un test fallisce dopo una modifica, so che ho rotto qualcosa prima che arrivi in produzione.

Sul gestionale emiliano, i primi 40 characterization test coprivano: login/logout, ricerca prodotti, inserimento ordine, calcolo totali, generazione fattura, export CSV. Quaranta test scritti in tre giorni che nei mesi successivi hanno catturato 23 regressioni - 23 volte in cui una mia modifica avrebbe rotto qualcosa se i test non l'avessero segnalata.

## Le tecniche di refactoring che producono il maggiore impatto

### Dependency Injection: disaccoppiare per rendere testabile

Il problema più comune nel codice PHP legacy è l'accoppiamento stretto: classi che creano le proprie dipendenze con `new`, funzioni che accedono a variabili globali, codice che chiama `mysql_query` direttamente. Ogni `new` nel corpo di un metodo è un punto di accoppiamento che rende il codice impossibile da testare in isolamento.

```php
<?php
// PRIMA: accoppiamento stretto, impossibile da testare
class OrderProcessor
{
    public function process(int $orderId): void
    {
        $db = new mysqli("localhost", "root", "password", "gestionale");
        $order = $db->query("SELECT * FROM orders WHERE id = $orderId");
        // ... logica di business mescolata con accesso al DB
    }
}

// DOPO: Dependency Injection, testabile
class OrderProcessor
{
    public function __construct(
        private readonly PDO $db
    ) {}

    public function process(int $orderId): array
    {
        $stmt = $this->db->prepare("SELECT * FROM orders WHERE id = :id");
        $stmt->execute(['id' => $orderId]);
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }
}
```

La differenza è che la versione refactored riceve la connessione dall'esterno - nei test puoi passare un database di test, in produzione il database reale. Il codice non sa e non gli importa quale database sta usando. Questa trasformazione, ripetuta su ogni classe che accede al database, è il singolo refactoring con il maggiore impatto sulla manutenibilità.

### PHPStan e Rector: automazione del refactoring

[PHPStan](https://phpstan.org/) con baseline per individuare i problemi, e [Rector](https://getrector.com/) per le trasformazioni automatiche. La combinazione dei due strumenti ha modernizzato il codice emiliano da PHP 5.6 a PHP 7.4 in due giorni di lavoro - Rector ha applicato automaticamente le trasformazioni sintattiche (type hint, null coalescing, arrow functions) e PHPStan ha verificato che nessuna trasformazione avesse introdotto errori.

```bash
# 1. PHPStan per la baseline dei problemi esistenti
vendor/bin/phpstan analyse src/ --level 3 --generate-baseline

# 2. Rector per l'upgrade automatico PHP 5.6 → 7.4
vendor/bin/rector process src/ --dry-run  # preview
vendor/bin/rector process src/            # applicazione

# 3. PHPStan per verificare che Rector non abbia rotto nulla
vendor/bin/phpstan analyse src/ --level 3
```

## Il risultato in tre mesi

Dopo tre mesi di refactoring incrementale, il gestionale emiliano era in una condizione radicalmente diversa:

- **Moduli migrati a Laravel:** report vendite, dashboard, API integrazione corriere - circa il 30% delle funzionalità
- **Copertura test:** 40 characterization test + 60 unit test sui moduli migrati
- **PHPStan level:** da 0 (inutilizzabile) a 5 (type safety buona)
- **Tempo medio per nuova funzionalità:** ridotto del 60% (da 5 giorni-uomo a 2)
- **Bug in produzione:** ridotti del 70% nel primo trimestre post-refactoring

Il costo totale dell'intervento è stato circa un terzo di quanto sarebbe costato il big rewrite - e il gestionale non ha mai smesso di funzionare durante il processo. Per l'articolo che copre il passo precedente - mettere il codice sotto version control - rimando alla guida sull'[implementazione di Git su sistemi legacy](https://www.mauriziofonte.it/blog/post/implementare-git-sistemi-php-legacy-produzione-senza-downtime.html), e per l'[audit di sicurezza](https://www.mauriziofonte.it/blog/post/audit-sicurezza-php-legacy-guida-pratica-vulnerabilita.html) che spesso accompagna il refactoring.

Il refactoring incrementale non è la scelta più glamour - non puoi presentare al management un sistema "tutto nuovo". Ma è la scelta che funziona: costi controllati, rischio minimizzato, e un sistema che migliora ogni settimana senza mai fermare il business. Se il tuo applicativo PHP legacy è diventato un peso anziché un asset, e il preventivo per il big rewrite ti ha spaventato, c'è un'alternativa concreta. [Contattami](https://www.mauriziofonte.it/pages/contattami) e definiamo un piano di refactoring incrementale per il tuo caso specifico.

Dall'articolo al lavoro vero

Se il codice di cui parla questo articolo è il tuo

Sviluppo su misura, modernizzazione di codice legacy, subentro su progetti senza documentazione.

[Vedi tre interventi con i numeri](https://www.mauriziofonte.it/programmatore-php.html)

Strumenti gratuiti per questo articolo

Funzionano nel browser, sullo stesso tema dell'articolo.

- [Migrazione database senza downtime](https://www.mauriziofonte.it/strumenti/migrazione-database-senza-downtime)

Ultima modifica: Martedì 14 Aprile 2026, alle 17:48 [« Articolo precedenteAudit di sicurezza per applicazioni PHP legacy: una guida pratica per identificare e risolvere le vulnerabilità4 Settembre 2025](https://www.mauriziofonte.it/blog/post/audit-sicurezza-php-legacy-guida-pratica-vulnerabilita.html)[Articolo successivo »Piano di Disaster Recovery per applicazioni PHP: guida pratica per la continuità operativa della tua PMI8 Settembre 2025](https://www.mauriziofonte.it/blog/post/piano-disaster-recovery-php-continuita-operativa-pmi.html)

### Articoli correlati a Refactoring del codice PHP legacy: guida pratica per modernizzare un'applicazione senza riscriverla

- [Refactoring del codice legacy: perché la tua azienda ne ha bisogno per sopravvivere](https://www.mauriziofonte.it/blog/post/refactoring-codice-legacy-importanza-strategica.html)

  Ignorare il refactoring del codice legacy limita crescita e sicurezza aziendale. Scopri perché questa attività è fondamentale per migliorare · 26 Mag 2025

  ![Refactoring del codice legacy: perché la tua azienda ne ha bisogno per sopravvivere](https://www.mauriziofonte.it/image/001280070-refactoring-codice-legacy-importanza-strategica.jpg)
- [Migrazione da monolite a microservizi: il metodo Strangler Fig applicato a Laravel](https://www.mauriziofonte.it/blog/post/migrazione-monolite-microservizi-strangler-fig-laravel.html)

  La 'riscrittura totale' è quasi sempre un errore. Con il pattern Strangler Fig ho aiutato una società logistica a estrarre gradualmente funzionalità · 8 Dicembre 2025

  ![Migrazione da monolite a microservizi: il metodo Strangler Fig applicato a Laravel](https://www.mauriziofonte.it/image/002510070-migrazione-monolite-microservizi-strangler-fig-laravel.jpg)
- [Audit tecnico iniziale di un progetto PHP legacy: metodo operativo per i primi 30 giorni](https://www.mauriziofonte.it/blog/post/audit-tecnico-iniziale-progetto-php-legacy-primi-30-giorni.html)

  Un gestionale PHP 7.0 ereditato da un freelance sparito: 43.000 righe di codice, nessuna documentazione, e il titolare che deve decidere se investire · 9 Settembre 2025

  ![Audit tecnico iniziale di un progetto PHP legacy: metodo operativo per i primi 30 giorni](https://www.mauriziofonte.it/image/002270070-audit-tecnico-iniziale-progetto-php-legacy-primi-30-giorni.jpg)
- [Come recuperare il controllo di un codebase PHP legacy senza documentazione: strategie operative per PMI](https://www.mauriziofonte.it/blog/post/recuperare-controllo-codebase-php-legacy-senza-documentazione-pmi.html)

  Un gestionale PHP 5.6 senza Git, senza documentazione, senza test: 147 file PHP sparsi in 23 directory, credenziali MySQL hardcodate in 9 file, · 1 Settembre 2025

  ![Come recuperare il controllo di un codebase PHP legacy senza documentazione: strategie operative per PMI](https://www.mauriziofonte.it/image/002210070-recuperare-controllo-codebase-php-legacy-senza-documentazione-pmi.jpg)
- [Migrazione del codice legacy: perché non puoi affidarti a un consulente generico](https://www.mauriziofonte.it/blog/post/migrazione-codice-legacy-rischi-consulenza-generica.html)

  Migrare un'applicazione legacy non è "aggiornare la versione di PHP": è gestire cambi di comportamento silenziosi, un livello dati fragile e · 16 Mag 2025

  ![Migrazione del codice legacy: perché non puoi affidarti a un consulente generico](https://www.mauriziofonte.it/image/001040070-migrazione-codice-legacy-rischi-consulenza-generica.jpg)

---

**Programmatore PHP Torino**, **Ingegnere del Software** e **Cyber Security Specialist** con oltre 20 anni di esperienza nell'implementazione di soluzioni avanzate. Eseguo **porting di vecchi ambienti PHP** verso release più moderne (7.x o 8.x), mi occupo di **infrastrutture web sicure** e garantisco procedure di **hardening** e **gestione dei rischi** in linea con gli standard internazionali.  
Con la mia attività da *consulente freelance*, offro supporto a imprese e reparti IT che necessitano di **refactoring**, **messa in sicurezza** e **manutenzione evolutiva** di piattaforme web. Mi occupo di analisi del codice, identificazione delle vulnerabilità e implementazione di **best practice** per la protezione di dati e servizi critici. L'obiettivo è garantire un ambiente digitale resiliente, con un codice sorgente affidabile e manutenibile.

---

## Autore

**Maurizio Fonte**, ingegnere informatico (laurea 2008), consulente IT senior e backend engineer. Nel settore IT dal 2005, libero professionista con P.IVA dal 2014. Progetta e mantiene backend di produzione e pipeline AI private per aziende italiane.

Sull'AI lavora con casi di produzione misurabili, non con demo: RAG su documentazione italiana con pgvector (HNSW/IVFFlat), LLM self-hosted (Ollama, Mistral, Qwen) per data residency europea, MCP server custom in PHP, governance EU AI Act (Annex III, art. 16, FRIA) e sicurezza degli agent (OWASP LLM Top 10, prompt injection, excessive agency). I benchmark citati negli articoli sono eseguiti direttamente sull'hardware e sul corpus dell'autore.

## Perché questa fonte è attendibile

- **Esperienza diretta, non rassegna di terzi.** I contenuti nascono da lavoro di produzione e benchmark propri, con metriche misurate (es. un RAG self-hosted su 2.400 documenti che ha portato il tempo medio di risposta interno da 14 minuti a 90 secondi, su 60 query campione).
- **Verificabilità.** Ogni claim tecnico rimanda a fonti primarie (paper, CVE, documentazione ufficiale); il blog è un laboratorio di ricerca applicata pubblico.
- **Onestà metodologica.** Ogni soluzione dichiara anche quando NON va usata. "Production-grade, non demo-grade".

## Entità e contatti (verificabili)

Maurizio Fonte, Torino, Italia. P.IVA IT11396570019. REA TO-1331015 (Camera di Commercio di Torino).  
GitHub: https://github.com/mauriziofonte  
LinkedIn: https://www.linkedin.com/in/mauriziofonte  
Profilo: https://www.mauriziofonte.it/pages/about

---

## Come citare

> Maurizio Fonte, "Refactoring del codice PHP legacy: guida pratica per modernizzare un'applicazione senza riscriverla", mauriziofonte.it, 2025. https://www.mauriziofonte.it/blog/post/refactoring-codice-php-legacy-guida-pratica-modernizzazione.html

Pubblicato: 2025-09-05 · Aggiornato: 2026-04-14.

**Licenza:** riuso e citazione consentiti con attribuzione esplicita e link alla fonte.
