Foto af Chandler Cruttenden på Unsplash

Sådan bygges modulopgaver i Laravel: Plug N Play-metoden - Del 2

I den første del af denne artikel om "hvordan man bygger modulopgaver i Laravel" diskuterede vi omfattende om moduler og fordelene ved at modulere dine applikationer. Du kan finde den del af denne artikel her "Sådan bygges modulopgaver i Laravel - Del 1".

I denne anden del vil vi gå lidt teknisk ind på at bruge moduler i Laravel. Så uden at spilde tid, lad os begynde fra hvor vi stoppede fra den første del. Skal vi?

Bemærk: Jeg vil gerne rådgive dig til at læse til slutningen af ​​denne artikel.

Oprettelse af migration i et modul

Migrationer er som versionskontrol til din database, så dit team let kan ændre og dele applikationens databaseskema. Overførsler er typisk parret med Laravels schema-builder for let at oprette din applikations databaseskema.

Oprettelse af migreringer til moduler er slet ikke anderledes. Hvis du vil oprette en migrering til et modul, skal du bruge modulet: make-migration Artisan-kommando:

php håndværksmodul: make-migration create_customers_table Kunder

Den nye migrering placeres i din mappe moduler / kunder / database / migration. Hvert migrationsfilnavn indeholder en tidsstempel ligesom standard Laravels migrering, der bestemmer rækkefølgen af ​​migrationerne.

Kundeindstillingen på kommandoen bruges til at indikere navnet på det modul, migreringen skal generere under. Du kan ændre navnet til ethvert modul, du genererer migration til.

Kører migrationer

Hvis du vil køre et enkelt udestående modul til migration, skal du udføre modulet: migrere Artisan-kommando:

php håndværksmodul: migrere kunder

Men hvad med at køre migrationer til alle dine moduler med en enkelt kommando? Nå, at vi er dækket som den sidste del af denne artikel.

Oprettelse af modeller til et modul

Vi ved alle, at Laravel som standard giver Eloquent ORM enkel ActiveRecord-implementering til at arbejde med din database. Hver databasetabel har en tilsvarende "Model", der bruges til at interagere med den tabel. Modeller giver dig mulighed for at forespørge om data i dine tabeller, samt indsætte nye poster i tabellen.

Dette er den samme tilgang, når man arbejder med moduler i Laravel.

Lad os oprette en veltalende model til vores modul for at komme i gang. Modeller lever typisk i app-biblioteket som standard, men når du bruger moduler, findes modeller i biblioteket Moduler / kunder / enheder. Alle modulets Eloquent-modeller udvider også Illuminate \ Database \ Eloquent \ Model-klassen.

Den nemmeste måde at oprette en modeleksempel til dit modul er at bruge modulet: make-model Artisan-kommando:

php håndværksmodul: fabrikant-kundekunder

Kundeindstillingen i ovennævnte kommando er navnet på modellen, mens indstillingen Kunder er navnet på modulet.

Hvis du gerne vil generere en databasemigration, når du genererer en model til dit modul, kan du bruge indstillingen -m:

php håndværksmodul: fabrikatmodel Kunde-m-kunder

Sørg for at følge Laravels standardkonvention, når du opretter modeller.

Kommunikation med forskellige modeller

Normalt, når du bruger Laravels standardmodel, er det let at referere til anden model; men når du bruger moduler er implementeringen anderledes.

Standard implementering

navneområde app;
Brug Illuminate \ Database \ Eloquent \ Model;
klasse Kunden udvider Model
{
    offentlig funktionstat ()
    {
     returner $ this-> hearTo ('App \ State', 'state_id');
    }
}

Fra ovenstående kode kan du se, at det er let at henvise til anden model fra en bestemt model ved hjælp af appens navneområde. Lad os nu se, hvordan vi implementerer dette på en modulopbygget måde.

Modulær implementering

navneområde app;
Brug Illuminate \ Database \ Eloquent \ Model;
brug moduler \ Kunder \ Enheder \ Stat;
klasse Kunden udvider Model
{
    offentlig funktionstat ()
    {
        returner $ dette-> hører til (Stat :: klasse, 'tilstand_id');
    }
}

Kan du se forskellen? I ovenstående eksempel er tilstandsmodellen placeret i kundemodulet. Så for at bruge tilstandsklassen i standard Laravel-modellen, må vi henvise den til det modul, den hører til, og biblioteket som vist ovenfor.

Men når du er i et modulsmodel og ønsker at henvise til en standardmodelklasse som Brugermodel, skal eksemplet herunder guide dig:

navneområde Moduler \ Krav \ Enheder;
Brug Illuminate \ Database \ Eloquent \ Model;
klasse Kunden udvider Model
{
    beskyttet $ fillable = [];
    offentlig funktionsprofil ()
    {
     returner $ this-> hearTo ('App \ User', 'insurance_company_id');
    }
}

Fra ovenstående eksempel kan du se, at navneområdet er anderledes; Dette skyldes, at vi er i et modulsmodel kaldet kunde. Så fra et moduls model kan du nemt henvise til en standardmodel uden først at inkludere den med brug af nøgleordet.

Brug af controllere på den modulære måde

Definition af controllere

Nedenfor er et eksempel på en grundlæggende modulcontrollerklasse. Bemærk, at controlleren udvider basestyringsklassen, der er inkluderet i Laravel:

navneområde Moduler \ Krav \ Http \ Controllere;
Brug Illuminate \ Http \ Request;
Brug Illuminate \ Http \ Response;
Brug Illuminate \ Routing \ Controller;
bruge moduler \ krav \ enheder \ kunde;
klasse CustomersController udvider Controller
{
    / **
     * Vis en oversigt over ressourcen.
     * @ Return Response
     * /
    offentlig funktionsindeks ()
    {
        returvisning ('kunder :: kunde.index');
    }
    / **
     * Vis formularen til oprettelse af en ny ressource.
     * @ Return Response
     * /
    offentlig funktion oprette ()
    {
        returvisning ('krav :: kunde.oprette');
    }
}

Der foregår en masse derinde, der kan være forvirrende for dig i starten, men slap af, mens jeg forklarer:

Navneområdet Moduler \ Krav \ Http \ Controllere erklærer simpelthen vores controller som en del af modulets controller-navneområde.

Brugsmoduler \ Krav \ Enheder \ Kunde er kun for at inkludere kundemodellen til vores modulcontroller.

Mens returvisningen ('kunder :: kunde.index') returnerer svaret til modulets egen visning ikke standard Laravel-visningen.

Kunderne :: er navnet på modulet, mens customer.index er et bibliotek i modulets ressourcer-> visningsmappe.

Så når du vil gengive en visning, der er en del af modulets visningsnavneområde, kan du beholde ovenstående tilgang. Men hvis du vil gengive en standard Laravel-visning, skal du holde dig til den traditionelle måde som vist nedenfor:

returvisning ('kunder.index);

Oprettelse af en controller

For at oprette en controller til dine moduler skal du køre kommandoen nedenfor:

php håndværksmodul: make-controller CustomersController Customer

Denne kommando genererer en controller under mappen Modules \ Http \ Controllers med navnet CustomersController. Enhver anden implementering, du gerne vil udføre i dit moduls controller, er den samme med Laravel-standardcontroller bortset fra dem, der er beskrevet ovenfor.

Oprettelse af frø

Laravel inkluderer en enkel metode til podning af din database med testdata ved hjælp af frøklasser. Alle frøklasser gemmes i databasen / frø-biblioteket. Frøklasser kan have et hvilket som helst navn, du ønsker, men sandsynligvis skal følge en fornuftig konvention, såsom UsersTableSeeder osv. Som standard defineres en DatabaseSeeder-klasse for dig. Fra denne klasse kan du bruge opkaldsmetoden til at køre andre frøklasser, så du kan kontrollere såsåden.

Men når man håndterer moduler er der små forskelle som:

Opretter såmaskiner

For at generere en seeder til et modul skal du udføre modulet: make-seeder Artisan kommando. Alle seeders genereret af modulet placeres i biblioteket Moduler \ Kunder \ Database \ Seeders:

php håndværksmodul: make-seeder StatesTableSeeder kunder

Ovenstående kode genererer en frøfil som den der er vist nedenfor:

navneområde Moduler \ Kunder \ Database \ Seeders;
Brug Illuminate \ Database \ Seeder;
Brug Illuminate \ Database \ Eloquent \ Model;
klasse StatesDatabaseSeeder udvider Seeder
{
    / **
     * Kør databasefrøene.
     *
     * @ tilbagevenden ugyldig
     * /
    offentlig funktionskørsel ()
    {
        Model :: unguard ();
        // $ this-> call ("OthersTableSeeder");
    }
}

Når du har ovenstående kodestruktur til din frøfil, kan du placere alle de koder, du gerne vil frø, lige under Model :: unguard ().

Kør dit moduls frøfiler

Når du har forberedt alle dine seeders, skal du sørge for, at alle dine seed-filer er deklareret i standard seed-filen, der oprindeligt blev genereret, da du oprettede modulet:

navneområde Moduler \ Kunder \ Database \ Seeders;
Brug Illuminate \ Database \ Seeder;
Brug Illuminate \ Database \ Eloquent \ Model;
klasse KunderDatabaseSeeder udvider Seeder
{
    / **
     * Kør databasefrøene.
     *
     * @ tilbagevenden ugyldig
     * /
    offentlig funktionskørsel ()
    {
        Model :: unguard ();
        $ This-> opkald (StatesTableSeeder :: klasse);
        // enhver anden seeder kan gå her
    }
}

Når du har gjort det, kan du køre modulet: seed Artisan-kommandoen

php håndværksmodul: seedkunder

Ovenstående kode kører alle seed-filer under modulet Kunder.

Arbejde med ruter i moduler

Som standard er alle Laravel-ruter defineret i dine rutefiler, som er placeret i rutebiblioteket. Disse filer indlæses automatisk af rammen. Ruterne / web.php-filen definerer ruter, der er til din webgrænseflade. Disse ruter tildeles web-mellemvaregruppen, som giver funktioner som sessionstatus og CSRF-beskyttelse.

Denne samme struktur gælder, når du arbejder med moduler. Når du opretter et modul, oprettes en Routes-mappe automatisk med api.php og web.php i den. Og også disse filer indlæses automatisk af rammen. Dette betyder, at du kan få adgang til en hvilken som helst rute, du erklærer inde i filen Moduler \ Kunder \ Ruter \ web.php.

Nedenfor er en standardvejsrutefil til kundemodulet

/ *
| ------------------------------------------------- -------------------------
| Webruter
| ------------------------------------------------- -------------------------
|
| Her kan du registrere webruter til din ansøgning. Disse
| ruter indlæses af RouteServiceProvider inden for en gruppe, som
| indeholder "web" mellemvaregruppen. Opret nu noget godt!
|
* /
Rute :: præfiks ('kunder') -> gruppe (funktion () {
    Rute :: get ('/', 'CustomersController @ index');
});

Så du kan redigere rutefilen, så den passer til dit behov.

Sådan udføres alle dine moduler migration og seeders med en enkelt Artisan-kommando

Først da jeg begyndte at arbejde med moduler opdagede jeg en udfordring. Jeg opdagede, at efter at have moduleret min applikation havde jeg mere end fem forskellige moduler til at administrere. Management i denne forstand kører migrationer og såmaskiner til hver af disse moduler under udvikling, og denne proces var ikke rigtig effektiv, og det var tidskrævende. I modsætning til standardmåden til at køre en migration i Laravel ved hjælp af en enkelt Artisan-kommando migrere, der kører alle migrationerne i din applikation; det samme gælder for såmaskiner.

Så jeg skrev en brugerdefineret Artisan-kommando, der vil hjælpe mig med at køre alle mine modulers migrationer og såmaskiner med en enkelt kommando. Dette er også vigtigt i tilfælde af installation.

Filen nedenfor skal hjælpe dig med at oprette din:

navneområde App \ Console \ Kommandoer;
Brug Illuminate \ Console \ Command;
Brug Symfony \ Component \ Console \ Input \ InputArgument;
Brug Symfony \ Component \ Console \ Input \ InputOption;
klasse AppRobot udvider kommandoen
{
    / **
     * Navnet og signaturen på konsolkommandoen.
     *
     * @var streng
     * /
    beskyttet $ signatur = 'robot: run-migration';
/ **
     * Konsolens kommandobeskrivelse.
     *
     * @var streng
     * /
    beskyttet $ beskrivelse = 'Denne kommando kører alle system- og undersystemmigrationer';
/ **
     * Opret en ny kommandoinstant.
     *
     * @ tilbagevenden ugyldig
     * /
    offentlig funktion __construct ()
    {
        forælder :: __ konstruktion ();
    }
/ **
     * Udfør konsolkommandoen.
     *
     * @ tilbagevenden blandet
     * /
    offentlig funktion håndtag ()
    {
        $ dette-> opkald ('migrer', [
            '--force' => 'styrke',
        ]);
        $ dette-> opkald ('modul: migrere', [
            'module' => 'Kunder',
        ]);
/ ** --------------- kører såmaskiner ----------------- ** /
        $ dette-> opkald ('db: frø', [
            '--force' => 'styrke',
        ]);
        $ dette-> opkald ('modul: seed', [
            'module' => 'Kunder',
        ]);
}

Indtil videre baseret på min egen erfaring med opbygning af modulbaserede applikationer i Laravel vil jeg meget gerne rådgive om, at enhver implementering, der hører til modulet, skal opholde sig i det modulkatalog, implementeringer som visninger, funktioner, modeller, migrationer, mellemværker, seeders, mails, tjenester, test sager osv. Dette gør det nemt at tilslutte det til et andet program til brug.

Med dette er vi kommet til slutningen af ​​denne artikel om "Sådan bygges modulær applikation i Laravel: Del 1 & 2". Med det, der er indeholdt i disse to dele, skal du være i stand til let at opbygge din egen modulære applikation. Og hvis der er behov for at oprette en del 3 af denne artikel, vil jeg gøre det, fordi der er nogle koncepter, som vi ikke har dækket; som at bruge middlewares, mails, udbydere osv.

Glem ikke at efterlade dine kommentarer eller bidrag i kommentarafsnittet nedenfor, og skriv venligst et klap, så andre hurtigt kan finde dette indlæg.

Tak fordi du læste.