Share
CodeIgniter blir kjent for sin kraft som et PHP-basert webapplikasjonsramme, men det er ikke ofte at vi ser eksempler på at det blir brukt til noe annet. I dag lærer vi hvordan vi kan bruke CodeIgniter til å lage en RESTful API for dine eksisterende webprogrammer, og demonstrere hvordan du samhandler med din egen API eller andre RESTful webtjenester, som Facebook og Twitter.
Som du kanskje vet, kan du finne et bredt utvalg av CodeIgniter-skript og -programmer på Envato Market, fra medlemsskript til menyansvarlige og mye mer.
Hvis du har fulgt CodeIgniter From Scratch serien vil du nå vite at det er relativt raskt og enkelt å sette sammen enkle webapplikasjoner, for eksempel blogger, CMS-systemer, brosjyrer, etc. En ting du kanskje ikke har tenkt på, bruker CodeIgniter til å lage en interaktiv API. Etter å ha prøvd flere eksisterende REST-implementeringer, fant jeg at de ikke bare manglet enkelhet, men manglet de fleste funksjonene du ville forvente fra en RESTful implementering; så jeg bygget min egen. Denne opplæringen vil vise deg hvordan du bruker denne koden for å konfigurere REST API, og gir eksempel på hvordan du kan kommunisere med det fra webapplikasjonen din.
Denne opplæringen er delt inn i to deler. Vi vil begynne med å lære å skape en RESTful tjeneste, og videre nedover, vil vi lære å samhandle med det på noen forskjellige måter.
For det første må du laste ned codeigniter-restserverkoden fra GitHub og pakke ut den og flytte koden til serveren din.
Når du åpner mappen, vil du se en hel CodeIgniter-installasjon, som er der for å drive demoen. Dette gjør at folk kan spille med REST-demoen før de integreres med din eksisterende applikasjon.
Åpne opp "Application / config / config.php" og sett base_url for å få koblinger som fungerer. Denne base_url vil være forskjellig for alle og avhenger helt av hvor du lastet opp filene dine.
Med filene hentet og base_url-settet, er vi klare til å laste opp vår RESTful CodeIgniter-installasjon, og se på demoen som følger med den. Bla gjennom basen URL, som som standard er:
http: // localhost / restserver
Her finner du noen få eksempler på linker til example_api kontrolleren, som finnes på "Application / kontrollere / example_api.php". La oss dissekere nettadressene til disse eksemplene for å se hva som skjer. Den første nettadressen er en veldig enkel.
Denne nettadressen ser veldig ut som alle andre CodeIgniter-nettadresser med en kontroller og en metode, men du vil merke i dette diagrammet at metoden heter "Ressurs". REST handler om ressurser og de er egentlig et substantiv i søknaden din, som er interaksjon med (dvs. lagt til, slettet, redigert, spørret) basert på HTTP-overskrifter og URL-spørringsstrenger eller HTTP-argumenter.
Standardformatet for utdata er XML som er det vi ser i dette grunnleggende eksemplet. De andre koblingene er litt større og demonstrerer hvordan parametere skal sendes og viser hvordan utdataformatet kan endres i URL:
Normalt i CodeIgniter, passerer du bare i parameterverdier, men en REST-kontroller aksepterer et hvilket som helst antall parametere i hvilken som helst rekkefølge. For at dette skal fungere, må vi passere i parameternavnet fulgt av verdien i par.
På slutten av nettadressen er parameteren "format". Dette er en reservert parameter som vil endre utdataformatet til de forespurte dataene slik som:
Ved å gi både API-utvikleren og klientprogrammet valget av dataformater å bruke, er API åpnet til et mye bredere publikum og kan brukes med flere programmeringsspråk og systemer. Disse tre er ikke de eneste formater som støttes, ut av boksen din REST API kan bruke:
Mens du legger til formatet på nettadressen, er det ikke teknisk sett den mest RESTful-måten å endre format på, det gjør det mulig for enkel nettlesertesting og lar utviklere uten cURL utføre enkle GET-forespørsler på APIen. Jo mer RESTful måte er å sende en Innholdstype HTTP-header til REST-kontrolleren ved hjelp av cURL, men det vil bli forklart senere.
Nå hvis du åpner opp application / kontrollere / example_api.php Du vil øyeblikkelig finne noen forskjeller fra normale CodeIgniter controllere.
I MVC-mønsteret er en kontroller det sentrale punktet i logikken. Det kalles når en bruker gjør en forespørsel, og deretter basert på logikken i kontrolleren, henter den data og sender ut visninger. CodeIgniter inneholder sin egen logikk for hvordan en Controller skal fungere, men da vi gjør noe annet, trenger vi vårt eget REST_Controller-bibliotek for å inneholde sin egen REST-relaterte logikk. Så i stedet for å bare bruke:
... du må bruke:
Arbeide med ressurser
Nå er din tomme kontroller satt opp, neste er metodene eller "ressursene". Dette er prossibly den mest forvirrende delen av opplæringen hvis du er vant til hvordan CodeIgniter fungerer. I utgangspunktet tar du Ressurs- og HTTP-verbet og kombinerer dem for å lage et metodnavn. Så de to eksemplene vi så på før, hadde en ressurs av bruker og brukere. Fordi begge disse ble lastet i nettleseren, vet vi at det var en GET-forespørsel, og de to metodene nedenfor blir brukt:
Dette kan virke litt rart, men det gir deg muligheten til å bruke samme nettadresse og svare på forespørselen avhengig av HTTP-verbet som er brukt. Hvis noen prøver å få tilgang til APIen din på en måte som ikke er tillatt (i dette eksempelet PUT eller DELETE), svarer det bare med en 404. Hvis du ikke er sikker på HTTP-verb, la meg forklare.
FÅ
Brukes til å hente informasjon om en eksisterende ressurs. Dette brukes av nettlesere når du skriver inn en nettadresse og klikker gå, eller når du klikker på en kobling, så det er perfekt for å hente informasjon om en av dine REST-ressurser (som bruker).
POST
Brukes til å oppdatere en eksisterende ressurs med informasjon. Nettlesere bruker dette til å sende inn de fleste typer skjemaer på internett, selv om noen også bruker GET ved å sende skjemahandlingen med en spørringsstreng som inneholder feltdataene.
SETTE
Mindre brukt og ikke støttet av de fleste nettlesere, brukes PUT til å opprette en ny ressurs.
SLETT
Denne HTTP-verben brukes heller ikke til å slette en ressurs, heller ikke brukt av mange nettlesere.
Hvis vi setter det inn i koden og tillater hvert verb på ressursen bruker det ville se slik ut:
Tilgang til parametere og returdata
Så nå har API fått sin struktur ved å sette opp ressursene og definere en metode for hvert HTTP-verb som vi ønsker å støtte; Vi trenger parametere slik at vi kan bruke våre CodeIgniter-modeller og biblioteker. Dette er en av de største fordelene med å bruke CodeIgniter for APIen vår, da vi kan bruke våre eksisterende modeller og biblioteker og ikke må kode dem om igjen.
få ( 'id')); $ Dette-> respons ($ data); funksjon user_post () $ data = array ('returnert:'. $ this-> post ('id')); $ Dette-> respons ($ data); funksjon user_put () $ data = array ('returnert:'. $ this-> put ('id')); $ this-> response ($ data; funksjon user_delete () $ data = array ('returnert:'. $ this-> delete ('id')); $ dette-> svar ($ data);Dette eksemplet inneholder fem nye kodestykker:
$ Dette-> get ()
Er vant til å returnere GET-variabler fra enten en spørringsstreng som denne indeksen.php / example_api / user? Id = 1 eller kan settes på den mer CodeIgniter'esque måte med index.php / example_api / user / id / 1.
$ Dette-> innlegget ()
Er et alias for $ this-> input-> post () som er CodeIgniter-metoden for å få tilgang til $ _POST-variabler med XSS-beskyttelse.
$ Dette-> put ()
Leser i PUT-argumenter angitt i HTTP-overskriftene eller via cURL.
$ Dette-> slett ()
Du gjettet det, dette står i DELETE argumenter, også angitt i HTTP-overskrifter eller via cURL.
$ Dette-> respons ()
Sender data til nettleseren i hvilket dataformat som er forespurt, eller som standard til XML. Du kan eventuelt sende en HTTP-statuskode for å vise at den har fungert eller mislyktes. For eksempel hvis ID oppgitt ikke var i databasen, kan du bruke $ this-> response (array ('error' => 'Bruker ikke funnet.'), 404);
Trinn 4: Arbeide med modellene dine
Hittil har vi jobbet med et eksempel-API i en ren installasjon. Så det neste trinnet er å få en REST API som kjører fra din eksisterende kodebase.
Selv om nedlastingen leveres med en full CodeIgniter-installasjon for demonstrasjonen og å tillate at API-er skal bygges fra bunnen av, er de eneste to filene av betydning:
- application / konfig / rest.php
- application / bibliotek / REST_Controller.php
Slett disse to filene i CodeIgniter-programmet ditt, og opprett en ny API-kontroller.
få ('id')) $ this-> svar (NULL, 400); $ user = $ this-> user_model-> get ($ this-> get ('id')); hvis ($ bruker) $ this-> svar ($ bruker, 200); // 200 er HTTP-svarskoden ellers $ this-> svar (NULL, 404); funksjon user_post () $ result = $ this-> user_model-> oppdatering ($ this-> post ('id'), array ('name' => $ this-> post ('navn'), 'epost '=> $ this-> post (' email '))); hvis ($ result === FALSE) $ this-> response (array ('status' => 'mislyktes')); ellers $ this-> response (array ('status' => 'suksess')); funksjon users_get () $ users = $ this-> user_model-> get_all (); hvis ($ brukere) $ this-> svar ($ brukere, 200); ellers $ this-> svar (NULL, 404); ?>Dette viser et eksempel-API med noen generiske modellnavn. I den første metoden tar vi opp en? Id = XX og sender den til modellen. Hvis data er funnet, sender vi det til $ this-> response () -funksjonen med en status 200. Hvis ingenting er funnet, returner ingen kropp og en 404 for å si at ingenting ble funnet. Du kan forestille deg hvordan dette kan utvides for å kjøre alle slags API-aktiviteter for din webapplikasjon.
Trinn 5: Sikre API
Nå er API-en din bygd, den trenger sikring, slik at bare brukere som får tilgang kan samhandle med APIen. For å angi innloggingstypen, åpnes brukernavn og passord "Application / config / rest.php" inne i kodebase.
/ * | ----------------------------------------------- --------------------------- | REST Logg inn | ----------------------------------------------- --------------------------- | | Er pålogging krevd, og i så fall hvilken type pålogging? | | "= Ingen innlogging kreves, 'basic' = relativt sikker innlogging, 'fordøye' = sikker pålogging | * / $ config ['rest_auth'] = 'basic';Ingen
Alle kan samhandle med en av dine API-kontrollere.
grunn~~POS=TRUNC
En relativt usikker påloggingsmetode som bare skal brukes på interne / sikre nettverk.
Fordøye
En mye tryggere innloggingsmetode som krypterer brukernavn og passord. Hvis du ønsker å ha en beskyttet API som noen kan få på, bruk fordøye.
/ * | ----------------------------------------------- --------------------------- | REST Logg inn brukernavn | ---------------------------------------------- ---------------------------- | | Array av brukernavn og passord for pålogging | | array ('admin' => '1234') | * / $ config ['rest_valid_logins'] = array ('admin' => '1234');Det er enkelt å sette opp brukerne. Hver innlogging er et array element, med en nøkkel og en verdi. Nøkkelen er brukernavnet og verdien er passordet. Legg til så mange som du liker i denne gruppen, og opprett dem til alle som vil bruke API.
Del 2 - Interagere med RESTful Services
Enten det er APIen du nettopp har bygget eller en offentlig tjeneste som Twitter, vil du være i stand til å samhandle med det på en eller annen måte. Å se som RESTful-tjenester fungerer med grunnleggende HTTP-forespørsler, det er veldig enkelt å gjøre dette på en rekke forskjellige måter.
Forskjellige metoder for å interagere med REST
Hver av disse forskjellige samhandlingsmetodene vil bli vist med koden plassert direkte i Controller-metodene. Dette er rent slik at demoene er enklere å lese og normalt ville bli plassert i en modell eller et bibliotek for riktig MVC-separasjon.
file_get_contents ()
Ved å bruke den enkle PHP-funksjonen file_get_contents (), kan du utføre en grunnleggende GET-forespørsel. Dette er den mest grunnleggende av alle metodene, men er verdt å nevne for de "raske og skitne" øyeblikkene.
$ user = json_decode (file_get_contents ('http://example.com/index.php/api/user/id/1/format/json')); ekko $ bruker-> navn;Det er verdt å merke seg at, mens denne metoden ikke fungerer ved hjelp av HTTP Digest-godkjenning, kan du bruke følgende syntaks hvis du bruker HTTP Basic-godkjenning for å få data fra ditt passordbeskyttede RESTful API:
$ user = json_decode (file_get_contents ('http: // admin: [email protected]/index.php/api/user/id/1/format/json')); ekko $ bruker-> navn;Det er noen problemer med å bruke denne metoden: Den eneste måten å angi ekstra HTTP-hoder på, er å angi dem manuelt ved hjelp av PHP-funksjonen stream_context_create (), noe som kan være svært komplisert for utviklere som er nye til de interne funksjonene til HTTP-forespørsler. En annen ulempe er at du bare mottar kroppen til HTTP-responsen i dets råformat, noe som betyr at du må håndtere konvertering fra en enkelt enkelt forespørsel.
cURL
cURL er den mest fleksible måten å samhandle med en REST API som den var designet for akkurat denne typen ting. Du kan angi HTTP-overskrifter, HTTP-parametere og mye mer. Her er et eksempel på hvordan du oppdaterer en bruker med vårt eksempel_api og cURL for å lage en POST-forespørsel:
funksjon native_curl ($ new_name, $ new_email) $ brukernavn = 'admin'; $ password = '1234'; // Alternativ JSON versjon // $ url = 'http://twitter.com/statuses/update.json'; // Sett opp og utfør krøllingsprosessen $ curl_handle = curl_init (); curl_setopt ($ curl_handle, CURLOPT_URL, 'http: //localhost/restserver/index.php/example_api/user/id/1/format/json'); curl_setopt ($ curl_handle, CURLOPT_RETURNTRANSFER, 1); curl_setopt ($ curl_handle, CURLOPT_POST, 1); curl_setopt ($ curl_handle, CURLOPT_POSTFIELDS, array ('navn' => $ nynavn, 'email' => $ new_email)); // Valgfritt, slett denne linjen hvis API-en din er åpen curl_setopt ($ curl_handle, CURLOPT_USERPWD, $ brukernavn. ':'. $ Passord); $ buffer = curl_exec ($ curl_handle); curl_close ($ curl_handle); $ result = json_decode ($ buffer); hvis (isset ($ result-> status) && $ result-> status == 'suksess') echo 'Brukeren har blitt oppdatert.'; ellers echo 'Noe har gått galt';Interaksjon med API-en din fungerer på denne måten, men det er to problemer med denne metoden:
- Den bruker et stygg forvirrende syntaks - tenk å lage flere applikasjoner basert på det.
- cURL er ikke installert på alle servere som standard.
For å løse denne stygge syntaksen, har et cURL-bibliotek blitt utviklet for CodeIgniter som forenkler ting enormt.
Den nøyaktige samme forespørselen som ble gjort med cURL-biblioteket, vil se slik ut:
funksjon ci_curl ($ new_name, $ new_email) $ brukernavn = 'admin'; $ password = '1234'; $ Dette-> last> bibliotek ( 'curl'); $ Dette-> curl-> lage ( 'http: //localhost/restserver/index.php/example_api/user/id/1/format/json'); // Valgfritt, slett denne linjen hvis APIen din er åpen $ this-> curl-> http_login ($ brukernavn, $ passord); $ this-> curl-> post (array ('name' => $ new_name, 'email' => $ new_email)); $ result = json_decode ($ this-> curl-> execute ()); hvis (isset ($ result-> status) && $ result-> status == 'suksess') echo 'Brukeren har blitt oppdatert.'; ellers echo 'Noe har gått galt';Mye bedre å se på? Vel, det er en enda enklere metode for å jobbe med REST i CodeIgniter-applikasjoner som dette.
REST klient bibliotek
Et REST-klientbibliotek er utviklet som sitter på toppen av dette cURL-biblioteket som håndterer formatkonvertering, HTTP-pålogginger og flere andre aspekter av din REST API.
funksjon rest_client_example ($ id) $ this-> load-> bibliotek ('resten', array ('server' => 'http: //localhost/restserver/index.php/example_api/', 'http_user' => ' admin ',' http_pass '=>' 1234 ',' http_auth '=>' basic '// eller' fordøye ')); $ user = $ this-> rest-> get ('bruker', array ('id' => $ id), 'json'); ekko $ bruker-> navn;Her kan du se at vi gjør en GET-forespørsel, sender id som en parameter og forteller biblioteket vi vil ha 'json' som innholdsformat. Dette håndterer innstillingen for innholdstype for deg, og konverterer dataene til et PHP-objekt for deg. Du kan endre denne verdien til 'xml', 'json', 'serialize', 'php', 'csv' eller en tilpasset MIME-type du liker, for eksempel:
$ user = $ this-> rest-> get ('bruker', array ('id' => $ id), 'application / json');Som du sikkert har gjettet så vel som $ this-> rest-> get (), støtter biblioteket også $ this-> rest-> post (), $ this-> rest-> put (), $ this-> resten -> slett () for å matche alle dine REST_Controller metoder.
Du må få var_dump () resultater fra REST-klientbiblioteket for å sikre at du får det riktige dataformatet tilbake. Konverteringen vil noen ganger være array og noen ganger være et objekt, avhengig av hvordan det konverteres av PHP. Hvis den returnerte MIME-typen ikke støttes, vil den ganske enkelt returnere formatet som vanlig tekst.
Snakker med Twitter
Ved hjelp av dette REST-biblioteket kan du snakke med andre RESTful-tjenester som Twitter og Facebook. Her er et enkelt eksempel på hvordan du kan få detaljer for en spesiell bruker basert på deres ID, ved hjelp av Twitters standardformat XML.
$ this-> load-> library ('resten', array ('server' => 'http://twitter.com/')); $ user = $ this-> rest-> get ('brukere / show', array ('screen_name' => 'philsturgeon'));$ this-> load-> library ('resten', array ('server' => 'http://twitter.com/', 'http_user' => 'brukernavn', 'http_pass' => 'passord' http_auth '=>' basic ')); $ user = $ this-> rest-> post ('statuses / update.json', array ('status' => 'Bruke REST-klienten til å gjøre ting'));Når du ser på dette, vil du legge merke til at interaksjon med Twitter API er litt annerledes på noen måter.
- De støtter URL-basert formatovergang i form av .json i stedet for / format / json. Noen krever en forlengelse, noen gjør det ikke; så det er best å alltid legge dem til.
- De støtter for det meste kun GET / POST, men begynner å legge til flere DELETE-metoder
- De har ikke alltid bare en ressurs i nettadressen deres, for eksempel: brukere / søk er en REST-metode, men lister er en annen.
Hold øye med disse forskjellene som de kan fange deg ut. Hvis du sitter fast, ekko $ this-> rest-> debug () for et stort utvalg av informasjon på din REST forespørsel.
Sammendrag
Kombinere hva du nå vet om RESTful-tjenester, CodeIgniter REST-klientbiblioteket og Twitter API-dokumentasjonen - eller en hvilken som helst annen RESTful API-dokumentasjon for det saks skyld - kan du lage noen svært kraftige applikasjoner som integreres med en tilpasset eller offentlig webtjeneste ved hjelp av REST. Du kan utvide API-en din ved å opprette flere REST_Controller-moduler og til og med lage en modulær API ved hjelp av Matchbox eller Modular Separation for å opprette en api.php-kontroller for hver modul for å holde API-en din så pent organisert som din søknad.
Følg oss på Twitter, eller abonner på Nettuts + RSS-feed for de beste webutviklingsopplæringene på nettet. Og ikke glem å sjekke ut de nyttige CodeIgniter-skriptene og -appene på Envato Market.
Accentsconagua
