Brug opbevaringsdesignmønsteret i en Laravel-applikation

Jeg skrev tidligere om, hvordan man bygger en opgave-app med Laravel og Vue.js. Laravel er en PHP-ramme til opbygning af skalerbare webapplikationer og API'er. Vue.js er en Javascript-ramme og alternativ til jQuery eller React.

Kom i gang

I denne tutorial vil vi tilføje funktionalitet til den applikation, vi har bygget i den forrige tutorial. Klon github-repoen, kør komponistinstallation, npm-installation og opret forbindelse til din database.

$ mysql -uroot -p
mysql> Opret database laravelTaskApp;

Hvis du sidder fast på dette tidspunkt, så tjek andre artikler, som jeg har skrevet om installation af MySQL og den oprindelige Laravel-opsætning. Hos localhost: 8000 kan du se en app, der asynkront tilføjer og sletter opgaver. Det betyder, at den udfører operationerne og viser de ajourførte data uden at opdatere websiden.

Opgave-appen opbyggede vi i den foregående tutorial.

Opbevaringsdesignmønsteret

I den forrige tutorial skrev vi alle vores applikationslogik i controller. Der er en alternativ tilgang til udvikling, der abstraherer nogle opkald til PHP-klasser, der kaldes Repositories. Tanken er, at vi kan afkoble modeller fra controllere og tildele læsbare navne til komplicerede forespørgsler.

Vi vil refactorere vores app for at bruge depotmønsteret. Det første trin er at oprette en fil til app / Repositories / Repository.php.

 model = $ model;
    }

    // Få alle forekomster af model
    offentlig funktion alle ()
    {
        returner $ dette-> model-> alle ();
    }

    // oprette en ny post i databasen
    oprettelse af offentlig funktion (array $ data)
    {
        returner $ this-> model-> create ($ data);
    }

    // opdateringspost i databasen
    offentlig funktionsopdatering (array $ data, $ id)
    {
        $ record = $ this-> find ($ id);
        returner $ record-> update ($ data);
    }

    // fjern post fra databasen
    slet af offentlig funktion ($ id)
    {
        returner $ dette-> model-> ødelægge ($ id);
    }

    // Vis posten med det givne id
    offentlig funktionsvisning ($ id)
    {
        returner $ dette-> model-findOrFail ($ id);
    }

    // Hent den tilknyttede model
    offentlig funktion getModel ()
    {
        returner $ denne-> model;
    }

    // Indstil den tilhørende model
    offentlig funktion setModel ($ model)
    {
        $ dette-> model = $ model;
        returner $ dette;
    }

    // Ivrige indlæs databaseforhold
    offentlig funktion med ($ relations)
    {
        returner $ dette-> model-> med ($ relations);
    }
}

Denne fil definerer vores depotklasse. Forekomster af denne klasse har en modelejendom, som vi binder til en veltalende model. Når dette er bundet i konstruktøren, kan vi kalde veltalende metoder som findOrFail, opdatering eller alt fra klassemetoderne.

Afsnittet med implementeringsdatabaser er ikke strengt nødvendigt, men det tilføjer et ekstra lag med struktur til vores kode. En grænseflade er en kontrakt, der definerer de metoder, en klasse SKAL have defineret. I vores tilfælde ser grænsefladen sådan ud:

Hvis vi laver nye lagre, der implementerer denne grænseflade, ved vi altid, at disse metoder er defineret. Grænseflader giver struktur, så vi ved, hvad vores kode skal gøre.

Tilbage i vores TaskController.php-fil indstiller vi et arkiv og overfører opgavemodellen til den.

 model = nyt depot ($ opgave);
   }

   offentlig funktionsindeks ()
   {
       returner $ dette-> model-> alle ();
   }

   offentlig funktion butik (anmodning om $ anmodning)
   {
       $ dette-> validere ($ anmodning, [
           'body' => 'krævet | max: 500'
       ]);

       // oprette post og videregive kun felter, der er fillable
       returner $ this-> model-> create ($ request-> only ($ this-> model-> getModel () -> fillable));
   }

   offentlig funktionsvisning ($ id)
   {
       returner $ dette-> model-> show ($ id);
   }

   opdatering af offentlig funktion (Anmodning om $ anmodning, $ id)
   {
       // opdatering af model og kun videresendes i de fillable felter
       $ dette-> model-> opdatering (kun $ anmodning-> ($ dette-> model-> getModel () -> arkiverbart), $ id);

       returner $ dette-> model-> find ($ id);
   }

   offentlig funktion ødelægge ($ id)
   {
       returner $ this-> model-> delete ($ id);
   }
}

Laravel-servicebeholderen løser automatisk vores afhængigheder og injicerer dem i controllerforekomsten (dokumenter).

På dette tidspunkt fungerer vores applikation nøjagtigt den samme, men vores kode er blevet refaktoreret til at bruge depoter, og vi har tilføjet et par flere API-slutpunkter.

Kildekode tilgængelig på Github

Hvis du er en kandidat på jobmarkedet eller opstart, der ønsker at ansætte i Bay-området, er du velkommen til at oprette en profil på Employbl