Gebruik het Repository-ontwerppatroon in een Laravel-toepassing

Ik schreef eerder over het bouwen van een taak-app met Laravel en Vue.js. Laravel is een PHP-framework voor het bouwen van schaalbare webapplicaties en API's. Vue.js is een Javascript-framework en alternatief voor jQuery of React.

Aan de slag

In deze tutorial gaan we functionaliteit toevoegen aan de applicatie die we in de vorige tutorial hebben gebouwd. Kloon de github-repo, voer de installatie van de componist uit, installeer de npm en maak verbinding met je database.

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

Als je op dit punt vastzit, bekijk dan andere artikelen die ik heb geschreven over het installeren van MySQL en de eerste installatie van Laravel. Op localhost: 8000 ziet u een app die taken asynchroon toevoegt en verwijdert. Dat betekent dat het de bewerkingen uitvoert en de actuele gegevens weergeeft zonder de webpagina te vernieuwen.

De taak-app die we in de vorige zelfstudie hebben gebouwd.

Het Repository-ontwerppatroon

In de vorige tutorial schreven we al onze applicatielogica in de controller. Er is een alternatieve benadering van ontwikkeling die sommige oproepen samenvat in PHP-klassen die Repositories worden genoemd. Het idee is dat we modellen kunnen ontkoppelen van controllers en leesbare namen kunnen toewijzen aan gecompliceerde query's.

We gaan onze app refacteren om het Repository-patroon te gebruiken. De eerste stap is het maken van een bestand voor app / Repositories / Repository.php.

 model = $ model;
    }

    // Krijg alle exemplaren van het model
    publieke functie allemaal ()
    {
        retourneer $ this-> model-> all ();
    }

    // maak een nieuw record in de database
    public function create (array $ data)
    {
        retourneer $ this-> model-> create ($ data);
    }

    // update record in de database
    openbare functie-update (array $ data, $ id)
    {
        $ record = $ this-> find ($ id);
        retourneer $ record-> update ($ data);
    }

    // verwijder record uit de database
    public function delete ($ id)
    {
        retourneer $ this-> model-> destroy ($ id);
    }

    // toon het record met de opgegeven id
    openbare functieshow ($ id)
    {
        retourneer $ this-> model-findOrFail ($ id);
    }

    // Haal het bijbehorende model op
    openbare functie getModel ()
    {
        retourneer $ this-> model;
    }

    // Stel het bijbehorende model in
    public function setModel ($ model)
    {
        $ this-> model = $ model;
        $ retourneren;
    }

    // Populair laden database relaties
    openbare functie met ($ relaties)
    {
        retourneer $ this-> model-> with ($ relations);
    }
}

Dit bestand definieert onze Repository-klasse. Instanties van deze klasse hebben een modeleigenschap die we koppelen aan een welsprekend model. Zodra dit in de constructor is gebonden, kunnen we Eloquent-methoden zoals findOrFail, update of alle methoden uit de klasse aanroepen.

De sectie RepositoryInterface van implementaties is niet strikt noodzakelijk, maar het voegt een extra laag structuur toe aan onze code. Een interface is een contract dat de methoden definieert die een klasse MOET hebben gedefinieerd. In ons geval ziet de interface er als volgt uit:

Als we nieuwe repositories maken die deze interface implementeren, weten we altijd dat deze methoden zijn gedefinieerd. Interfaces bieden structuur zodat we weten wat onze code moet doen.

Terug in ons TaskController.php-bestand maken we een repository en geven we het Task-model door.

 model = new Repository ($ task);
   }

   openbare functie-index ()
   {
       retourneer $ this-> model-> all ();
   }

   openbare functieopslag (verzoek $ aanvragen)
   {
       $ this-> validate ($ request, [
           'body' => 'vereist | max: 500'
       ]);

       // maak een record en geef alleen velden door die kunnen worden ingevuld
       retourneer $ this-> model-> create ($ request-> only ($ this-> model-> getModel () -> invulbaar));
   }

   openbare functieshow ($ id)
   {
       retourneer $ this-> model-> show ($ id);
   }

   openbare functie-update (verzoek $ verzoek, $ id)
   {
       // update-model en alleen doorgeven in de invulbare velden
       $ this-> model-> update (alleen $ request-> ($ this-> model-> getModel () -> invulbaar), $ id);

       retourneer $ this-> model-> find ($ id);
   }

   openbare functie vernietigen ($ id)
   {
       retourneer $ this-> model-> delete ($ id);
   }
}

De Laravel-servicecontainer lost onze afhankelijkheden automatisch op en injecteert ze in de controller-instantie (docs).

Op dit moment werkt onze applicatie precies hetzelfde, maar onze code is gerefacteerd om repositories te gebruiken en we hebben nog een paar API-eindpunten toegevoegd.

Broncode beschikbaar op Github

Als u een kandidaat bent op de arbeidsmarkt of een startup zoekt om te huren in de Bay Area, maak dan een profiel aan op Employbl