Un'introduzione ai modelli di progettazione in PHP

Pubblicato: 2020-04-14

I modelli di progettazione PHP si sono dimostrati estremamente utili per gli sviluppatori ed è un importante risolutore di problemi. Per scrivere codice efficiente, gli sviluppatori devono seguire le migliori pratiche. PHP Design pattern è un concetto di programmazione orientata agli oggetti (OOP) che ora viene utilizzato anche nei progetti Drupal 8. Con Drupal 8 che adotta i moderni concetti PHP e OOP, i modelli di progettazione possono essere sfruttati per una programmazione più pulita e robusta.

Modelli di progettazione in PHP

Cosa sono i Design Pattern in PHP?

Nell'ingegneria del software, un modello di progettazione è una soluzione generale ripetibile a problemi che si verificano comunemente nella progettazione del software. I buoni progetti orientati agli oggetti dovrebbero essere riutilizzabili, manutenibili ed estensibili e i modelli di progettazione in PHP potrebbero essere molto utili per farlo. Non solo aiuta a risolvere i problemi, ma implica un modo ottimale per affrontare le sfide comuni.

Vantaggi dell'utilizzo di PHP Design Patterns

I principali vantaggi dei modelli di progettazione in PHP sono:

  • I modelli di PHP Design aiutano a risolvere i problemi ripetitivi affrontati durante lo sviluppo
  • L'utilizzo di modelli di progettazione in PHP rende la comunicazione più efficiente tra i progettisti
  • Gli altri sviluppatori che guardano il tuo codice non dovranno faticare a capire poiché il codice è ben strutturato con modelli di progettazione
  • Seguire le migliori pratiche aiuta a creare un software più robusto
  • Aiuta a rendere lo sviluppo più veloce e più facile

Modelli di progettazione ampiamente utilizzati in PHP

I Design Pattern possono essere utilizzati in varie situazioni per risolvere problemi simili. Esistono circa 23 modelli di design che possono essere ampiamente classificati in tre tipi di modelli di design: modelli creazionali, strutturali e comportamentali.

Modelli Creativi: Modelli di progettazione utilizzati nei meccanismi di creazione degli oggetti, per creare oggetti che possono essere disaccoppiati dal sistema che li ha implementati.

Schemi strutturali: facilita la progettazione identificando modi semplici per realizzare relazioni tra entità

Modelli comportamentali: sono utilizzati per gestire relazioni, responsabilità e algoritmi tra oggetti

Modello di fabbrica

Un modello di fabbrica viene utilizzato per costruire un oggetto. Esatto: costruisci un oggetto e non crea un oggetto. Quando costruiamo l'oggetto, prima lo creiamo e poi lo inizializziamo. Di solito, è necessario applicare una certa logica ed eseguire più passaggi. Con ciò, ha senso avere tutto ciò in un unico posto e riutilizzarlo ogni volta che è necessario creare un nuovo oggetto allo stesso modo. Fondamentalmente, questo è l'uso del modello di fabbrica.
È un'ottima idea avere un'interfaccia per la nostra fabbrica e fare in modo che il nostro codice faccia affidamento su di essa e non su una fabbrica di cemento 

 interfaccia FamilyFactoryInterface {
    pubblico funzione create () : Famiglia
}

Quindi, implementa l'interfaccia di fabbrica con la seguente classe:

classe FamigliaFabbrica attrezzi FamilyFactoryInterface {

pubblico funzione create () : Famiglia {

$famiglia = nuova famiglia();

// inizializza la tua famiglia

restituire $famiglia;

}

}

Modello adattatore

In Adapter Design Pattern, una classe trasforma l'interfaccia di una classe ad un'altra class.In questo esempio abbiamo una classe libro di testo che ha un metodo getTitle () e getAuthor (). Il client si aspetta un metodo getTitleAndAuthor(). Per "adattare" SimpleBook per demoAdapter abbiamo una classe adattatore, BookAdapter , che accetta un'istanza di TextBook e utilizza i metodi TextBook getTitle() e getAuthor() nel proprio metodo getTitleAndAuthor.

<?php

classe Libro di testo {

$titolo privato ;
$autore privato ;
funzione __costrutto ($titolo_in, $autore_in) {
$questo ->titolo = $titolo_in;

$questo ->autore = $autore_in;
}

funzione getTitolo () {
Restituzione $questo ->titolo;
}
funzione getAuthor () {
Restituzione $questo ->autore;
}
}

classe BookAdapter {
$libro privato ;
funzione __construct (Libro di testo $libro_in) {
$questo ->libro = $libro_in;
}
funzione getTitleAndAuthors () {
Restituzione $this ->book->getTitle(). 'da' . $this ->book->getAuthor();
}
}

// cliente

writeln( ' INIZIA IL TEST DEL MODELLO DELL'ADATTATORE ' );
writeln( '' );

$book = new TextBook( "Gamma, Helm, Johnson e Vlissides" , "Design Patterns" );
$bookAdapter = new BookAdapter($libro);
writeln( 'Autore e Titolo: ' .$bookAdapter->getTitleAndAuthor());
writeln( '' );

writeln( ' TERMINA IL MODELLO DELL'ADATTATORE DI PROVA' );

funzione writeln ($line_in) {
echo $line_in. "<br/>" ;
}

?>

Pattern PHP Singleton

Per limitare l'istanziazione di una classe a un singolo oggetto, viene utilizzato un pattern singleton in PHP. Questo può essere utile quando è necessario un solo oggetto nel sistema. Ha senso consentire l'accesso a una sola istanza di una determinata classe durante la progettazione di applicazioni web. Per impedire la creazione esplicita di oggetti dalla classe pattern Singleton, viene utilizzato un costruttore privato.

<?php
classe Singleton
{
pubblico statico funzione getInstance ()
{
statico $istanza = nullo ;
if ( null === $istanza) {
$istanza = nuovo statico ();
}
restituisce $istanza;
}
protetto funzione __costruire ()
{
}
privato funzione __clone ()
{
}
privato funzione __sveglia ()
{
}
}
classe SingletonBambino si estende Singleton
{
}
$obj = Singleton::getInstance();
var_dump($obj === Singleton::getInstance());
$obj2 = SingletonChild::getInstance();
var_dump($obj2 === Singleton::getInstance());
var_dump($obj2 === SingletonChild::getInstance());
?>

Modello osservatore in PHP

Il pattern PHP Observer viene utilizzato per avvisare il resto del sistema di particolari eventi in determinati luoghi.
Ad esempio, se abbiamo bisogno di creare un teatro per mostrare i film ai critici. Definiamo la classe Theater con il metodo corrente. Prima di presentare il film, vogliamo inviare messaggi ai cellulari della critica. Quindi, nel mezzo del film vogliamo fermare il film per 5 minuti per lasciare che i critici abbiano un intervallo. Infine, dopo la fine del film, chiediamo ai critici di lasciare la loro risposta. Quindi, nel pattern osservatore per PHP, l'oggetto osservatore riceve una notifica solo quando lo stato viene modificato.

Ecco come appare il codice -

classe teatro {

pubblico funzione corrente (film $ film): void {

$critics = $movie->getCritics();
$this ->message->send($critics, '...' );

$film->play();

$film->pausa( 5 );
$this ->progress->interval($critics)
$film->fine();

$this ->response->request($critics);
}
}

Motivo decorativo per PHP

Il pattern Decorator viene utilizzato quando si desidera modificare il carattere di un oggetto in fase di esecuzione e, con ciò, ridurre le eredità non necessarie e il numero di classi. Bene, può essere spiegato con esempi. Diciamo che abbiamo le classi Sofa e Bed, ed entrambe implementano SleeperInterface.

interfaccia SleeprInterface {
pubblico funzione dormi () : vuoto;
}
classe Divano attrezzi Interfaccia dormiente {
pubblico funzione dormire (): vuoto {
// dorme sul divano
}
}
classe Letto attrezzi Interfaccia dormiente {
pubblico funzione dormire (): vuoto {
// dorme sul letto
}
}

Sia i divani che i letti hanno lo stesso comportamento per dormire. Ora abbiamo bisogno di altri divani e letti con funzionalità aggiuntive che comunichino agli utenti il ​​monitoraggio del sonno quando dormono sui divani o sui letti. Con l'ereditarietà possiamo risolvere questo problema proprio in questo modo:

classe SmartSofa si estende Divano {
funzione pubblica sleep() : void {
genitore::sonno();
$ questo ->ore di sonno();
}
}
classe SmartBed si estende finestra {
funzione pubblica sleep() : void {
genitore::sonno();
$ questo ->ore di sonno();
}
}

Ora abbiamo 4 classi in totale. Tuttavia, potremmo risolvere questo problema con 3 classi solo con il motivo Decorator. Ecco come:

classe SmartSleeper attrezzi Interfaccia dormiente {

$dormiente privato ;
pubblico funzione __construct (SleeperInterface $dormiente) {
$questo ->dormiente = $dormiente;
}

pubblico funzione dormire (): vuoto {
$this ->dormiente->dormire();
$questo ->ore di sonno();
}
}
$divano = nuovo Divano();
$letto = nuovo letto();
$smartSofa = new SmartSleeper($divano);
$smartBed = nuovo SmartSleeper($letto);

Qui abbiamo introdotto un nuovo tipo di dormiente che si comporta come un proxy ma con una funzionalità extra.

Sfruttare i modelli di progettazione in Drupal 8

Mentre ci sono molti modelli di design già stabiliti all'interno di Drupal prima di Drupal 8, Drupal 8 ora consiste in molti modelli che in precedenza non erano disponibili. Alcuni di questi nuovi modelli sostituiscono completamente alcuni vecchi, mentre altri introducono alcune nuove funzionalità in Drupal 8.

I modelli di progettazione utilizzati in Drupal 8 includono:

  • Pattern di programmazione orientato agli oggetti (OOP)
  • Iniezioni di dipendenza
  • Modello di fabbrica
  • Modello singolo

OOP non è realmente un singolo modello, ma un modo completamente radicale di concettualizzare e strutturare i codici che va ben oltre i semplici modelli di progettazione. È la base per molti modelli di progettazione software popolari in uso oggi, inclusi quelli utilizzati in Drupal 8. È stato introdotto in Drupal 7, ma non è stato utilizzato ampiamente e non è stato richiesto. La situazione in Drupal 8 ora è diversa, è ampiamente utilizzata ed è necessaria.

Iniezione di dipendenza

L'iniezione di dipendenza è quel modello di progettazione del software che ti consentirebbe di rimuovere le dipendenze hardcoded e renderebbe anche possibile modificarle in fase di esecuzione o in fase di compilazione. L'aggiunta dell'iniezione di dipendenza è facile e non interferisce con il codice esistente. Drupal 8 ha introdotto il concetto di servizi al fine di disaccoppiare le funzionalità riutilizzabili. core.services.yml è un esempio per l'iniezione di dipendenza in Drupal 8. Abbiamo già discusso su Factory Pattern e Singleton Pattern in PHP sopra