Share
Le API RESTful sono difficili! Ci sono molti aspetti nel progettare e scrivere con successo. Ad esempio, alcuni degli argomenti che potresti trovare nella gestione includono l'autenticazione, hypermedia / HATEOS, il controllo delle versioni, i limiti di velocità e la negoziazione del contenuto. Invece di affrontare tutti questi concetti, concentriamoci invece sulle basi del REST. Creeremo alcuni endpoint JSON dietro un sistema di autenticazione di base e impareremo alcuni trucchi di Laravel 4 nel processo.
Se hai bisogno di aiuto per lo sviluppo di Laravel, prova alcuni degli utili script e plug-in di Laravel disponibili su Envato Market.
Costruiamo un'API per una semplice app Read-It-Later. Gli utenti saranno in grado di creare, leggere, aggiornare e cancellare gli URL che desiderano leggere in seguito.
Pronto per tuffarti e iniziare?
Crea una nuova installazione di Laravel 4. Se sei pratico con CLI, prova questa guida rapida. Altrimenti, abbiamo un video tutorial qui su Nettuts + che copre il processo.
Per prima cosa creeremo una chiave di crittografia per l'hashing della password sicura. Puoi farlo facilmente eseguendo questo comando dalla radice del tuo progetto:
Chiave artigianale $ php: generare
In alternativa, puoi semplicemente modificare il tuo app / config / app.php chiave di crittografia:
Accentsconagua
/ * | ----------------------------------------------- --------------------------- | Chiave di crittografia | ----------------------------------------------- --------------------------- | | Questa chiave è utilizzata dal servizio di crittografia di Illuminate e dovrebbe essere impostata | a una stringa lunga casuale, altrimenti questi valori crittografati non saranno | stai attento. Assicurati di cambiarlo prima di distribuire qualsiasi applicazione! | * / 'key' => md5 ('questo è un modo per ottenere un set di chiavi di crittografia'), Una volta installata un'installazione funzionante di Laravel 4, possiamo iniziare con il divertimento. Inizieremo creando il database dell'app.
Ciò richiederà solo due tabelle di database:
Useremo le migrazioni di Laravel per creare e popolare il database.
modificare app / config / database.php e riempirlo con le impostazioni del database. Nota: questo significa creare un database per questa applicazione da utilizzare. Questo articolo presuppone un database MySQL.
'connections' => array ('mysql' => array ('driver' => 'mysql', 'host' => 'localhost', 'database' => 'read_it_later', 'username' => 'your_username', 'password' => 'your_password', 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => ",),), $ php artisan migrate: make create_users_table --table = users --create $ php artisan migrate: make create_urls_table --table = urls --create
Questi comandi impostano gli script di migrazione di base che utilizzeremo per creare le tabelle del database. Il nostro compito ora è riempirli con le colonne corrette della tabella.
modificare app / database / migrazioni / SOME_DATE_create_users_table.php e aggiungere al su() metodo:
public function up () Schema :: create ('users', function (tabella $ Blueprint) $ table-> increments ('id'); $ table-> string ('username') -> unique (); $ table-> string ('password'); $ table-> timestamps ();); In alto, stiamo impostando un nome utente (che dovrebbe essere univoco), una password e i timestamp. Salvalo e ora modifica app / database / migrazioni / SOME_DATE_create_urls_table.php, e aggiungere al su() metodo:
public function up () Schema :: create ('urls', function (tabella $ Blueprint) $ table-> increments ('id'); $ table-> intero ('user_id'); $ table-> string ( 'url'); $ table-> string ('description'); $ table-> timestamps ();); L'unica nota importante in questo snippet è che stiamo creando un collegamento tra il url e utenti tavolo, tramite il ID utente campo.
Possiamo utilizzare i semi di Laravel per creare alcuni utenti di esempio.
Crea un file all'interno di app / database / semi cartella che ha lo stesso nome della tabella alla quale corrisponde; nel nostro caso, UserTableSeeder.php. Inserisci:
Elimina(); User :: create (array ('username' => 'firstuser', 'password' => Hash :: make ('first_password'))); User :: create (array ('username' => 'seconduser', 'password' => Hash :: make ('second_password'))); Quindi, assicurarsi che la classe seminatrice venga eseguita quando il database viene seminato. modificare app / database / semi / DatabaseSeeder.php:
funzione pubblica run () Eloquent :: unguard (); // Aggiungi o Decommenta questa linea $ this-> call ('UserTableSeeder'); Ecco come creare queste due tabelle e inserire i nostri utenti di esempio.
// Crea le due tabelle $ php artisan migrate // Crea gli utenti di esempio $ php artisan db: seed
Laravel 4 continua a utilizzare l'eccellente ORM eloquente. Ciò renderà il processo di gestione delle chiamate ai database in un attimo. Richiediamo un modello per tabella.
Fortunatamente, Laravel viene fornito con una configurazione del modello Utente, quindi creiamo un modello per la nostra tabella degli URL.
Crea e modifica file app / modelli / Url.php.
Autenticazione
I filtri di Laravel possono gestire l'autenticazione per noi. In particolare, Laravel ora dispone di un filtro di autenticazione di base, che possiamo utilizzare come modello di autenticazione rapida da utilizzare con le nostre richieste API.
Se apri
app / filters.php, vedrai com'è:Route :: filter ('auth.basic', function () return Auth :: basic (););Abbiamo solo bisogno di fare un aggiustamento. Per impostazione predefinita, questo filtro cerca un campo "email" per identificare l'utente. Dal momento che stiamo usando nomi utente invece di e-mail, abbiamo solo bisogno di regolare questa preferenza. Cambiare il
Auth :: di base ()chiama assegnandogli il nostro campo username come parametro:Route :: filter ('auth.basic', function () return Auth :: basic ("username"););Itinerari
Proviamo questo. Crea un percorso, chiamato
testauth, e assicurati che il nostroauth.basicil filtro viene eseguito prima di esso.modificare
app / routes.php:Route :: get ('/ authtest', array ('before' => 'auth.basic', function () return View :: make ('hello');));Possiamo testare questo con una richiesta di arricciatura. Dal tuo terminale, prova a puntare alla tua build di Laravel. Nella mia, sembra che questo (il tuo URL sarà probabilmente diverso!):
$ curl -i localhost / l4api / public / index.php / authtest HTTP / 1.1 401 Data non autorizzata: mar, 21 maggio 2013 18:47:59 GMT WWW-Authenticate: Basic Vary: Accept-Encoding Content-Type: text / html ; charset = UTF-8 Credenziali non valideCome puoi vedere, viene rilevata una richiesta non autorizzata e viene restituito un messaggio "Credenziali non valide" con un codice di stato 401. Successivamente, provare a includere l'autenticazione di base.
$ curl --user firstuser: first_password localhost / l4api / public / index.php / authtest HTTP / 1.1 200 OK Data: Martedì, 21 maggio 2013 18:50:51 GMT Vary: Accept-Encoding Content-Type: text / html; charset = UTF-8Ciao mondo!
Ha funzionato!
A questo punto, viene eseguito il lavoro di base della nostra API. Abbiamo:
Potresti avere familiarità con i controller RESTful di Laravel. Esistono ancora in Laravel 4; tuttavia, possiamo anche utilizzare i controller di risorse di Laravel, che impostano alcuni paradigmi che possiamo usare per creare un'interfaccia API coerente. Useremo un controller Resourceful.
Ecco una ripartizione di ciò che ogni metodo nel controller pieno di risorse gestirà. Tieni presente che puoi rimuovere i percorsi / resource / create e / resource / id / edit, poiché non sarà necessario mostrare i moduli "create" o "edit" in un'API.
$ php artisan controller: make UrlController
Quindi, impostare un percorso per utilizzare il controller e richiedere che ogni percorso venga autenticato.
modificare app / routes.php e aggiungi:
// Gruppo di percorso per versioning API Route :: group (array ('prefix' => 'api / v1', 'before' => 'auth.basic'), function () Route :: resource ('url', 'UrlController');); Alcune cose stanno accadendo lì.
http://example.com/api/v1/url./ Api / v1 / utente.Nota: è possibile prendere in considerazione tecniche di controllo delle versioni API più avanzate, ad esempio l'utilizzo di un Accettare intestazione o sottodominio che possono aiutarti a indicare diverse versioni dell'API basi di codice separate.
Modifica il nuovo app / controller / UrlController.php file:
// Modifica questo: public function index () return 'Hello, API';
Proviamoci:
$ curl -i localhost / l4api / pubblico / index.php / api / v1 / url HTTP / 1.1 401 Data non autorizzata: Mar, 21 maggio 2013 19:02:59 GMT Autenticazione WWW: base Varia: Accetta-codifica Content-Type : text / html; charset = UTF-8 Credenziali non valide. $ curl --user firstuser: first_password localhost / l4api / public / index.php / api / v1 / url HTTP / 1.1 200 OK Data: mar, 21 maggio 2013 19:04:19 GMT Vary: Accept-Encoding Content-Type: text / html; charset = UTF-8 Ciao, API
Ora disponiamo di un controller pieno di risorse con autenticazione funzionante e pronto per aggiungere funzionalità.
modificare app / controller / UrlController.php:
/ ** * Archivia una risorsa appena creata nella memoria. * * @return Response * / public function store () $ url = new Url; $ url-> url = Request :: get ('url'); $ url-> description = Request :: get ('description'); $ url-> user_id = Auth :: user () -> id; // Validazione e filtraggio sono assolutamente necessari !! // Scherzi a parte, sono una persona cattiva per averlo lasciato fuori. $ Url-> save (); return Response :: json (array ('error' => false, 'urls' => $ urls-> toArray ()), 200); È ora di testare questo con un'altra richiesta di arricciatura. Questo invierà una richiesta POST, che corrisponderà al memorizzare() metodo creato sopra.
$ curl -i --user firstuser: first_password -d 'url = http: //google.com&description=A Motore di ricerca' localhost / l4api / public / index.php / api / v1 / url HTTP / 1.1 201 Data creazione: mar , 21 maggio 2013 19:10:52 GMT Content-Type: application / json "error": false, "message": "URL created"
Freddo! Creiamo qualcos'altro, per entrambi i nostri utenti.
$ curl --user firstuser: first_password -d 'url = http: //fideloper.com&description=A Great Blog' localhost / l4api / public / index.php / api / v1 / url $ curl --user seconduser: second_password -d 'url = http: //digitalsurgeons.com&description=Un'agenzia di marketing' localhost / l4api / public / index.php / api / v1 / url $ curl --user seconduser: second_password -d 'url = http: //www.poppstrong .com / & description = Sento per lui 'localhost / l4api / public / index.php / api / v1 / url
Quindi, creiamo metodi per recuperare gli URL.
/ ** * Visualizza un elenco delle risorse. * * @return Response * / public function index () // Precedentemente: return 'Hello, API'; $ urls = Url :: where ('user_id', Auth :: user () -> id) -> get (); return Response :: json (array ('error' => false, 'urls' => $ urls-> toArray ()), 200); / ** * Visualizza la risorsa specificata. * * @param int $ id * @return Risposta * / public function show ($ id) // Assicurarsi che l'utente corrente possegga la risorsa richiesta $ url = Url :: where ('user_id', Auth :: user () - > id) -> dove ('id', $ id) -> take (1) -> get (); return Response :: json (array ('error' => false, 'urls' => $ url-> toArray ()), 200); Proviamoli:
$ curl --user firstuser: first_password localhost / l4api / public / index.php / api / v1 / url "error": false, "urls": ["created_at": "2013-02-01 02:39: 10 "," descrizione ":" A Search Engine "," id ":" 2 "," updated_at ":" 2013-02-01 02:39:10 "," url ":" http://google.com "," user_id ":" 1 ", " created_at ":" 2013-02-01 02:44:34 "," description ":" Un grande blog "," id ":" 3 "," updated_at " : "2013-02-01 02:44:34", "url": "http://fideloper.com", "user_id": "1"] $ curl --user firstuser: first_password localhost / l4api / public / index.php / api / v1 / url / 1 "error": false, "urls": ["created_at": "2013-02-01 02:39:10", "description": "A Search Motore "," id ":" 2 "," updated_at ":" 2013-02-01 02:39:10 "," url ":" http://google.com "," user_id ":" 1 " ]
Quasi fatto. Consentiamo ora agli utenti di eliminare un URL.
/ ** * Rimuovi la risorsa specificata dalla memoria. * * @param int $ id * @return Risposta * / public function destroy ($ id) $ url = Url :: where ('user_id', Auth :: user () -> id) -> find ($ id) ; $ Url-> delete (); return Response :: json (array ('error' => false, 'message' => 'url cancellato'), 200); Ora, possiamo cancellare un URL usando una richiesta DELETE:
$ curl -i -X DELETE --user firstuser: first_password localhost / l4api / public / index.php / api / v1 / url / 1 HTTP / 1.1 200 OK Data: mar, 21 maggio 2013 19:24:19 GMT Content- Tipo: application / json "error": false, "message": "url cancellato"
Infine, consentiamo agli utenti di aggiornare un URL.
/ ** * Aggiorna la risorsa specificata nella memoria. * * @param int $ id * @return Risposta * / aggiornamento funzione pubblica ($ id) $ url = Url :: where ('user_id', Auth :: user () -> id) -> find ($ id) ; if (Request :: get ('url')) $ url-> url = Request :: get ('url'); if (Request :: get ('description')) $ url-> description = Request :: get ('description'); $ url-> save (); return Response :: json (array ('error' => false, 'message' => 'url updated'), 200); Per testare gli aggiornamenti URL, eseguire:
$ curl -i -X PUT --user seconduser: second_password -d 'url = http: //yahoo.com' localhost / l4api / public / index.php / api / v1 / url / 4 HTTP / 1.1 200 OK Data: Mar 21 Mag 2013 19:34:21 GMT Content-Type: application / json "error": false, "message": "url updated" // Visualizza le nostre modifiche $ curl --user seconduser: second_password localhost / l4api /public/index.php/api/v1/url/4 "error": false, "urls": ["created_at": "2013-02-01 02:44:34", "description": "I sentirsi per lui "," id ":" 3 "," updated_at ":" 2013-02-02 18:44:18 "," url ":" http://yahoo.com "," user_id ":" 1 "]
Ora abbiamo l'inizio di un'API pienamente funzionante. Spero che tu abbia imparato molto su come ottenere un'API in corso con Laravel 4.
Per riassumere, abbiamo ottenuto quanto segue in questa lezione:
Se desideri spingere la tua API su una tacca, potresti considerare uno dei seguenti passaggi successivi.
