Il Builder pattern separa la costruzione di un oggetto complesso dalla sua rappresentazione, così che il processo di costruzione possa creare rappresentazioni diverse.

Il design pattern Builder è un pattern creazionale che viene utilizzato per creare oggetti complessi step by step. Il suo obiettivo principale è quello di separare la costruzione di un oggetto complesso dalla sua rappresentazione, in modo che lo stesso processo di costruzione possa essere utilizzato per creare oggetti differenti.

Il pattern Builder prevede l’utilizzo dei seguenti elementi:

• Oggetto Builder che viene utilizzato per definire le caratteristiche generali e comuni di oggetti omogenei.
• Metodi di “costruzione” che permettono di definire nello specifico l’oggetto finale passo dopo passo.

Scenari di utilizzo

Il pattern Builder può essere utilizzato ovunque ci sia la necessità di creare oggetti complessi in modo flessibile e modulare, e dove i passaggi di costruzione possono essere suddivisi in metodi più piccoli e gestibili.

Esempi concreti di impiego possono essere:

• Creazione di oggetti Model: Il pattern Builder può essere utilizzato per creare oggetti Model complessi passo dopo passo. Ad esempio, se si vuole creare un oggetto Model che rappresenta un Ordine con molti dettagli, il pattern Builder può semplificare il processo di creazione dell’oggetto suddividendo i passaggi in metodi più piccoli e gestibili.
• Costruzione di Query: Il pattern Builder può essere utilizzato per costruire query SQL complesse in modo flessibile e modulare.
• Creazione di oggetti View: Il pattern Builder può essere utilizzato per creare oggetti View complessi passo dopo passo.

Esempio di pattern Builder in PHP

Vediamo ora un esempio di codice in PHP che utilizza il pattern Builder per creare una classe che funga da query builder SQL.

class QueryBuilder {
  private $table;
  private $fields = array();
  private $conditions = array();

  public function table($table) {
    $this->table = $table;
    return $this;
  }

  public function select($fields) {
    $this->fields = $fields;
    return $this;
  }

  public function where($field, $operator, $value) {
    $this->conditions[] = array(
      'field' => $field,
      'operator' => $operator,
      'value' => $value
    );
    return $this;
  }

  public function build() {
    $query = 'SELECT ' . implode(', ', $this->fields) . ' FROM ' . $this->table;
    if (!empty($this->conditions)) {
      $query .= ' WHERE ';
      foreach ($this->conditions as $condition) {
        $query .= $condition['field'] . ' ' . $condition['operator'] . ' ' . $condition['value'] . ' AND ';
      }
      $query = rtrim($query, ' AND ');
    }
    return $query;
  }
}

In questo esempio, la classe QueryBuilder definisce i metodi per creare una query SQL complessa passo dopo passo. Il metodo table imposta la tabella su cui effettuare la query, il metodo select imposta i campi da selezionare, e il metodo where aggiunge una condizione alla clausola WHERE della query. Infine, il metodo build restituisce la query SQL completa.

Vediamo ora come utilizzare il query builder appena creato:

$query = (new QueryBuilder())
          ->table('products')
          ->select(array('id', 'name', 'price'))
          ->where('price', '>', 10)
          ->where('category', '=', 'electronics')
          ->build();
echo $query;
// Output: SELECT id, name, price FROM products WHERE price > 10 AND category = 'electronics'

Nell’esempio di utilizzo, si crea un oggetto QueryBuilder e si chiamano i metodi necessari per costruire la query desiderata, ovvero selezionare l’id, il nome e il prezzo dei prodotti con un prezzo maggiore di 10 e appartenenti alla categoria ‘electronics’. Infine, si chiama il metodo build per ottenere la query SQL completa.

Vantaggi del design pattern builder

• Consente di creare oggetti complessi step by step, separando la costruzione dell’oggetto dalla sua rappresentazione e facilitando il processo di creazione.
• Permette di creare oggetti con diverse configurazioni, utilizzando gli stessi passaggi di costruzione.
• Consente di creare oggetti in modo più flessibile e modulare, aggiungendo o rimuovendo passaggi di costruzione a seconda delle necessità.
• Consente di migliorare la leggibilità del codice, in particolare quando si hanno molti parametri da passare al costruttore.

Svantaggi del design pattern builder

• Può aumentare la complessità del codice, in particolare se si hanno molti passaggi di costruzione da definire.
• Può richiedere l’implementazione di molte classi aggiuntive (interfacce e classi concrete).
• Può introdurre un costo aggiuntivo di tempo di esecuzione a causa dell’utilizzo di oggetti intermedi durante il processo di costruzione.

Conclusioni

Il pattern Builder è un pattern molto utile e flessibile per la creazione di oggetti complessi, ma deve essere utilizzato con cautela e valutando attentamente le specifiche esigenze del progetto.

Per un panoramica generale sui design pattern consiglio di leggere l’articolo introduttivo sui design patterns.

L'articolo Design Pattern Builder in Php sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Il Singleton pattern assicura che una sola istanza di una classe esista, fornendo un punto di accesso globale a tale istanza.

Il pattern Singleton impedisce la creazione di più istanze di una classe garantendo che ne esista solo una e fornisce un modo per accedere a quell’istanza unica da qualsiasi parte dell’applicazione.

Il singleton prevede tre elementi fondamentali:

• Costruttore privato: impedisce la creazione di istanze della classe dal di fuori della classe stessa.
• Variabile statica privata: mantiene l’istanza unica della classe. Deve essere privata per evitare che altri oggetti accedano ad essa direttamente.
• Metodo statico di accesso all’istanza: restituisce l’istanza unica della classe. Se l’istanza non esiste ancora, il metodo crea l’istanza e la restituisce, altrimenti restituisce semplicemente l’istanza esistente.

Scenari di utilizzo

Il pattern singleton può essere utilizzato quando un certo oggetto deve essere “unico” all’interno del nostro applicativo, per un ruolo di coordinamento o per ottimizzare le risorse. Ecco alcuni esempi concreti di utilizzo:

• Registro / Storage condiviso
• Log / Debug
• Connessione a DB persistente

Esempio di pattern Singleton in PHP

Vediamo ora il codice di base per implementare questo pattern.

class MySingleton {

    /**
     * Istanza unica del singleton
     * @var object
     */
    private static object $instance;

    /**
     * Costruttore privato per prevenire che venga istanziato da codice esterno.
     */
    private function __construct() {
        echo 'Faccio qualcosa...';
    }

    /**
     * Metodo pubblico per l'accesso all'istanza unica di classe.
     * @return object|MySingleton
     */
    public static function getInstance() {
        if ( !isset(self::$instance) ) {
            self::$instance = new MySingleton();
        }
        return self::$instance;
    }
}

Se proviamo ad istanziare due volte il singleton noteremo che il messaggio “Faccio qualcosa…” presente nel costruttore verrà mostrato una sola volta. poiché il sistema utilizzato per implementarlo garantisce l’unicità dell’istanza (oggetto).

Per rendere il codice più riutilizzabile possiamo apportare una piccola modifica all’interno del metodo getIstance() in modo che il nome della classe istanziata con new sia valorizzato automaticamente. Sfruttiamo la costante magica __CLASS__ che restituisce il nome della classe nella quale è richiamata.

if ( !isset(self::$instance) ) {
    $className = __CLASS__;
    self::$instance = new $className;
}

Vantaggi del design pattern singleton

• Garantisce una sola istanza: Il pattern Singleton garantisce che una sola istanza di una classe esista in un determinato momento, il che può essere utile in alcune situazioni, ad esempio per gestire le connessioni al database o le impostazioni globali dell’applicazione.
• Facile accesso globale: Il pattern Singleton fornisce un punto di accesso globale all’istanza unica, il che significa che possiamo accedere all’istanza ovunque e in qualsiasi momento senza dover preoccuparci di passare l’istanza esplicitamente a ogni parte dell’applicazione.
• Riduzione del consumo di memoria: Poiché una sola istanza esiste in un determinato momento, il pattern Singleton può aiutare a ridurre il consumo di memoria del sistema.

Svantaggi del design pattern singleton

Alcuni puristi della programmazione ad oggetti (OOP) possono storcere il naso quando si parla di singleton definendolo un anti-pattern. Le principali critiche al singleton sono le seguenti:

• Viola il Single Responsibility Principle (SRP) se crea delle dipendenze nei componenti che lo utilizzano. L’SRP vorrebbe infatti ogni componente assegnato ad una singola funzione o responsabilità.
• Difficile da testare poiché l’istanza unica esiste in tutta l’applicazione e non può essere facilmente sostituita con una mock o una versione di prova.
• Difficile da estendere poiché impone l’esistenza di una sola istanza di una classe in un determinato momento, può essere difficile estendere il pattern se si desidera introdurre più istanze della classe.
• Crea accoppiamento forte: poiché ogni parte dell’applicazione che utilizza il Singleton dipende dal suo stato globale.
• Viene utilizzato erroneamente per sostituire le variabili globali che, per definizione, non devono essere influenzate dall’applicativo.

Conclusioni

Il singleton si può rivelare molto utile in specifiche situazioni, ma non bisogna abusarne così come non bisogna abusare delle implementazioni statiche nella programmazione ad oggetti. Può essere utile valutare anche altri tipi di soluzioni come la Dependency Injectiono il pattern Factory.

Per un panoramica generale consiglio di leggere l’articolo introduttivo sui design patterns.

L'articolo Design Pattern Singleton in Php sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.