Share
I modelli di progettazione del software sono meglio definiti nelle parole di Martin Fowler:
I pattern forniscono un meccanismo per il rendering dei consigli di progettazione in un formato di riferimento. Il design del software è un argomento enorme e, di fronte a un problema di progettazione, devi essere in grado di concentrarti su qualcosa il più vicino possibile al problema che puoi ottenere.
Il codice che impiega modelli di progettazione è facile da capire, mantenere ed estendere. Lo scopo di questo tutorial è promuovere la facciata di Laravel.
Secondo la definizione di Gang of Four, il facciata il modello di progettazione è un modello strutturale che definisce un'interfaccia semplificata per un sottosistema più complesso. Il modello si basa sulla creazione di una semplice interfaccia di facciata di fronte alla raccolta di logica e metodi richiesti. La facciata stessa mantiene le dipendenze.
La facciata è molto simile al adattatore e decoratore modelli. L'adattatore agisce come un ponte tra due interfacce che non sono compatibili, mentre il decoratore è più complesso e utilizzato per cambiare dinamicamente il modo in cui gli oggetti si comportano.
La sintassi dolce, che usa Laravel, rende la scrittura del codice più pulita e più facile da capire. Le facciate di Laravel sono in realtà lo zucchero sintattico per la posizione del servizio.
Diamo un'occhiata a Laravel Facade e al suo funzionamento. Il nascondiglio facciata in Laravel assomiglia a questo:
php Cache :: get ('chiave'); Sebbene possa sembrare che stia utilizzando un carico di metodi statici, Laravel fornisce effettivamente un'interfaccia alle classi disponibili nel contenitore di servizi dell'applicazione. Come probabilmente già saprai, il codice sopra scritto è equivalente a:
php $ app = app (); $ App-> rendere ( 'cache') -> get ( 'chiave');
La facciata di Laravel localizza oggetti in vendor / laravel / quadro / src / Illuminate / Supporto / Facciate mentre la facciata Cache è posizionata Cache.php:
namespace php Illuminate \ Support \ Facades; class Cache extends Facade / ** * Ottieni il nome registrato del componente. * * @return string * / protected static function getFacadeAccessor () return 'cache';
Quando usiamo Cache :: get ( 'chiave') stiamo, infatti, chiamando la classe di cui sopra. Assicurati di creare l'alias della classe sopra menzionata nel file di configurazione config / app.php:
php 'aliases' => [// ... 'Cache' => Illumina \ Support \ Facades \ Cache :: class,
Gli alias vengono impostati automaticamente dal caricatore automatico di Laravel. L'impostazione del nome della classe nella cache crea coerenza con la facciata. Questa opzione renderà sicuramente più le persone che usano le facciate più comode con il tuo codice.
I seguenti tre metodi sono cruciali per la generazione di una facciata:
Accentsconagua
getFacadeAccessor metodo nella classe figlio.resolveFacadeInstance il metodo è responsabile della risoluzione dell'istanza corretta del servizio.L'implementazione dei metodi delle classi di facciata:
"php // ... public static function __callStatic ($ method, $ args) $ instance = static :: getFacadeRoot (); switch (count ($ args)) caso 0: return $ instance -> $ method ();
caso 1: restituire $ istanza -> $ metodo ($ args [0]); caso 2: restituisce $ istanza -> $ metodo ($ args [0], $ args [1]); caso 3: restituire $ istanza -> $ metodo ($ args [0], $ args [1], $ args [2]); caso 4: restituire $ istanza -> $ metodo ($ args [0], $ args [1], $ args [2], $ args [3]); default: return call_user_func_array (array ($ istanza, $ metodo), $ args); "
__callStatic in pratica chiama il contenitore IoC per legarsi alla classe. Chiama anche il suo metodo (non statico) usando l'interruttore caso tramite il PHP call_user_func_array () funzione, passando la matrice dei parametri all'oggetto che restituisce getFacadeRoot () metodo. Il getFacadeRoot () il metodo è mostrato come segue:
php public static function getFacadeRoot () return static :: resolveFacadeInstance (static :: getFacadeAccessor ());
E il resolveFacadeInstance ():
"funzione statica protetta da php resolveFacadeInstance ($ name) if (is_object ($ name)) restituisce $ name;
if (isset (static :: $ resolvedInstance [$ name])) return static :: $ resolvedInstance [$ name]; return static :: $ resolvedInstance [$ name] = static :: $ app [$ name]; "
Come presentato nell'ultima riga dell'articolo, nel resolveFacadeInstance metodo, Laravel restituisce l'istanza del localizzatore di servizio. Poiché il localizzatore è una pura istanza della classe originale, concludiamo che la facciata di Laravel non corrisponde alla definizione del modello di facciata di GoF. Quelli sono solo luoghi di servizio. A differenza della facciata di Laravel, la Real Facade rende i test delle unità di scrittura difficili e talvolta persino impossibili, a causa della creazione di dipendenze hard-coded.
Per coloro che credono che DI via costruttore è un'opzione migliore rispetto all'utilizzo di facciata Laravel, vorrei informarvi che potrebbe essere inclusa qualche configurazione aggiuntiva.
Voglio creare un file di controllo Laravel Facade che è responsabile per verificare se il file di input è un pdf o meno. Per fare questo, prima di tutto dobbiamo creare un È Pdf Classe in App / MyFacade / IsPdf.php:
"php namespace App \ MyFacade;
class IsPdf private $ pdf = "\ x25 \ x50 \ x44 \ x46 \ x2D";
controllo di funzione pubblica ($ file) return (file_get_contents ($ file, false, null, 0, strlen ($ this-> pdf)) === $ this-> pdf)? vero falso; "
In secondo luogo, associare la classe al fornitore di servizi. Creerai il nuovo fornitore di servizi, che si troverà in App \ Providers \ IsPdfServiceProvider:
"App / Provider dello spazio dei nomi php;
usa Illuminate \ Support \ Facades \ App; utilizzare Illuminate \ Support \ ServiceProvider;
classe IsPdfServiceProvider estende ServiceProvider / ** * Bootstrap dei servizi dell'applicazione. * * @return void * / public function boot () //
/ ** * Registrare i servizi dell'applicazione. * * @return void * / public function register () App :: bind ('IsPdf', function () return new \ App \ MyFacade \ IsPdf;); "
In terzo luogo, crea la classe Facade, come estensione della classe menzionata in precedenza Illuminare \ Support \ Facciate \ Facciata . Creerai la classe in cui si troverà App \ Facciate \ IsPdfFacade.php.
"php namespace App \ Facades; utilizzare Illuminate \ Support \ Facades \ Facade;
la classe IsPdf estende la funzione protected static function getFacadeAccessor () return 'IsPdf'; "L'ultimo passo è registrare la facciata in config / app.php:
"php / * * Provider di servizi applicativi ... * / App \ Provider \ IsPdfServiceProvider :: class,
"
E lo pseudonimo:
php 'IsPdf' => App \ Facades \ IsPdf :: class
Congratulazioni! Hai creato con successo una facciata Laravel. Sentiti libero di testare la facciata usando alcuni codici, come:
php Route :: get ('/', function () IsPdf :: check ('/ files / file.pdf'););
Ora sappiamo che la facciata di Laravel rende super facile chiamare i metodi, e l'iniezione delle dipendenze reali potrebbe davvero ripagare la linea. Ovviamente Laravel Facade ha i suoi vantaggi e svantaggi. Dipende dallo sviluppatore per selezionare l'opzione giusta.
Per ulteriori risorse con Laravel, assicurati di controllare l'offerta sul mercato.
Chissà, forse questo articolo ti incoraggerà a sviluppare il codice agnostico del framework e dimenticarti di usare le facciate! In bocca al lupo!
