Share
Når du oppretter en enkeltsidig app, bør vi bruke en slags rammeverk for å gjøre noe av jobben for oss, så vi kan fokusere på den faktiske funksjonaliteten. AngularJS passer perfekt, fordi funksjoner som dynamisk avhengighetsinjeksjon og toveisbinding er bare bra. Noen ganger krever vi også en slags server. Hvis du har valgt PHP, kan Laravel være ditt beste alternativ, da det er lett å jobbe med og ganske kraftig.
I denne opplæringen vil du opprette et enkelt kunde / transaksjonsstyringssystem med muligheten til å legge til og fjerne både transaksjoner og kunder. Dette er sannsynligvis ikke den typen ting du gjør veldig ofte, men det viser hvordan du bruker funksjoner i begge rammene.
Før vi starter, bør du sette opp en MySQL-database som vi skal bruke (Laravel støtter mange flere av dem, men dette er fortsatt den mest populære). Du trenger ikke noen webserver siden vi skal bruke PHPs innebygde (men vær så snill å huske på det Denne løsningen er kun for utviklingen og bør aldri brukes i produksjon - det mangler mange funksjoner som kreves for at appen din skal fungere skikkelig i offentligheten). For det trenger vi minst PHP versjon 5.4.0.
Det første vi må gjøre er å installere Laravel. Den fullstendige prosessen er beskrevet på Laravels nettsted. Deretter bør du ha prosjektkatalogen din opprettet med alle Laravel-filene der inne. Naviger til den katalogen i kommandolinjen og kjør denne kommandoen der:
php artisan tjene
Hvis alt går bra, bør du se at den lokale utviklingsserveren ble startet på locahost: 8000. Åpne nettleseren din og navigere der, du bør se Laravels velkomstside:
Nå kan vi fortsette til selve søknaden.
Modeller i Laravel er akkurat som i andre MVC-rammer. Det bruker Eloquent ORM for å lette arbeidet for deg - du vil sannsynligvis aldri trenge å skrive en SQL-spørring igjen (med mindre du vil ha noe som Eloquent ikke støtter). Ved å bruke migreringer kan du endre databasestrukturen med muligheten til å tilbakestille endringer hvis noe går galt. Du kan lese mer om overføringer i dokumentasjonen.
I vår app bruker vi to modeller:
Accentsconagua
Kunde - vil holde kundedataeneTransaksjon - vil holde informasjonen om en transaksjonLa oss begynne med å skape migreringer for dem. Hvis du ikke allerede har gjort det, må du slå av serveren vi startet tidligere (Ctrl + C).
Først påkall denne kommandoen:
php artisan migrere: lag create_customers_table
Dette vil opprette en migreringsfil med en grunnleggende struktur for deg. Gå nå til app / database / vandringer. Det skal være en fil med navnet som begynner med en tidsstempel og slutter med "create_customers_tableLaravel har automatisk opprettet denne grunnleggende strukturen for deg opp() Metoden kalles når migreringen blir brukt, og ned() når den rulles tilbake.
Ring først på Schema :: skape () metode. Det tar to argumenter - skjemaets navn og en tilbakeringingsfunksjon:
Schema :: create ('customers', function ($ table) Tilbakeringingen utføres når bordet er opprettet. Tabellobjektet er bestått som $ table variabel og vi manipulerer tabellens struktur ved å bruke den. La oss legge til en automatisk inkrementering id felt:
$ Table-> trinn ( 'id');
Deretter vil det være tre strengfelter for kundens fornavn, etternavn og e-post:
$ Bord-> streng ( 'FIRST_NAMEs'); $ Bord-> streng ( 'last_name'); $ Tabell-> string ( 'e') -> unik ();
Vi lager e-post feltet unikt ved å ringe unik() metode på den.
Den siste metoden er for tidsstemplene:
$ Tabell-> tidsstempler (); );
Dette vil opprette to datafelt i skjemaet: created_at og updated_at. Disse vil bli brukt av Eloquent til å lagre tiden da varen ble opprettet og oppdatert.
Endelig bør koden se slik ut:
offentlig funksjon opp () Schema :: opprette ('kunder', funksjon ($ tabell) $ tabell-> trinn ('id'); $ tabell-> streng ('first_name'); $ table-> string last_name '); $ table-> string (' email ') -> unikt (); $ tabell-> tidsstempel ();); De ned() Metoden er mye enklere - det sletter bare skjemaet:
offentlig funksjon ned () Schema :: drop ('kunder'); Koden her vil være lik kundenes en. Først påkalle denne kommandoen:
php artisan migrere: lag create_transactions_table
Finn nå den aktuelle filen i app / database / vandringer og åpne den. Som tidligere, begynn med å lage skjemaet:
Schema :: create ('transaksjoner', funksjon ($ tabell) Legg til feltene for id, transaksjonens navn, kostnaden og IDen til kunden den tilhører:
$ Table-> trinn ( 'id'); $ Tabell-> string ( 'navn'); $ Bord-> flottør ( 'mengde'); $ Bord-> heltall ( 'CUSTOMER_ID');
Og selvfølgelig tidsstemplene:
$ Tabell-> tidsstempler (); );
Den endelige koden skal se slik ut:
offentlig funksjon opp () Schema :: opprette ('transaksjoner', funksjon ($ tabell) $ tabell-> trinn ('id'); $ tabell-> streng ('navn'); $ table-> float beløp '); $ tabell-> heltall (' customer_id '); $ tabell-> tidsstempel ();); Og nå ned() metode:
offentlig funksjon ned () Schema :: drop ('transaksjoner'); Nå før du bruker overføringene må du konfigurere tilkoblingen til databasen. Åpne app / config / database.php fil og gå til linje 55. Her er konfigurasjonsdataene for MySQL (det er få andre der inne, for eksempel kan du bruke SQLite eller Postgres):
'mysql' => array ('driver' => 'mysql', // database driver, ikke rør 'host' => 'localhost', // vert for databasen, vanligvis localhost med mindre du har din db på noen server 'database' => 'database', // navn på databasen du skal bruke, den må opprettes tidligere 'brukernavn' => 'root', // brukernavn som skriptet skal bruke for å koble til, anbefaler jeg sterkt bruker root-bruker for dette 'passordet' => ", // passord for brukeren ovenfor, det er bedre å ikke bruke en tom en 'charset' => 'utf8', // koding av db 'collation' => 'utf8_unicode_ci ', // dbs sorteringsinnstilling' prefix '=> ", // prefikset for databastabellene, nyttig hvis du har flere skript som bruker samme database), Etter at du har fylt det inn, er du god til å gå. Pass på at du lagret filen og påkall denne kommandoen fra appens hovedkatalog (den ene med håndverker filen i den):
php artisan migrere
Og det er det. Hvis det ikke var feil, betyr det at tabellene ble opprettet med hell. Du kan koble til din db ved hjelp av for eksempel phpMyAdmin for å sjekke manuelt hvis du vil.
I Laravel er det veldig raskt å lage en modell etter at du har konfigurert databasen din ved hjelp av overføringer. Navigere til app / modeller og slett eksemplet User.php fil som er der. Opprett nå to filer med navnet Customer.php og Transaction.php.
La oss begynne med Customer.php. Hver modell i Laravel må utvide Veltalende klasse:
klasse kunden utvider eloquent
Nå skal vi definere et forhold mellom kunden og deres transaksjoner. Dette gjøres ved å definere en offentlig metode i modellen med navnet på eiendommen vi ønsker å ha i den (i dette tilfellet transaksjoner):
offentlig funksjonstransaksjoner ()
Nå i funksjonens kropp er det bare en linje:
returnere $ this-> hasMany ('Transaction'); Dette forteller Eloquent at det skal gi alle transaksjoner med Kunde ID av kunden under en eiendom som heter transaksjoner.
Nå skal vi gjøre det samme for transaksjonene, men vi vil reversere forholdet for å gjøre transaksjonens eier tilgjengelig via kunde eiendom:
Klassetransaksjonen utvider Eloquent Public Function kunde () Return $ this-> belongsTo ('Customer'); Dette gjøres ved hjelp av $ Dette-> belongsTo () metode av modellen.
Nå for å faktisk bruke modellene må vi skape kontroller for dem. Hodet til app / kontrollører katalog, slett HomeController.php bare - BaseController.php er viktig som våre kontrollører vil forlenge den. Opprett nå to filer: CustomerController.php og TransactionController.php.
Denne kontrolleren vil håndtere alt relatert til kundene - legge til, fjerne og vise en liste over dem. Begynn med å definere klassen:
klasse CustomerController utvider BaseController
Vi bruker Laravel-funksjonen RESTful-kontrollere. Det gjør det enklere å skape ruter fordi vi bare må definere basen URI og Laravel håndterer alt for oss. Dette krever at du starter dine funksjonsnavn med riktig HTTP-verb og fortsetter deretter med undernavnet (ved hjelp av camelCase). Så for eksempel, hvis vi ville ha en metode som heter getNames og basen URI ville være / kunder, da vil metoden være tilgjengelig på / kunder / navn.
De getIndex (), postIndex (), deleteIndex () etc. Metoder vil bli kartlagt til standardruten (i dette tilfellet / kunder).
La oss nå definere vår første rute - få kunden etter deres id:
offentlig funksjon getIndex ()
La oss få ID fra spørringsparametrene (Laravel gir et fint Input klasse for å håndtere det, så du trenger ikke å bruke $ _GET, $ _POST og $ _files):
$ id = Input :: get ('id'); Og søk etter brukeren i databasen ved hjelp av dette ID:
returnere kunde :: finn ($ id);
Hver metode for kontrolleren må returnere en verdi som er en streng eller har a __toString () metode. I dette tilfellet Kunde Modellen som returneres, vil bli konvertert til JSON før du sender.
Nå kan vi returnere en liste over alle brukere (dette vil være tilgjengelig under / Kunder / alle):
offentlig funksjon getAll () retur kunde :: alle ();
Som du kan se, kan vi få alle kunder ved hjelp av modellens alle() metode.
Nå den lengste delen, legger til en ny kunde:
offentlig funksjon postIndex ()
Først må vi sjekke om all nødvendig informasjon ble gitt. Vi kan gjøre dette ved hjelp av Input :: har () metode:
hvis (Input :: har ('first_name', 'last_name', 'email')) La oss sette alle inntastingsfeltene i $ inngang variabel for å unngå å ringe Input :: får () igjen og igjen. Dette kan gjøres ved hjelp av Input :: alle ():
$ input = Input :: all ();
Neste vil vi sjekke om noen av inngangene er tomme. Hvis det er tilfelle, returnerer vi en feilmelding med HTTP 400 Feilmelding med en mer oversatt melding:
hvis ($ input ['first_name'] == "|| $ input ['last_name'] ==" || $ input ['email'] == ") return Response :: make ('Du må fylle alle av inntastingsfeltene ', 400); Siden vi ønsket å returnere en statuskode enn 200, istedenfor å bare returnere meldingen som en streng, brukte vi Response :: gjøre (), som tar dataene som skal sendes som den første parameteren og statuskoden som den andre. Ta en titt på docs hvis du vil vite mer om svar.
Nå lager vi endelig en ny Kunde modell og mate den med dataene som er oppgitt:
$ kunde = ny kunde; $ kunde-> first_name = $ input ['first_name']; $ kunde-> last_name = $ input ['last_name']; $ kunde-> email = $ input ['email'];
Deretter kan vi lagre den nyopprettede modellen og svare på forespørselen med den:
$ Kunde> Lagre (); returner $ kunde;
Her håndterer vi saken hvis ikke alle inngangene ble gitt:
else return Response :: make ('Du må fylle alle inntastingsfeltene', 400); Til slutt trenger vi også muligheten til å fjerne kundene. Denne er veldig kort:
offentlig funksjon deleteIndex ()
Vi starter med å få kundens ID til å slette:
$ id = Input :: get ('id'); Deretter søker vi etter og sletter kunden:
$ kunde = kunde :: finn ($ id); $ Kunde> slett ();
Etter det svarer vi på forespørselen med id oppgitt:
returner $ id;
Nå før rutene kan nås, må vi koble dem. Åpne app / routes.php fil, slett alt annet enn kommentaren og legg til denne linjen på slutten av filen:
Route :: controller ('/ customers', 'CustomerController'); Dette vil fortelle Laravel å rute alle forespørsler på / kunder til vår CustomerController. Nå kan du bruke CURL til å spille med det. Start serveren først med php artisan tjene og da kan du for eksempel opprette en kunde:
curl -X POST -d "[email protected]" http: // localhost: 8000 / customers
Deretter kan du få listen over alle kunder:
krølle http: // localhost: 8000 / kunder / alle
Dette, som modellen, ligner veldig på CustomerController. Først oppretter du klassen:
klasse TransactionController utvider BaseController
La oss da definere metoden for å få alle transaksjoner for en bruker:
offentlig funksjon getIndex () $ id = Input :: get ('id'); retur Bruker :: finn ($ id) -> transaksjoner; Som du kan se bruker vi forholdet som ble definert tidligere for å få transaksjonene (nå tilbakekall spørringen du måtte skrive for å oppnå det samme ved å bruke vanlig PHP og SQL).
Den neste tingen vil være etableringen av transaksjoner:
offentlig funksjon postIndex ()
Som tidligere kontrollerer vi om all nødvendig informasjon er gitt:
hvis (Input :: har ('navn', 'beløp')) I så fall tilordne den til en $ inngang variabel:
$ input = Input :: all ();
Sjekk om noen av verdiene som er oppgitt, er tomme, og hvis det er en feil:
hvis ($ input ['name'] == "|| $ input ['amount'] ==") return Response :: make ('Du må fylle alle inntastingsfeltene', 400); Opprett nå transaksjonen og leverer den med all informasjonen som er oppgitt:
$ transaksjon = ny transaksjon; $ transaction-> name = $ input ['name']; $ transaction-> amount = $ input ['amount'];
Nå må vi legge den til riktig kunde. La oss finne dem med det oppgitte id og legge til $ transaksjon til deres transaksjonsliste:
$ id = $ input ['customer_id']; Bruker :: finne ($ id) -> transactions-> Lagre ($ transaksjon);
Dette gjøres ved hjelp av transactions-> Lagre () metode gitt av Laravel. Nå kan vi svare med den opprettede transaksjonen:
returnere $ transaksjon;
Og håndter saken der ingen eller ikke alle dataene ble oppgitt:
else return Response :: make ('Du må fylle alle inntastingsfeltene', 400); Deretter er det også en metode for å slette transaksjonen på samme måte som vi slettet kunden:
offentlig funksjon deleteIndex () $ id = Input :: get ('id'); $ transaction = Transaction :: finn ($ id); $ Transaksjons> slett (); returner $ id; Legg nå bare ruten og du kan teste kontrolleren ved hjelp av CURL:
Rute :: kontroller ('/ transaksjoner', 'TransactionController'); Ok, dette er slutten på første del - i den andre delen av denne opplæringen vil vi skape forkant med AngularJS. Du er velkommen til å legge til flere funksjoner i appen din (for eksempel redigering av kunder eller sortering), hvis du ikke fant informasjonen du lette etter, ta en titt på Laravels dokumentasjon.
