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.

Lo Strategy pattern definisce una famiglia di algoritmi, li incapsula e li rende interscambiabili tra di loro. Strategy permette di variare gli algoritmi indipendentemente dai client che li usano.

Il design pattern Strategy è utile quando si desidera selezionare l’algoritmo da utilizzare in fase di esecuzione ed è composto da tre elementi fondamentali:

• L’interfaccia o la classe astratta “Strategy”: definisce il contratto che deve essere implementato dalle classi che rappresentano le diverse strategie di algoritmo. L’interfaccia o la classe astratta può includere un o più metodi, che rappresentano le operazioni che l’algoritmo deve essere in grado di eseguire.
• Le classi concrete delle strategie: queste classi implementano l’interfaccia o la classe astratta “Strategy” e rappresentano le diverse implementazioni degli algoritmi.
• La classe “Context”: rappresenta il contesto in cui viene eseguito l’algoritmo e che utilizza una delle strategie disponibili per l’esecuzione. La classe “Context” deve accettare un’istanza di una delle classi concrete delle strategie attraverso il costruttore e/o un metodo setter.

Scenario di utilizzo

Il desgin pattern Strategy è utile in situazioni in cui è necessario avere la possibilità di cambiare il comportamento di un’operazione in modo flessibile e senza dover modificare il codice dell’operazione stessa.

Esempi concreti di impiego possono essere:

• Nel controller di un framework MVC, è possibile utilizzare il pattern Strategy per incapsulare la logica di business associata a un’azione specifica. Ad esempio, se un’azione richiede la validazione dei dati di input, è possibile utilizzare una classe di validazione Strategy per gestire questo compito in modo indipendente dalla logica di business principale.
• Nel modello di un framework MVC, è possibile utilizzare il pattern Strategy per gestire la connessione ai diversi database utilizzati dall’applicazione. In questo modo, è possibile rendere la scelta del database dinamica e intercambiabile a runtime.
• Nel template di un framework MVC, è possibile utilizzare il pattern Strategy per definire diverse strategie di rendering a seconda del tipo di visualizzazione richiesta. Ad esempio, è possibile utilizzare una classe di rendering HTML per le visualizzazioni web e una classe di rendering JSON per le API REST.

Esempio di pattern Strategy in PHP

Supponiamo di dover calcolare il prezzo di un prodotto in un negozio online, ma il prezzo può variare in base a diversi fattori, come il tipo di sconto, le imposte applicabili e le tariffe di spedizione.

Invece di creare un metodo per ogni combinazione possibile di fattori, possiamo utilizzare il design pattern Strategy per creare un insieme di algoritmi, o strategie, che possono essere scelti in fase di esecuzione in base ai fattori specifici.

Vediamo ora il codice di base per implementare questo pattern.

// Creazione dell'interfaccia della strategia
interface PricingStrategy {
    public function calculatePrice($product);
}

// Implementazione della prima strategia: nessuno sconto
class NoDiscountStrategy implements PricingStrategy {
    public function calculatePrice($product) {
        return $product->getPrice();
    }
}

// Implementazione della seconda strategia: sconto del 10%
class TenPercentDiscountStrategy implements PricingStrategy {
    public function calculatePrice($product) {
        return $product->getPrice() * 0.9;
    }
}

// Implementazione della terza strategia: sconto del 20%
class TwentyPercentDiscountStrategy implements PricingStrategy {
    public function calculatePrice($product) {
        return $product->getPrice() * 0.8;
    }
}

// Implementazione della classe prodotto
class Product {
    private $price;
    private $pricingStrategy;
    
    public function __construct($price, $pricingStrategy) {
        $this->price = $price;
        $this->pricingStrategy = $pricingStrategy;
    }
    
    public function getPrice() {
        return $this->pricingStrategy->calculatePrice($this);
    }
    
    public function setPricingStrategy($pricingStrategy) {
        $this->pricingStrategy = $pricingStrategy;
    }
}

// Utilizzo del codice
$product = new Product(100, new NoDiscountStrategy());
echo $product->getPrice(); // output: 100

$product->setPricingStrategy(new TenPercentDiscountStrategy());
echo $product->getPrice(); // output: 90

$product->setPricingStrategy(new TwentyPercentDiscountStrategy());
echo $product->getPrice(); // output: 80

In questo esempio, abbiamo creato un’interfaccia PricingStrategy che definisce un metodo calculatePrice(), che viene implementato dalle classi NoDiscountStrategy, TenPercentDiscountStrategy e TwentyPercentDiscountStrategy.

Abbiamo quindi creato una classe Product che accetta un oggetto PricingStrategy nel suo costruttore e ha un metodo getPrice() che utilizza la strategia selezionata per calcolare il prezzo del prodotto.

Infine, abbiamo creato un oggetto Product con un prezzo di 100 e senza sconto, e abbiamo utilizzato il metodo setPricingStrategy() per selezionare le altre strategie di sconto e calcolare il prezzo del prodotto in base ad esse.

Vantaggi del design pattern strategy

• Consente di isolare la logica di business in classi separate, rendendo il codice più modulare e facile da testare.
• Permette di sostituire gli algoritmi utilizzati in modo semplice e senza dover modificare il codice esistente.
• Favorisce l’estendibilità del codice, poiché nuovi algoritmi possono essere facilmente aggiunti senza dover modificare la struttura esistente.

Svantaggi del design pattern strategy

• L’uso del pattern Strategy può portare a un aumento della complessità del codice, poiché richiede la creazione di molte classi aggiuntive.
• Il pattern Strategy potrebbe non essere necessario in tutti i casi e potrebbe rappresentare una soluzione eccessiva in alcune situazioni.

Conclusioni

Il design pattern Strategy può essere una soluzione potente per creare codice modulare e flessibile, ma deve essere utilizzato con cautela e solo quando è effettivamente necessario.

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

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

The main goal is to allow libraries to receive a Psr\Log\LoggerInterface object and write logs to it in a simple and universal way.

L’obiettivo è quello di far sì che le varie componenti software possano utilizzare un oggetto di tipo Psr\Log\LoggerInterface per scrivere messaggi di log in modo semplice ed universale.

Anche gli applicativi più complessi come i framework POTREBBERO estendere l’interfaccia del logger per arricchirla di funzioni, ma DOVREBBERO assicurarsi di mantenerne la compatibilità. In questo modo tutti i componenti e le librerie utilizzate potrebbero scrivere nei log centralizzati dell’applicativo.

La parola implementatore (<strong>implementor</strong>) utilizzata nel testo dello standard PSR3 rappresenta qualcuno che implementa la <strong><em>LoggerInterface</em></strong> per inserire un logger in una libreria o framework .
Gli utenti dei logger vengono definiti utenti (user).

Per il significato delle altre parole chiave si rimanda alle note dell’articolo sul PSR-1.

PSR-3: specifiche

LoggerInterface: l’Interfaccia di base

La <strong><em>LoggerInterface</em></strong> espone otto metodi per scrivere i log utilizzando i rispettivi livelli dello standard RFC 5424: debug, info, notice, warning, error, critical, alert, emergency. Tali livelli vengono definiti come costanti.

<?php

namespace Psr\Log;

class LogLevel
{
    const EMERGENCY = 'emergency';
    const ALERT     = 'alert';
    const CRITICAL  = 'critical';
    const ERROR     = 'error';
    const WARNING   = 'warning';
    const NOTICE    = 'notice';
    const INFO      = 'info';
    const DEBUG     = 'debug';
}

Un nono metodo <strong>log</strong> accetta come primo argomento il livello di log.
La chiamata a questo metodo con una delle costanti di livello DEVE avere lo stesso effetto della chiamata al metodo specifico del relativo livello. Chiamare questo metodo con un livello non definito DEVE lanciare un’eccezione di tipo <em>Psr\Log\InvalidArgumentException</em> se l’implementazione non prevede tale livello. Gli utenti NON DOVREBBERO utilizzare un livello personalizzato senza essere certi che l’attuale implementazione lo supporti.

Psr\Log\LoggerInterface: il codice

Di seguito il codice dell’interfaccia <strong><em>LoggerInterface</em></strong>.

<?php

namespace Psr\Log;

interface LoggerInterface
{
    /**
     * Il sistema è inutilizzabile
     *
     * @param string  $message
     * @param mixed[] $context
     *
     * @return void
     */
    public function emergency( $message, array $context = [] );

    /**
     * È necessario agire immediatamente.
     *
     * Esempio: Il sito web è down, database non disponibile, ... 
     *
     * @param string  $message
     * @param mixed[] $context
     *
     * @return void
     */
    public function alert( $message, array $context = [] );

    /**
     * Condizione critica
     *
     * Esepio: Componente non trovato, eccezione inaspettata, ...
     *
     * @param string  $message
     * @param mixed[] $context
     *
     * @return void
     */
    public function critical( $message, array $context = [] );

    /**
     * Errori di runtime che non richiedono un'azione immediata 
     * ma in genere dovrebbero essere loggati e monitorati.
     *
     * @param string  $message
     * @param mixed[] $context
     *
     * @return void
     */
    public function error( $message, array $context = [] );

    /**
     * Occorrenze eccezionali che non sono errori
     * Esempio: uso di api deprecate.
     *
     * @param string  $message
     * @param mixed[] $context
     *
     * @return void
     */
    public function warning( $message, array $context = [] );

    /**
     * Eventi normali ma significativi.
     *
     * @param string  $message
     * @param mixed[] $context
     *
     * @return void
     */
    public function notice( $message, array $context = [] );

    /**
     * Eventi interessanti
     * Esempio: Log-in utente, esecuzione query, ...
     *
     * @param string  $message
     * @param mixed[] $context
     *
     * @return void
     */
    public function info( $message, array $context = [] );

    /**
     * Informazioni dettagliate sul debug.
     *
     * @param string  $message
     * @param mixed[] $context
     *
     * @return void
     */
    public function debug( $message, array $context = [] );

    /**
     * Creazione del Log con un livello arbitrario.
     *
     * @param mixed   $level
     * @param string  $message
     * @param mixed[] $context
     *
     * @return void
     *
     * @throws \Psr\Log\InvalidArgumentException
     */
    public function log( $level, $message, array $context = [] );
}

La gestione dell’eccezione di <em>Psr\Log\InvalidArgumentException</em> estende la classe nativa di php <a rel="noreferrer noopener" href="https://www.php.net/manual/en/class.invalidargumentexception.php" target="_blank"><em>InvalidArgumentException</em></a> e deve essere lanciata dal logger qualora vengano passati ai metodi dei paramentri non corretti.

<?php

namespace Psr\Log;

class InvalidArgumentException extends \InvalidArgumentException {
    // class body
}

PSR-3: messaggi

Ogni metodo accetta una stringa come messaggio o un oggetto con un metodo __toString (). Gli implementatori POSSONO implementare una gestione personalizzata per gli oggetti passati al metodo. In caso contrario, gli implementatori DEVONO eseguire il type casting del valore passato in stringa.

Il messaggio PUÒ contenere un placeholder che gli implementatori possono sostituire con i valori presi dall’array del parametro context.

I nomi dei placeholder DEVONO corrispondere alle chiavi del context array.

I nomi dei placeholder DEVONO essere delimitati fra due parentesi graffe singole {placeholder}. NON DEVE esserci spazio tra i delimitatori e il nome placeholder.

I nomi dei placeholder DOVREBBERO essere composti solo dai caratteri A-Z, a-z, 0-9, underscore _, e punto .. L’uso di altri caratteri è riservato per future modifiche delle specifiche dei placeholder.

Gli implementatori POSSONO usare i placeholder per implementare escaping strategy o gestire la traduzione dei messagi. Gli utenti non DOVREBBERO effettuare l’escape preventivo dei placeholder poiché non possono sapere in quale contesto i dati inseriti nei messaggi verranno visualizzati.

Il PHP-FIG fornisce una semplice funzione di esempio per comprendere meglio la funzione dei placeholder nei messaggi di log.

<?php

/**
 * Sostituisce i placeholder dei messaggi con i rispettivi valori.
 */
function interpolate($message, array $context = []) {
    // Crea l'array delle sostituzioni
    $replace = array();
    foreach ($context as $key => $val) {
        // controlla che il valore possa essere usato come stringa.
        if (!is_array($val) && (!is_object($val) || method_exists($val, '__toString'))) {
            $replace['{' . $key . '}'] = $val;
        }
    }

    // Sostituisce i placeholder con i rispettivi valori.
    return strtr($message, $replace);
}

// Messaggio contenente il placeholder fra graffe
$message = "User {username} created";

// Il context array con i dati da sostituire ai placeholder
$context = array('username' => 'bolivar');

// stampa "User bolivar created"
echo interpolate($message, $context);

Context data

Ogni metodo accetta un array contenente dati contestuali (context data) per gestire ulteriori informazioni che non possano essere ridotte alla stringa del messagio. L’array può contenere qualsiasi tipo di dato. Gli implementatori DEVONO utilizzare i dati di contesto con moderazione. Un context data NON DEVE generare un’eccezione né errori php di tipo error, warning o notice

Se nei context data viene passato un oggetto di tipo <em>Exception</em>, questo DEVE essere passato nella chiave 'exception'. Poiché il log delle eccezioni è un’esigenza diffusa, questa regola dello standard PSR-3 consente di registrare questo tipo di evento ed il relativo stack trace. Gli implementatori DEVONO verificare che il dato contenuto nella chiave 'exception' sia realmente un oggetto di tipo Exception dato che l’elemento dell’array potebbe contenere qualsiasi tipo di dato.

PSR-3: classi helper ed interfacce

La classe di esempio <em>Psr\Log\AbstractLogger</em> facilita l’implementazione di <em>LoggerInterface</em> estendendola e implementando il metodo log generico. Gli altri otto metodi richiamano il metodo <em>log</em> passandogli la corretta costante di livello, messaggio ed eventuale contesto.

<?php

namespace Psr\Log;

abstract class AbstractLogger implements LoggerInterface {

    public function emergency($message, array $context = []) {
        $this->log(LogLevel::EMERGENCY, $message, $context);
    }

    public function alert($message, array $context = []) {
        $this->log(LogLevel::ALERT, $message, $context);
    }

    public function critical($message, array $context = []) {
        $this->log(LogLevel::CRITICAL, $message, $context);
    }

    public function error($message, array $context = [])) {
        $this->log(LogLevel::ERROR, $message, $context);
    }

    public function warning($message, array $context = []) {
        $this->log(LogLevel::WARNING, $message, $context);
    }

    public function notice($message, array $context = []) {
        $this->log(LogLevel::NOTICE, $message, $context);
    }

    public function info($message, array $context = []) {
        $this->log(LogLevel::INFO, $message, $context);
    }

    public function debug($message, array $context = []) {
        $this->log(LogLevel::DEBUG, $message, $context);
    }
}

Similmente ad AbstractLogger è possibile creare un trait <em>Psr\Log\LoggerTrait</em> utile nel caso si voglia implementare il logger in diverse classi. Poiché i traits non possono implementare delle interfacce, in questo caso si dovrà di fatto riscrivere il codice di LoggerInterface.

namespace Psr\Log;

trait LoggerTrait {

    public function emergency($message, array $context = []) {
        $this->log(LogLevel::EMERGENCY, $message, $context);
    }

    public function alert($message, array $context = []) {
        $this->log(LogLevel::ALERT, $message, $context);
    }

    public function critical($message, array $context = array[]) {
        $this->log(LogLevel::CRITICAL, $message, $context);
    }

    public function error($message, array $context = [])) {
        $this->log(LogLevel::ERROR, $message, $context);
    }

    public function warning($message, array $context = []) {
        $this->log(LogLevel::WARNING, $message, $context);
    }

    public function notice($message, array $context = [])
    {
        $this->log(LogLevel::NOTICE, $message, $context);
    }

    public function info($message, array $context = [])
    {
        $this->log(LogLevel::INFO, $message, $context);
    }

    public function debug($message, array $context = [])
    {
        $this->log(LogLevel::DEBUG, $message, $context);
    }

    abstract public function log($level, $message, array $context = []);
}

Veniamo ora al “piuttosto che niente”! <em>Psr\Log\NullLogger</em> implementa <em>AbstractLogger</em> e PUÒ essere usato dagli utenti, se non gli viene fornito un apposito log, da utilizzare con una fall-back. E’ una sorta di “black hole” in cui inviare qualcosa che potrà essere loggato.

<?php

namespace Psr\Log;

class NullLogger extends AbstractLogger
{
    /**
     * Logs with an arbitrary level.
     *
     * @param mixed  $level
     * @param string $message
     * @param array  $context
     *
     * @return void
     *
     * @throws \Psr\Log\InvalidArgumentException
     */
    public function log($level, $message, array $context = array())
    {
        // class body
    }
}

<em>Psr\Log\LoggerAwareInterface</em> contiene solo un metodo setLogger(LoggerInterface $logger) che PUÒ essere utilizzato dai framework per collegarsi automaticamente a istanze del logger.

<?php

namespace Psr\Log;

interface LoggerAwareInterface {
    public function setLogger(LoggerInterface $logger);
}

Il trait Psr\Log\LoggerAwareTrait PUÒ essere utilizzato per implementare facilmente la medesima interfaccia in qualsiasi classe così da avere accesso all’oggetto $this->logger.

PSR-3 Logger package

Le interfacce e le classi descritte, nonché le relative classi di eccezione e una suite di test per verificare l’implementazione sono fornite come parte del pacchetto psr/log sul sito ufficiale di PHP-FIG

L'articolo PSR-3 Logger Interface: standard log per PHP sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Prima di procedere con la lettura della lezione sullo standard PSR1 consiglio di leggere le note in fondo alla pagina. Inoltre, nella sezione “Lezioni“, è possibile trovare altro materiale sugli standard PHPFIG.

PSR-1: in breve

• I file PHP DEVONO usare solo i tag <?php e <?=,
• DEVONO usare solo la codifica UTF-8 priva di BOM,
• DOVREBBERO dichiarare classi, funzioni, costanti, … OPPURE DOVREBBERO eseguire altri tipi di azioni logiche come generare output, modificare parametri di configurazione del php.ini, includere file … ma NON DOVREBBERO fare entrambe le cose.
• I Namespaces e i Class Names DEVONO seguire lo standard per “autoloading” PSR-4: una sola classe in un solo file, namespace di almeno un livello indicante il vendor-name.
• I Class Names DEVONO essere dichiarati in StudlyCaps.
• Le costanti DEVONO essere dischiarate in maiuscolo utilizzando l’underscore come separatore.
• I nomi dei metodi DEVONO essere dichiarati in camelCase.

PSR-1: files

PHP Tags

Il codice PHP deve essere dichiarato attraverso i tag <?php ?> oppure gli short-echo <?= ?> tags. NON DEVE utilizzare altre varianti di tag dichiarativi (es: <? ?>).

Codifica dei caratteri

Il file PHP DEVE utilizzare solo la codifica UTF-8 ed essere privo di BOM.

Dichiarazioni ed effetti collaterali (side effects)

Un file DOVREBBE dichiarare nuovi “simboli” (classi, funzioni, costanti, …) senza causare altri “effetti collaterali” OPPURE DOVREBBE eseguire una logica con effetti collaterali, MA NON DOVREBBE fare entrambe le cose.

Lo standard spiega che l’espressione “effetti collaterali” (side effects) indica l’esecuzione di una logica non direttamente correlata alla dichiarazione di classi, funzioni, costanti, ecc, ma correlata direttamente all’inclusione del file stesso.

Vengono poi fatti alcuni esempi di “effetti collaterali” a titolo esemplificativo: generazione di output, uso esplicito di require o include, connessione a servizi esterni, modifica di parametri del php.ini, generazione di errori o eccezioni, modifica di variabili statiche o globali, lettura/scrittura di file, …

Ecco un esempio di file non conforme allo standard con la coopresenza di dichiarazioni ed “effetti collaterali”.

<?php
// effetto collaterale: cambio ini setting
ini_set('error_reporting', E_ALL);

// effetto collaterale: carico un file
include "file.php";

// effetto collaterale: genero output
echo "<html>\n";

// dichiarazione una funzione
function foo() {
    // function body
}

Il seguente esempio mostra un file conforme allo standard contenete solo delle dichiarazioni:

<?php
// dichiarazione una funzione
function foo() {
    // function body
}

// la dichiarazione condizionale non è un effetto collaterale.
if (! function_exists('bar')) {
    function bar() {
        // function body
    }
}

PSR-1: namespace e class names

I namespaces ed i class names DEVONO essere conformi ad allo standard per l’autoloading PSR-4.

Ciò significa che ogni classe DEVE essere dichiarata in un file dedicato e DEVE trovarsi in un Namespace di almeno un livello indicante il vendor-name, in pratica l’indicazione dello sviluppatore.

I class names DEVONO essere dichiarati in StudlyCaps.

ll codice scritto da PHP 5.3 in avanti DEVE utilizzare namespaces formali.

<?php
// PHP 5.3 e successivi:
namespace Vendor\Model;

class Foo {
  // Class body
}

Il codice scritto per PHP 5.2 e versioni precedenti DOVREBBE usare la convenzione pseudo-namespacing con prefissi Vendor_ nei nomi delle classi.

<?php
// PHP 5.2.x e versioni precedenti:
class Vendor_Model_Foo {
  // Class body
}

PSR-1: costanti di classe, proprietà e metodi

Il termine “class” si usa qui in senso più ampio per riferirsi a tutte le classi, le interfacce ed i traits.

Costanti

Le costanti di classe DEVONO essere dischiarate in maiuscolo utilizzando l’underscore come separatore. Personalmente applico questa regola a tutte le costanti comprese quelle definite con define().

<?php
namespace Vendor\Model;

class Foo {
    const VERSION = '1.0';
    const DATE_APPROVED = '2012-06-01';
}

Proprietà

Lo standard evita intenzionalmente di fornire consigli riguardanti l’uso dei nomi di prorpietà $StudlyCaps, $camelCase, or $under_score property names.

Qualunque sia la convenzione di denominazione utilizzata DOVREBBE essere applicato in modo coerente.

Metodi

I nomi dei metodi DEVONO essere dichiarati in camelCase().

PSR1 nel lavoro di tutti i giorni

Il nuovo framework CoreBox che stiamo sviluppando alla Communication Box adererisce perfettamente allo standard PSR1. Questo facilita notevolmente lo sviluppo poiché ogni componente del team trova sempre una certa familiarità nel leggere il codice scritto dai colleghi.

Note

Quando si legge un documento del PHP-FIG le parole DEVE (MUST), NON DEVE (MUST NOT), RICHIESTO (REQUIRED), POTRÀ (SHALL), NON POTRÀ (SHALL NOT), DOVREBBE (SHOULD), NON DOVREBBE (SHOULD NOT), RACCOMANDATO (RECCOMANDED), PUÒ (MAY) e OPZIONALE (OPTIONAL) vanno interpretati secondo quanto descritto nel documento RFC 2119.

Lo stile StudlyCaps, noto anche come PascalCase, impone che la prima lettera di ogni parola sia in maiuscolo. Una stringa in questo stile deve iniziare sempre con la lettera maiuscola.

Lo stile camelCase, proprio come in un cammello, impone che le gobbe siano solo in mezzo. Una stringa in questo stile deve iniziare sempre con la lettera minuscola.

L'articolo PSR-1: regole per la scrittura di codice 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.

Progettare software ad oggetti è difficile, ma lo è ancora di più renderne i suoi componenti riutilizzabili. La scomposizione dell’applicativo in oggetti deve tener conto di molteplici fattori: incapsulamento, granularità, dipendenza, performance, ridondanza, riusabilità, modularità, estendibilità nel tempo.

I design pattern vengono in nostro soccorso indicandoci soluzioni a problemi ricorrenti così da rendere il nostro codice riutilizzabile e mantenibile.

La genesi

Il concetto di design pattern è stato mutuato dall’ingegneria del software direttamente dall’architettura. Fu l’architetto austriaco Cristopher Alexander a formalizzare tale concetto nel 1977 all’interno del libro Pattern Language: Towns, Buildings, Construction.

Il pattern è una soluzione architetturale che può risolvere problemi in contesti eterogenei.

La trasposizione del concetto di design pattern in ambito informatico è attribuita invece alla cosiddetta Gang of Four (GoF) formata da Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides. Dopo quatro anni di confronto condensarono tutta la loro esperienza in un libro del 1994 che è diventato la “Bibbia della programmazione ad oggetti”: Design Patterns: elements of reusable object oriented software“ (Elementi per il riuso di software ad oggetti).

Il design pattern descrive un problema ricorrente e fornisce una soluzione che può essere riutilizzata infinite volte senza doverla applicare mai nello stesso identico modo

Design Pattern: classificazione

La GoF cataloga i suoi 23 pattern suddividendoli in 3 macro categorie:

• Pattern creazionali: soluzioni per creare oggetti.
• Pattern strutturali: soluzioni per la composizione strutturale di classi e oggetti.
• Pattern comportamentali: soluzioni per gestire le responsabilità delle classi e degli oggetti.

Una seconda classificazione viene fatta in base al loro ambito applicativo:

• Class pattern: soluzioni tramite classi e sottoclassi in relazioni statiche tra loro.
• Object Pattern: soluzioni dinamiche basate sugli oggetti.

Infine ogni pattern viene descritto in base agli elementi che lo caratterizzano:

• Nome/Alias: sintentizza l’essenza del pattern.
• Scopo: cosa fa il pattern.
• Motivazione: scenario del problema e soluzione offerta.
• Applicabilità: situazioni di esempio in cui si può usare il pattern.
• Struttura: rappresentazione grafica delle classi del pattern.
• Partecipanti: classi/oggetti interessati e relative responsabilità
• Collaborazioni: dei partecipanti per poter assumersi le responsabilità.
• Conseguenze: pro e contro del pattern.
• Implementazione: tecniche e consigli per implementare il pattern.
• Codice d’esempio: in C++ e SmallTalk.
• Utilizzi noti: esempi reali in sistemi esistenti.
• Correlazioni: legami con altri pattern e differenze.

I 23 pattern definiti dal GoF possono essere quindi così schematizzati:

Design Pattern: il catalogo della GoF

Riporto qui una sintesi del catalogo composto dai 23 design pattern in modo da avere un’idea di massima del loro utilizzo.
Ricordo che con il termine “interfaccia” si intende qui l’insieme delle richieste a cui un oggetto può rispondere cioè l’insieme delle proprietà e dei metodi pubblici di un oggetto. Attenzione quindi a non confondersi con le “interface” di Php!

• Abstract Factory: fornisce un’interfaccia per la creazione di famiglie di oggetti correlati o dipendenti senza specificare o conoscere le classi concrete.
• Adapter: converte l’interfaccia di una classe in un’altra interfaccia richiesta dal client permettendo la collaborazione fra classi tra loro incompatibili.
• Bridge: disaccoppia un’astrazione dalla sua implementazione in modo che le due possano variare indipendentemente.
• Builder: separa la costruzione di un oggetto complesso dalla sua rappresentazione così che lo stesso processo di creazione possa creare rappresentazioni diverse.
• Chain of Responsability: disaccoppia il mittente di una richiesta dal suo destinatario. Si ordinano gli oggetti destinatari e la richiesta viene passata di oggetto in oggetto finché non viene gestita.
• Command: incapsula una richiesta in un oggetto.
• Composite: raggruppa oggetti in strutture ad albero permettendo ai client di trattare oggetti singoli e raggruppamenti in modo uniforme.
• Decorator: aggiunge dinamicamente responsabilità ad un oggetto. E’ un’aternativa flessibile all’ereditarietà.
• Facade: definisce un’interfaccia di più alto livello per facilitare l’utilizzo di un sottosistema più complesso.
• Factory Method: permette ad una classe di delegare la creazione di un oggetto alle sue sottoclassi.
• Flyweight: usa la condivisione per gestire numerosi oggetti a granularità fine.
• Interpreter: permette di implementare un proprio linguaggio con la sua grammatica ed il relativo interprete.
• Iterator: permette di accedere agli elementi di un contenitore sequenzialmente senza esporre la struttura sottostante.
• Mediator: favorisce un basso accoppiamento evitando che gli oggetti facciano riferimento l’un l’altro.
• Memento: esplicita lo stato interno di un oggetto così da poterlo riportare al suo stato originale.
• Observer: definisce una dipendenza uno-a-molti fra oggetti così che quando un oggetto cambia stato tutti gli oggetti dipendenti vengano notificati ed aggiornati.
• Prototype: specifica gli oggetti da creare utilizzando un’istanza prototipale.
• Proxy: fornisce un surrogato di un oggetto pper controllare l’accesso a quest’ultimo.
• Singleton: forza una classe ad avere una sola istanza e ne fornisce un accesso globale.
• State: permette ad un oggetto di modificare il proprio comportamento quando il suo stato interno cambia. Sembrerà che l’oggetto abbia cambiato la sua classe.
• Strategy: definisce una famiglia di algoritmi, li incapsula e li rende interscambiabili tra di loro.
• Template Method: definisce lo scheletro principale dell’algoritmo in un metodo delegando alcuni passi alle sottoclassi.
• Visitor: permette di definire nuove operazioni senza cambiare le classi degli elementi su cui opera.

Riferimenti

Design Patterns: Elements of Reusable Object-Oriented Software
Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
Pearson Education

https://designpatternsphp.readthedocs.io

https://refactoring.guru/design-patterns

L'articolo Design Pattern GoF – Guida sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Cosa sono i namespaces in php?

What are namespaces? In the broadest definition namespaces are a way of encapsulating items.

I namespaces, introdotti in PHP 5.3 e migliorati in PHP 7, permettono di raggruppare classi, interfacce, funzioni e costanti per evitare ambiguità di denominazione. In questo modo potremo far coesistere classi con lo stesso nome “incapsulate” in namespace differenti esattamente come avviene per file con lo stesso nome posti in cartelle diverse del filesystem. La possibilità di creare una gerarchizzazione (sub-namespace) fornisce una chiara indicazione sull’organizzazione delle risorse del nostro applicativo. Ad esempio, assegnando i namespaces Framework\Core\Main ad un file contenente una classe e Framework\Core\Main\Libs ad un altro contenente un’altra classe con il medesimo nome, è facilmente intuibile come la prima si riferisca alle funzionalità di base del nostro ipotetico framework e l’altra sia presente in una libreria secondaria.

Pur essendo forte l’analaogia con il filesystem non sussite alcuna relazione diretta fra un namespace ed il percorso dei file .php. E’ però intuitivo utilizzare questa analogia per creare vincoli convenzionali e sfruttarli nella pratica dell’autoloading la cui implementazione più diffusa è sintetizzata nello standard PSR-4 che approfondirò in un altro articolo.

Namespaces: vantaggi di utilizzo

• Risolvono il problema di omonimia di classi, interfacce, funzioni e costanti tra il codice scritto dallo sviluppatore, quello integrato in librerire di terze parti e quello nativo di Php.
• Facilitano lo sviluppo di codice ordinato, organizzato ed “eloquente”.
• Migliorano la leggibilità e la scrittura del codice permettendo di utilizzare degli alias nel momento in cui la precisa ed inevitabile lunghezza del namespace non fosse necessaria.

Namespaces: dichiarazione

Compresi i vantaggi del loro utilizzo vediamo come utilizzare i namespaces iniziando dalla loro dichiarazione attraverso l’apposita keyword <strong>namespace</strong>.
Uno script che faccia uso di namespaces deve dichiararlo all’inizio del listato fatta eccezione per i commenti ed eventuali istruzioni declare.

<?php
declare(encoding='UTF-8');

// Dichiaro il namespace...
namespace Framework\Core\Main;

Attenzione!

• I namespaces non possono contenere keywords del linguaggio php.
  Framework\Core\<s>Class</s>
• I namespaces non possono iniziare con un numero.
  Framework\Core\<s>1Class</s>
• E’ possibile, ma altamente sconsigliato, dichiarare più namespaces nello stesso file utilizzando le parentesi graffe.
  <?php<br /><em><strong>Framework\Core\Main</strong></em> { // codice }<br /><em><strong>Framework\Core\Libs</strong></em> { // codice }

Php Namespaces: dalla teoria alla pratica

Immaginiamo di creare ed includere due file php contenenti la dichiarazione di una classe denominata nello stesso modo (Es: MyClass). Una volta in esecuzione otterremmo questo errore:
<strong>Fatal error</strong>: Cannot declare class MyClass, because the name is already in use

Aggiungiamo ora ai due file una dichiarazione namespace…

<?php // File 1: /Framework/Core/Main/MyClass.php

namespace Framework\Core\Main;

Class MyClass {
    public function __construct() {
        echo '<p>MAIN: MyClass ready!</p>';
    }
}

<?php // File 2: /Framework/Core/Main/Libs/MyClass.php

namespace Framework\Core\Main\Libs;

Class MyClass {
    public function __construct() {
        echo '<p>LIBS: MyClass ready!</p>';
    }
}

Creiamo ora il file principale ex01.php che li includerà e tenterà di creare un oggetto.

<?php // File: /ex01.php

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// Creo l'oggetto
$objOne = New MyClass();

Mandandolo in esecuzione ci troveremo davanti ancora un errore…
<strong>Fatal error</strong>: Uncaught Error: Class 'MyClass' not found in...

Questo si verifica poichè le nostre due classi “MyClass” sono assegnate ai rispettivi namespaces, mentre il nostro file principale non ha alcun namespace specificato e si riferisce quindi a quello globale in cui la classe MyClass() non è definita.

Namespaces: tipi di riferimento

Sappiamo definire i namespaces, ma per richiamarli correttamente dobbiamo conoscere quali sono i tipi di riferimento che possiamo utilizzare e che nuovamente hanno una forte analogia con i percorsi dei filesystem:

• Unqualified name (nomi non qualificati): si riferiscono solo al namespace corrente. È come cercare un fille nella cartella in cui ci si trova.
  MyClass()
• Qualified name (nomi qualificati): paragonabile al percorso relativo di un file.
  Main\Libs\MyClass()
• Fully-qualified name (nomi completamente qualificati): inizia sempre con un backslash iniziale ed è paragonabile ad un percorso assoluto. È il modo più sicuro anche se più verboso.
  \Framework\Core\Main\Libs\MyClass()

Unqualified name – Nel file principale (ex02.php) dichiariamo lo stesso namespace di uno dei due file contenenti la dichiarazione di MyClass() che vorremmo richiare, ad esempio Libs: Framework\Core\Main\Libs. Ecco finalmente il primo risultato positivo!

<?php // File: /ex02.php

// Dichiaro il namespace
namespace Framework\Core\Main\Libs;

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// UNQUALIFIED NAME...
$objOne = New MyClass();

Qualified name – Nel file principale (ex03.php) dichiariamo un namespace più generico Framework\Core ed utilizzamo nomi qualificati per riferirci ad entrambe le nostre classi ed ottenere i relativi oggetti.

<?php
// File: /ex03.php

// Dichiaro il namespace
namespace Framework\Core;

require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// QUALIFIED NAME...
$objOneMain = New Main\MyClass();
$objOneLib = New Main\Libs\MyClass();

Nota: una volta dichiarato un namespace, per riferirsi al contesto globale è necessario anteporre il backslash.

Fully-qualified name – Nel file principale (ex04.php) omettiamo il namespace, ma utilizziamo un nome completamente qualificato per riferirci alle due classi.

<?php // File: /ex04.php

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// FULLY-QUALIFIED NAME...
$objOneMain = New \Framework\Core\Main\MyClass();
$objOneLib = New \Framework\Core\Main\Libs\MyClass();

Php Namespaces: importazione e aliasing tramite l’operatore “use”

Una caratteristica importante dei namespaces è la possibilità di essere importati e di creare degli alias per renderne più pratico l’utilizzo vista la loro “eloquenza”. Queste funzioni trovano un parallelismo nella capictà dei filesystem di creare link simbolici a file o cartelle.
A tale scopo Php mette a disposizione la keyword <strong>use</strong> con la quale è possibile eseguire i seguenti tipi di seguenti tipi di importazione/aliasing:

• nomi di classi o interfacce (use Name\Space\ClassName),
• nomi di classi o interfacce globali (use DateTime)
• namespaces (use Name\Space\For\...)
• nomi di funzioni (use function Name\Space\FunctionName)
• nomi di costanti (use const Name\Space\CONSTANT).

E’ possibile importare anche più elementi nello stesso file purché non si generino delle ambiguità, in tal caso si potrà ricorrere agli alias.

Applichiamo use al nostro scenario di esempio (ex05.php) per importare i namespaces comuni alla due classi e sintetizzarli in “Main”.

<?php // File: /ex05.php

use Framework\Core\Main as Main;

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// QUALIFIED NAME...
$objOneMain = New Main\MyClass();
$objOneLib = New Main\Libs\MyClass();

Nell’esempio seguente (ex06.php) utilizziamo use per superare l’ambiguita dei nomi delle classi e creare un alias dei namespaces.

<?php // File: /ex06.php

use Framework\Core\Main\MyClass as MainMy;
use Framework\Core\Main\Libs\MyClass as LibsMy;

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// UNQUALIFIED NAME...
$objOneMain = New MainMy();
$objOneLib = New LibsMy();

Direi sia tutto! Qui trovate i file di esempio visti nella lezione e se l’articolo è stato utile… condividilo!

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

Scenario: dobbiamo convertire lato server un’immagine RGB in CMYK

Problema: letta la scarna documentazione di Imagemagick sulla refernece di Php ci imbattiamo in un annoso problema: l’immagine ottenuta è in negativo!!!

Soluzione: dopo aver letto post su post sui soliti siti senza riuscire a trovare una soluzione e grazie al supporto di Giacomarco, ecco svelato il mistero.

Se si deve convertire un’immagine occorre usare transformimagecolorspace, mentre se si sta generando un’immagine ex-novo allora si deve utilizzare transformimagecolorspace:

$image->transformimagecolorspace(Imagick::COLORSPACE_CMYK);

Se invece si sta creando un’immagine ex-novo allora si deve utilizzare setImageColorSpace

$image->setImageColorSpace(Imagick::COLORSPACE_CMYK);

Ecco un esempio:

$image = new Imagick();
$image->readImage(rgb.jpg);
$image->transformimagecolorspace(Imagick::COLORSPACE_CMYK);
$image->profileImage('icc', file_get_contents(/path/CoatedFOGRA27.icc'));
$image->writeImage(cmyk.rgb);

Per gli amici in lingua inglese: [SOLVED] imagemagick convert image RGB to CMYK!

L'articolo Conversione immagine: Imagemagick RGB to CMYK in PHP sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Credo che qualsiasi programmatore si sia trovato nella condizione di dover cercare un determinato valore di un campo ricorrente in molteplici record per sostituirlo con uno diverso.

Diciamo ad esempio di voler sostituire in una tabella di dati anagrafici il termine “maschio” con “M” nel campo “genere”.

Problema: come fare quindi per eseguire un “cerca e sostituisci” in massa su tutti i record interessati della tabella MySql?

Soluzione: detto fatto, basta sfruttare l’apposita string function REPLACE di MySQL opportunatamente combinata con un UPDATE:

UPDATE `nomeTabella` SET `nomeCampo` = REPLACE(`nomeCampo`, ‘cosaTrovare‘, ‘cosaSostituire‘);

Se l’applichiamo al nostro esempio otterremo:

UPDATE `Anagrafica` SET `genere` = REPLACE(`genere`, 'maschio', 'M');

L'articolo MySql: cerca e sostituisci in una query per web developer sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Per fare questo dovremo utilizzare il protocollo HTTPS che abbina il comune HTTP ad un ulteriore protocollo di crittografia asimmetrica.
HTTPS è infatti l’acronimo di HyperText Transfer Protocol over Secure Socket Layer.
Questo sistema di sicurezza è stato pensato proprio per evitare che attraverso tecniche di man in the middle un malintenzionato possa fare sniffing dei dati scambiati bidirezionalmente fra server e client.

Problema: se “tirar su” un server LAMP è ormai alla portata di tutti i web developer grazie alle molte distribuzioni out of the box, abilitare l’https è già un’operazione più specificatamente sistemistica, ma ugualmente attuabile in pochi minuti.

Spiegazione: su Ubuntu Server, così come in molte altre distribuzioni, il modulo SSL è già presente nell’installazione base di Apache.
Bisogna solo attivarlo con il seguente comando che abilita anche la porta 443 di default per l’https.

sudo a2enmod ssl

Dovremo quindi predisporre una cartella in cui generare i nostri certificati di sicurezza. Consiglio di creare una sottocartella dentro a quella di apache.

Nel caso di Ubunti dovremo lanciare il comando

sudo mkdir /etc/apache2/ssl

In altre distribuzioni come centOS la sottocartella può essere creata con i comando

sudo mkdir /etc/httpd/ssl

Per ottenere chiave privata e certificato utilizzeremo openssl attraverso il seguente comando, riportando i percorsi corretti, scegliendo la crittografia RSA a 2048 bit e una validità di 365 giorni.

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/apache2/ssl/apache.key -out /etc/apache2/ssl/apache.crt

Nel caso openssl non fosse presente, si può installare mediante il seguente comando su Ubuntu (o analoghi su altre distro)

apt-get install openssl

La procedura di creazione dei certificati pone alcune domande alle quali si può rispondere abbastanza liberamente, es:

Country Name (2 letter code) [AU]:IT
State or Province Name (full name) [Some-State]:Modena
Locality Name (eg, city) []:Modena
Organization Name (eg, company) [Internet Widgits Pty Ltd]:communicationBox
Organizational Unit Name (eg, section) []:Development
Common Name (e.g. server FQDN or YOUR name) []:NomeMioServer
Email Address []:maimaildiriferimento@dominio.it

A questo punto il grosso del lavoro è fatto, non resta che settare i virtual host per indicare di sfruttare la cominicazione sicura sulla porta 443 e chiave e certificato appena creati.

Nella cartella /etc/apache2/sites-available/ è solitamente già presente un file di esempio denominato default-ssl.conf che possiamo modificare o utilizzare come modello per creare il nostro file:

sudo nano /etc/apache2/sites-available/default-ssl.conf

<VirtualHost *:80>
        ServerAdmin webmaster@localhost

        DocumentRoot /var/www/html
        <Directory />
                Options FollowSymLinks
                AllowOverride All
        </Directory>
        <Directory /var/www/>
                Options -Indexes +FollowSymLinks +MultiViews
                AllowOverride All
                Order allow,deny
                allow from all
        </Directory>

        ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
        <Directory "/usr/lib/cgi-bin">
                AllowOverride None
                Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
                Order allow,deny
                Allow from all
        </Directory>

        ErrorLog ${APACHE_LOG_DIR}/error.log

        # Possible values include: debug, info, notice, warn, error, crit,
        # alert, emerg.
        LogLevel warn

        CustomLog ${APACHE_LOG_DIR}/access.log combined

        Alias /doc/ "/usr/share/doc/"
        <Directory "/usr/share/doc/">
                Options MultiViews FollowSymLinks
                AllowOverride None
                Order deny,allow
                Deny from all
                Allow from 127.0.0.0/255.0.0.0 ::1/128
        </Directory>

</VirtualHost>

Ora la configurazione è terminata, dobbiamo abilitare come di consueto il virtual host:

sudo a2ensite default-ssl.conf

Infine riavviamo il servizio per rendere effettive le modifiche:

sudo service apache2 restart

Ora, sincerandosi che il firewall della nostra connessione consenta il traffico sulla porta 443, puntiamo sull’ip del server, o sul dominio impostato nel virtualhost, ad esempio https://123.123.123.123.
Comparirà un avviso che ci avverte che il certificato non è attendibile, questo è normale in quanto lo abbiamo autogenerato e non acquistato da un ente certificatore. Basterà procedere “accettando i rischi” per navigare in maniera sicura. Naturalmente, per siti o app pubbliche, è vivamente consigliato l’acquisto di un certificato verificato per non “spaventare” l’utente con questo avviso.

L'articolo Sicurezza: abilitare HTTPS in Apache2 su Ubuntu server sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.