Pakethantering i Laravel

I den här artikeln kommer vi att fortsätta och utforska pakethanteringsfunktionen i Laravel-ramverket. Under artikelns gång går vi igenom ett verkligt exempel för att visa artikelns syfte.

Pakethantering i Laravel är en viktig funktion som låter dig kombinera en del funktionalitet så att den enkelt kan distribueras. Dessutom kan du alltid publicera ditt paket till repositorier som Packagist och GitHub som tillåter andra utvecklare att dra nytta av ditt paket.

För att visa konceptet bygger vi en exempelsida i Laravel som laddar upp en bild till Amazon S3-molnet. I stället för att gå med det vanliga flödet utvecklar vi det som ett buntpaket som enkelt kan distribueras och underhållas.

Innan jag går vidare antar jag att du är bekant med Laravel-ramverket redan då jag inte kommer att gå in i detaljerna i grundläggande Laravel-koncept.

Du måste också ha ett giltigt AWS-konto och referenser för att komma åt Amazon API för att följa med exemplet i den här artikeln. Så se till att du ställer upp det först.

Med allt till hands är vi redo att dyka in i den faktiska utvecklingen.

Ställa in paketfilerna

Låt oss snabbt titta på listan över filer som vi ska genomföra under hela handledningen.

composer.json: Vi måste lägga till klasskartläggning av vårt paket i befintliga composer.json filen i paketets rutt.
config / app.php: Det här är den befintliga filen som vi ska använda för att lägga till en inmatning från vår anpassade tjänsteleverantör så att vi kan ladda visningar och rutter med den filen.
composer.json: Det här är paketspecifik composer.json fil ska du vilja distribuera paketet med andra.
paket / Envato / AWS / src / leverantörer / AwsServiceProvider.php: Den vanliga Laravel-tjänsteleverantörsfilen som används för att ladda andra komponenter i paketet.
paket / Envato / AWS / src / rutter / web.php: Den laddar våra anpassade vägar till vårt paket.
paket / Envato / AWS / src / Controllers / AwsController.php: Det här är kontrollerfilen som hanterar programlogiken för vårt paket.
paket / Envato / AWS / src / views / upload.blade.php: Visningsfilen som hanterar reningslogiken.

Oroa dig inte om det inte ger stor mening ännu, eftersom vi kommer att diskutera allt i detalj när vi går igenom det.

Ställa in förutsättningarna

Som vi diskuterade tidigare implementerar vårt paket användningsfallet för filuppladdning till Amazon S3-molnet. I det här avsnittet går vi igenom de förutsättningar som måste ställas in för att kunna köra vårt paket framgångsrikt.

Som Laravel-utvecklare måste du vara bekant med Flysystem, som ger ett bra abstraktionslager för att interagera med filsystemet. Det ger lättanvända drivrutiner så att du enkelt kan interagera med det, oavsett vilken typ av filsystem du hanterar, antingen det är det lokala filsystemet eller AWS S3-systemet.

För att möjliggöra stöd för Amazon S3 Cloud File System med Flysystem, måste du installera motsvarande adapterkompositörspaket.

Fortsätt och kör följande komponentkommando från din projektrot för att installera flysystem-aws-s3-v3-paketet.

$ komponist kräver liga / flygsystem-aws-s3-v3

Efter det framgångsrika genomförandet av det här kommandot kan du nu använda Laravel Flysystem för att interagera med Amazon S3 Cloud File System på samma sätt som du skulle ha använt det för det lokala filsystemet.

Nu, låt oss snabbt dra i config / filesystems.php fil för att se inställningarna för Amazon S3-filsystemet.

... 'diskar' => ['local' => ['driver' => 'lokal', 'root' => storage_path ('app'),], 'public' => , 'root' = 'storage_path', 'url' => env ('APP_URL'). '/ storage', 'visibility' => 'public',], 's3' => drivrutin '=>' s3 ',' key '=> env (' AWS_KEY '),' hemlig '=> env (' AWS_SECRET '),' region '=> env (' AWS_REGION '),' bucket '=> env ('AWS_BUCKET'),],], ...

Som du kan se är konfigurationen redan på plats för Amazon S3; Det är bara att vi behöver ange lämpliga ENV variabler i .env fil.

Fortsätt och lägg till följande variabler i din .env fil.

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

Naturligtvis måste du ersätta platsinnehavare med deras faktiska värden. Nu är du redo att använda Flysystem AWS S3-adaptern i din Laravel-applikation.

Går igenom paketfilerna

För att skapa ditt eget Laravel-paket är det första att skapa en lämplig katalogstruktur som återspeglar Laravel-systemets konventioner. Jag antar att du redan kör en grundläggande Laravel-applikation; i själva verket standard blog ansökan kommer också att göras.

Gå vidare och skapa paket katalog i roten till din ansökan. Med tanke på att du ska distribuera ditt paket med andra, bör den önskade strukturen i ditt paket vara VENDOR_NAME / paket.

Efter den konventionen, låt oss gå vidare och skapa en Envato / AWS katalog under paket katalogen. Som du kanske har gissat, Envato är leverantörens namn och AWS står för själva paketets namn. Slutligen, låt oss skapa en paket / Envato / AWS / src katalog som innehåller källfilerna i vårt paket.

Nu måste vi informera Laravel om vårt nya paket. Gå vidare och öppna composer.json fil i roten till din Laravel-ansökan och lägg till "Envato \\ Aws \\": "paket / envato / aws / src" inmatning i autoload-sektionen som visas nedan.

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

Som du kan se, är Envato \ Aws \ namespace är mappad till paket / Envato / AWS / src katalogen. Nu behöver vi bara springa kommandot dump-autoload för att regenerera kompositorns mappings.

$ komponent dump-autoload

Nu kan du använda Envato \ Aws \ namnrymden i din ansökan och det hämtar filerna från rätt plats!

Komponistfilen av paketet

Nu, låt oss fortsätta och lägga till en paketspecifik composer.json fil så att du kan distribuera ditt paket till förpackningsförteckningen.

Gå till paket / Envato / aws katalog och kör följande kommando för att generera en composer.json filen för ditt paket.

$ composer init

Du blir tillfrågad med vanliga frågor, så gå bara igenom det och det kommer att skapa en composer.json fil.

Åtminstone bör det se ut så här.

"name": "envato / aws", "description": "Exempel på filuppladdning till AWS S3 Cloud", "minimumstabilitet": "dev", "require":

Rutt

I vårt paket skapar vi en enkel sida som visar status för den uppladdade filen. Så vi behöver skapa en rutt som är associerad med den sidan.

Låt oss skapa en färdfil på paket / Envato / AWS / src / rutter / web.php.

Behöver det någon förklaring alls? Det uppenbara nästa steget är att skapa den associerade registerfilen.

Kontrollant

Låt oss skapa en kontrollerfil på paket / Envato / AWS / src / Controllers / AwsController.php med följande innehåll.

skiva ( 's3'); // ladda lokal lagring $ localStorage = $ storage-> disk ('local'); // standardväg för lokal lagring "lagring / app" $ sourceFileContents = $ localStorage-> get ('test.jpg'); // destination filepath i S3 moln $ destFilePath = 'test_new.jpg'; // init vars $ imageUrl = "; $ errorMsg ="; // ladda upp filen till AWS S3 om ($ awsS3Storage-> put ($ destFilePath, $ sourceFileContents, "public")) $ imageUrl = env ('AWS_CDN_URL'). env ("AWS_BUCKET"). '/'. $ DestFilePath;  else $ errorMsg = 'Oops! Något gick fel :( '; // Call View Return View (' aws :: ladda upp ', [' imageUrl '=> $ imageUrl,' errorMsg '=> $ errorMsg]);

Låt oss gå igenom filen för att förstå vad varje kod är avsedd för.

Vi sparkar av sakerna genom att ställa in namnspalten hos vår controller till namespace Envato \ Aws \ Controllers. Minns att vi lagt till kartläggningen av Envato \ Aws till paket / Envato / AWS / src i roten composer.json filen så att den kunde hitta våra paketfiler.

Därefter har vi definierat ladda upp metod som gör det nödvändigt att synkronisera lokala filer till Amazon S3-molnet. Det viktiga att notera här är det första argumentet för uppladdningsmetoden som ber om \ Lys \ Kontrakt \ File \ Factory beroende. Under genomförandet injiceras lämplig Laravel-kontrakt.

Nu kan vi använda filsystemet fabriksinstans för att skapa diskinstanser efter behov. Skivexemplet i Laravel är drivrutinen som ger dig enkel åtkomst till underliggande filsystem som den lokala skivan, Amazon S3-molnet och liknande.

// ladda s3-lagring $ awsS3Storage = $ storage-> disk ('s3'); // ladda lokal lagring $ localStorage = $ storage-> disk ('local');

För enkelheten överför vi den statiska bildfilen som redan är tillgänglig under standard lokal lagring av Laravel, och sökvägen är lagring / app / test.jpg.

Som ett första steg, låt oss ta tag i källfilens innehåll.

// standardväg för lokal lagring "lagring / app" $ sourceFileContents = $ localStorage-> get ('test.jpg');

Med allt som anges, bör du kunna synkronisera en fil till Amazon S3 med hjälp av put-metoden.

// ladda upp filen till AWS S3 om ($ awsS3Storage-> put ($ destFilePath, $ sourceFileContents, "public")) $ imageUrl = env ('AWS_CDN_URL'). env ("AWS_BUCKET"). '/'. $ DestFilePath;  else $ errorMsg = 'Oops! Något gick fel :(';

Se till att du har ställt in AWS-miljövariablerna korrekt, om något inte fungerar som förväntat.

Och det sista är att ringa en vyfil som visar den synkroniserade bilden och ett lämpligt meddelande.

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

Självklart har vi inte skapat en visningsfil ännu, och det är precis vad nästa avsnitt handlar om.

Se

Låt oss skapa en visningsfil på paket / Envato / AWS / src / views / upload.blade.php med följande innehåll.

      laravel        @if (Rutt :: har ('inloggning'))  @if (Auth :: check ()) Hem @else Logga in Registrera @endif 
 @endif   Filuppladdning till S3 Cloud 
  @if ($ imageUrl)  @annan $ errorMsg @endif

Det är en ganska standard visning fil som visar den uppladdade bilden vid den framgångsrika uppladdningen, eller på annat sätt ett lämpligt felmeddelande.

Tjänsteleverantör

Vi är nästan färdiga med vårt paket som vi har skapat de nödvändiga filerna. Nästa steg är att skapa en tjänsteleverantör så att vi kan registrera rutorna och synpunkter på vårt paket.

Låt oss skapa en tjänsteleverantörsfil på paket / Envato / AWS / src / leverantörer / AwsServiceProvider.php med följande innehåll.

loadRoutesFrom (__ DIR __. '/ ... /routes/web.php'); // ladda visa filer $ this-> loadViewsFrom (__ DIR __. '/ ... / views', 'aws'); // publicera filer $ this-> publicerar ([__DIR __. '/ ... / views' => resource_path ('views / vendor / aws'),]);  / ** * Registrera applikationstjänsterna. * * @return void * / public function register ()

Självklart kan du ha skapat tjänsteleverantörsfilen genom att använda kommandot artisan också. Men det skulle ha krävt ett extra steg för att flytta filen från app / leverantörer till vårt paket.

Hur som helst, låt oss gå igenom tjänsteleverantörsfilen som just skapades.

För det första laddar vi de rutter och synpunkter som är förknippade med vårt paket.

// ladda rutter $ this-> loadRoutesFrom (__ DIR __. / / /routes/web.php '); // ladda visa filer $ this-> loadViewsFrom (__ DIR __. '/ ... / views', 'aws');

Därefter ger vi stöd för att publicera synpunkterna på våra paket så att de utvecklare som vill åsidosätta synpunkterna kan göra det. Nästa gång de kör php artisan leverantör: publicera kommando, kopierar Laravel synpunkterna från paket / Envato / AWS / src / views / till resurser / views / leverantör / AWS.

Nu kan de ändra visningarna under resurser / views / leverantör / AWS katalog, och det hämtas automatiskt av Laravel istället för synpunkterna under paket / Envato / AWS / src / views /. Det är faktiskt det rätta sättet att modifiera tredjepartspaketvyer, istället för att direkt ändra paketvyn.

Det är så långt som tjänsteleverantören berör. Som du skulle ha förväntat, måste vi lägga till tjänsteleverantörens post i config / app.php. Lägg till följande post i leverantörer array.

... / * * Applikationsleverantörer ... * / App \ Providers \ AppServiceProvider :: klass, App \ Providers \ AuthServiceProvider :: klass, App \ Providers \ BroadcastServiceProvider :: klass, App \ Providers \ EventServiceProvider :: klass, App \ Providers \ RouteServiceProvider :: klass, Envato \ Aws \ Providers \ AwsServiceProvider :: klass, // Vår paketleverantör ...

Och där är du - allt är i ordning nu, så att vi kan fortsätta och testa vårt paket.

Fortsätt och kör http: // din-laravel-ansökan / aws / s3 / uppladdningsadressen i din webbläsare. Om allt går bra bör du se bilden på din sida som laddas från Amazon S3-molnet. Vänligen meddela mig om du möter några problem, och jag skulle gärna svara på dem.

Så vi är på slutet av denna artikel, och jag hoppas att du har haft det!

Slutsats

Idag diskuterade vi en av de viktiga funktionerna i Laravel Framework-pakethantering. I processen med att skapa vårt anpassade Laravel-paket gick vi igenom ett verkligt exempel som visade hur du kan ladda upp en bild till Amazon S3-molnet.

Det är en riktigt bra funktion om du vill kombinera och distribuera en uppsättning funktioner alla tillsammans. Faktum är att du kan titta på detta som ett alternativ att närma sig din anpassade modulutveckling i Laravel.

För er som antingen bara börjar med Laravel eller vill utvidga din kunskap, webbplats eller ansökan med tillägg, har vi en mängd olika saker du kan studera på Envato Market.

Som alltid kan du lämna dina värdefulla kommentarer och feedback i foderet nedan!

Koda