Gestione dei pacchetti in Laravel

In questo articolo, andremo avanti ed esploreremo la funzione di gestione dei pacchetti nel framework di Laravel. Nel corso dell'articolo, passeremo attraverso un esempio del mondo reale per dimostrare lo scopo dell'articolo.

La gestione dei pacchetti in Laravel è una funzionalità importante che consente di raggruppare una funzionalità in modo che possa essere facilmente distribuita. Inoltre, puoi sempre pubblicare il tuo pacchetto in repository come Packagist e GitHub che consentono ad altri sviluppatori di trarre vantaggio dal tuo pacchetto.

Per dimostrare il concetto, costruiremo una pagina di esempio in Laravel che carica un'immagine sul cloud Amazon S3. Piuttosto che seguire il solito flusso, lo svilupperemo come pacchetto in bundle che può essere distribuito e gestito facilmente.

Prima di andare avanti, presumo che tu abbia già familiarità con il framework di Laravel dato che non entrerò nei dettagli dei concetti base di Laravel.

Inoltre, devi avere un account AWS valido e le credenziali per accedere all'API di Amazon per seguire l'esempio in questo articolo. Quindi, assicurati di averlo impostato prima.

Con tutto a portata di mano, siamo pronti a tuffarci nello sviluppo reale.

Impostazione dei file del pacchetto

Diamo un'occhiata rapida all'elenco dei file che implementeremo nel corso di questo tutorial.

composer.json: Abbiamo bisogno di aggiungere la mappatura di classe del nostro pacchetto nel esistente composer.json file nella radice del pacchetto.
config / app.php: Questo è il file esistente che utilizzeremo per aggiungere una voce del nostro fornitore di servizi personalizzati in modo che possiamo caricare viste e percorsi utilizzando quel file.
composer.json: Questo è il pacchetto specifico composer.json file se desideri distribuire il pacchetto con altri.
pacchetti / Envato / AWS / src / fornitori / AwsServiceProvider.php: Il solito file del provider di servizi Laravel che verrà utilizzato per caricare altri componenti del pacchetto.
pacchetti / Envato / AWS / src / percorsi / web.php: Carica i percorsi personalizzati del nostro pacchetto.
pacchetti / Envato / AWS / src / Controller / AwsController.php: Questo è il file del controller che gestisce la logica dell'applicazione del nostro pacchetto.
pacchetti / Envato / AWS / src / views / upload.blade.php: Il file di visualizzazione che gestisce la logica di rendering.

Non preoccuparti se non ha ancora molto senso, tratteremo ogni cosa in dettaglio mentre la attraversiamo.

Impostazione dei prerequisiti

Come abbiamo discusso in precedenza, il nostro pacchetto implementa il caso di utilizzo del caricamento di file su cloud Amazon S3. In questa sezione, esamineremo i prerequisiti che devono essere impostati per poter eseguire correttamente il nostro pacchetto.

Come sviluppatore Laravel, devi avere familiarità con Flysystem, che fornisce un bel livello di astrazione per interagire con il filesystem. Fornisce driver di facile utilizzo in modo da poter interagire facilmente con esso indipendentemente dal tipo di file system con cui si ha a che fare: il file system locale o il sistema cloud AWS S3.

Per abilitare il supporto del filesystem cloud Amazon S3 con Flysystem, è necessario installare il pacchetto dell'adattatore di composizione dell'adattatore corrispondente.

Vai avanti ed esegui il seguente comando compositore dalla root del progetto per installare il pacchetto flysystem-aws-s3-v3.

$ compositore richiede league / flysystem-aws-s3-v3

Dopo aver eseguito con successo questo comando, ora puoi utilizzare Laravel Flysystem per interagire con il sistema di file cloud Amazon S3 nello stesso modo in cui lo avresti usato per il file system locale.

Ora, inseriamo rapidamente il config / filesystems.php file per vedere le impostazioni fornite per il filesystem Amazon S3.

... 'disks' => ['local' => ['driver' => 'local', 'root' => percorso_destinazione ('app'),], 'pubblico' => ['driver' => 'locale' , 'root' => percorso_destinazione ('app / pubblico'), 'url' => env ('APP_URL'). '/ storage', 'visibility' => 'public',], 's3' => [' driver '=>' s3 ',' chiave '=> env (' AWS_KEY '),' secret '=> env (' AWS_SECRET '),' region '=> env (' AWS_REGION '),' bucket '=> env ('AWS_BUCKET'),],], ...

Come puoi vedere, la configurazione è già attiva per Amazon S3; è solo che abbiamo bisogno di impostare appropriato ENV variabili nel .ENV file.

Vai avanti e aggiungi le seguenti variabili nel tuo .ENV file.

AWS_KEY = AWS_KEY_VALUE AWS_SECRET = AWS_SECRET_VALUE AWS_REGION = AWS_REGION_VALUE AWS_BUCKET = AWS_BUCKET_VALUE AWS_CDN_URL = AWS_CDN_URL_VALUE

Ovviamente, è necessario sostituire i segnaposto con i loro valori effettivi. Ora sei pronto per utilizzare l'adattatore Flysystem AWS S3 nell'applicazione Laravel.

Passando attraverso i file del pacchetto

Per creare il tuo pacchetto Laravel, la prima cosa è creare una struttura di directory appropriata che rifletta le convenzioni del sistema Laravel. Suppongo che tu stia già utilizzando un'applicazione Laravel di base; in effetti, il valore predefinito blog l'applicazione farà altrettanto.

Vai avanti e crea il pacchi directory nella radice della tua applicazione. Considerando che distribuirai il tuo pacchetto con altri, dovrebbe essere la struttura preferita del tuo pacchetto VENDOR_NAME / package_name.

Seguendo questa convenzione, andiamo avanti e creiamo un Envato / AWS directory sotto il pacchi directory. Come avrai intuito, Envato è il nome del fornitore e aws sta per il nome del pacchetto stesso. Infine, creiamo un Pacchetti / Envato / aws / src directory che contiene i file sorgente del nostro pacchetto.

Ora, dobbiamo informare Laravel del nostro nuovo pacchetto. Vai avanti e apri il composer.json file nella radice della tua applicazione Laravel e aggiungi il "Envato \\ Aws \\": "pacchetti / envato / aws / src" voce nella sezione autoload come mostrato di seguito.

... "autoload": "classmap": ["database"], "psr-4": "App \\": "app /", "Envato \\ Aws \\": "pacchetti / envato / aws / src ", ...

Come puoi vedere, il Envato \ Aws \ lo spazio dei nomi è mappato al Pacchetti / Envato / aws / src directory. Ora, abbiamo solo bisogno di eseguire il comando dump-autoload per rigenerare i mapping del compositore.

$ composer dump-autoload

Ora puoi usare il Envato \ Aws \ spazio dei nomi nella tua applicazione e raccoglierà i file dalla posizione corretta!

Compositore File del pacchetto

Ora, andiamo avanti e aggiungiamo un pacchetto specifico composer.json file in modo da poter distribuire il pacchetto nel repository di packagist.

Vai al pacchetti / Envato / AWS directory ed eseguire il seguente comando per generare un file composer.json file per il tuo pacchetto.

$ compositore init

Ti verrà chiesto con le solite domande, quindi basta esaminarlo e creerà un composer.json file.

Per lo meno, dovrebbe assomigliare a questo.

"nome": "envato / aws", "descrizione": "Esempio di caricamento file su AWS S3 Cloud", "stabilità minima": "dev", "require":

Itinerario

Nel nostro pacchetto, creeremo una semplice pagina che mostra lo stato del file caricato. Quindi abbiamo bisogno di creare un percorso associato a quella pagina.

Creiamo un file di percorso a pacchetti / Envato / AWS / src / percorsi / web.php.

Richiede alcuna spiegazione? Il prossimo passo ovvio è creare il file controller associato.

controllore

Creiamo un file di controller su pacchetti / Envato / AWS / src / Controller / AwsController.php con i seguenti contenuti.

disk ( 's3'); // carica memoria locale $ localStorage = $ storage-> disk ('local'); // percorso predefinito della memoria locale "storage / app" $ sourceFileContents = $ localStorage-> get ('test.jpg'); // percorso file di destinazione nel cloud S3 $ destFilePath = 'test_new.jpg'; // init vars $ imageUrl = "; $ errorMsg ="; // carica il file in AWS S3 se ($ awsS3Storage-> put ($ destFilePath, $ sourceFileContents, 'public')) $ imageUrl = env ('AWS_CDN_URL'). env ('AWS_BUCKET'). '/'. $ Destfilepath;  else $ errorMsg = 'Oops! Qualcosa è andato storto :( '; // call view return view (' aws :: upload ', [' imageUrl '=> $ imageUrl,' errorMsg '=> $ errorMsg])

Analizziamo il file per capire per cosa è destinato ogni pezzo di codice.

Diamo il via alle cose impostando uno spazio dei nomi del nostro controller nello spazio dei nomi \ Aws \ Controller Envato. Ricordiamo che abbiamo aggiunto la mappatura di Envato \ Aws a Pacchetti / Envato / aws / src nella radice composer.json file in modo che possa trovare i nostri file del pacchetto.

Successivamente, abbiamo definito il caricare metodo che ha la necessità di sincronizzare i file locali con il cloud Amazon S3. La cosa importante da notare qui è il primo argomento del metodo di caricamento che richiede il \ Illuminare \ Contratti \ Filesystem \ fabbrica dipendenza. Durante l'esecuzione verrà iniettato il contratto Laravel appropriato.

Ora, potremmo usare l'istanza di fabbrica del filesystem per creare istanze del disco secondo necessità. L'istanza del disco in Laravel è il driver che consente un facile accesso ai file system sottostanti come il disco locale, il cloud Amazon S3 e simili.

// carica memoria s3 $ awsS3Storage = $ storage-> disk ('s3'); // carica memoria locale $ localStorage = $ storage-> disk ('local');

Per semplicità, trasferiremo il file immagine statico che è già disponibile nella memoria locale predefinita di Laravel e il percorso è stoccaggio / app / test.jpg.

Come primo passo, prendiamo il contenuto del file sorgente.

// percorso predefinito della memoria locale "storage / app" $ sourceFileContents = $ localStorage-> get ('test.jpg');

Con tutto configurato come accennato, dovresti essere in grado di sincronizzare un file su Amazon S3 usando il metodo put.

// carica il file in AWS S3 se ($ awsS3Storage-> put ($ destFilePath, $ sourceFileContents, 'public')) $ imageUrl = env ('AWS_CDN_URL'). env ('AWS_BUCKET'). '/'. $ Destfilepath;  else $ errorMsg = 'Oops! Qualcosa è andato storto :(';

Assicurati di aver impostato correttamente le variabili di ambiente AWS, nel caso in cui qualcosa non funzioni come previsto.

E l'ultima cosa è chiamare un file di visualizzazione che visualizza l'immagine sincronizzata e un messaggio appropriato.

// call view return view ('aws :: upload', ['imageUrl' => $ imageUrl, 'errorMsg' => $ errorMsg]);

Naturalmente, non abbiamo ancora creato un file di visualizzazione, ed è esattamente ciò che riguarda la prossima sezione.

vista

Creiamo un file di visualizzazione su pacchetti / Envato / AWS / src / views / upload.blade.php con i seguenti contenuti.

      laravel        @if (Route :: has ('login')))  @if (Auth :: check ()) Home @else Accedi Register @endif 
 @finisci se   Caricamento file su S3 Cloud 
  @if ($ imageUrl)  @altro $ errorMsg @finisci se

Si tratta di un file di visualizzazione piuttosto standard che visualizza l'immagine caricata in seguito al corretto caricamento o, in caso contrario, a un messaggio di errore appropriato.

Fornitore di servizi

Abbiamo quasi finito con il nostro pacchetto dato che abbiamo creato i file necessari. Il passo successivo è creare un fornitore di servizi in modo che possiamo registrare i percorsi e le viste del nostro pacchetto.

Creiamo un file del fornitore di servizi su pacchetti / Envato / AWS / src / fornitori / AwsServiceProvider.php con i seguenti contenuti.

loadRoutesFrom (__ DIR __. '/ ... /routes/web.php'); // carica i file di visualizzazione $ this-> loadViewsFrom (__ DIR __. '/ ... / views', 'aws'); // pubblica i file $ this-> pubblica ([__DIR __. '/ ... / views' => resource_path ('views / vendor / aws'),]);  / ** * Registrare i servizi dell'applicazione. * * @return void * / public function register ()

Ovviamente, potresti aver creato il file del fornitore di servizi usando anche il comando artisan. Ma avrebbe richiesto un ulteriore passaggio per spostare il file da app / fornitori al nostro pacchetto.

Ad ogni modo, passiamo al file del fornitore di servizi che è stato appena creato.

Innanzitutto, cariciamo le rotte e le viste associate al nostro pacchetto.

// carica percorsi $ this-> loadRoutesFrom (__ DIR __. '/ ... /routes/web.php'); // carica i file di visualizzazione $ this-> loadViewsFrom (__ DIR __. '/ ... / views', 'aws');

Successivamente, forniamo il supporto per la pubblicazione delle viste dei nostri pacchetti in modo che gli sviluppatori che desiderano eseguire l'override delle viste possano farlo. La prossima volta eseguiranno il php artisan vendor: pubblicare comando, Laravel copia le viste da pacchetti / Envato / AWS / src / views / a Resources / views / fornitore / AWS.

Ora, possono modificare le viste sotto il Resources / views / fornitore / AWS directory, e verrà prelevato automaticamente da Laravel invece delle viste sotto pacchetti / Envato / AWS / src / views /. In effetti, è il modo corretto di modificare le viste del pacchetto di terze parti, invece di modificare direttamente le viste del pacchetto.

È tutto ciò che riguarda il fornitore di servizi. Come previsto, è necessario aggiungere la voce del fornitore di servizi in config / app.php. Aggiungi la seguente voce nel fornitori schieramento.

... / * * Application Service Provider ... * / App \ Provider \ AppServiceProvider :: classe, App \ Provider \ AuthServiceProvider :: classe, App \ Provider \ BroadcastServiceProvider :: classe, App \ Provider \ EventServiceProvider :: classe, App \ Provider \ RouteServiceProvider :: class, Envato \ Aws \ Providers \ AwsServiceProvider :: class, // Il nostro fornitore di servizi di pacchetti ...

Ed eccoti - adesso tutto è in ordine, in modo che possiamo andare avanti e testare il nostro pacchetto.

Vai avanti e lancia l'URL http: // your-laravel-application / aws / s3 / upload nel tuo browser. Se tutto va bene, dovresti vedere l'immagine sulla tua pagina caricata dal cloud Amazon S3. Per favore fatemi sapere se avete problemi, e sarei più che felice di rispondere a quelli.

Quindi siamo nella nota conclusiva di questo articolo, e spero che vi sia piaciuto!

Conclusione

Oggi abbiamo discusso di una delle caratteristiche importanti della gestione del pacchetto framework di Laravel. Nel processo di configurazione del nostro pacchetto Laravel personalizzato, abbiamo analizzato un esempio del mondo reale che dimostra come è possibile caricare un'immagine sul cloud Amazon S3.

È una funzionalità davvero interessante se desideri raggruppare e distribuire insieme un insieme di funzionalità. In effetti, puoi considerare questo come un'opzione per accedere allo sviluppo del tuo modulo personalizzato in Laravel.

Per quelli di voi che stanno appena iniziando con Laravel o stanno cercando di espandere le vostre conoscenze, il vostro sito o la vostra applicazione con le estensioni, abbiamo una varietà di cose che potete studiare su Envato Market.

Come sempre, puoi lasciare i tuoi preziosi commenti e feedback nel feed sottostante!

Codice