Share
Les API RESTful sont difficiles! Il y a beaucoup d'aspects à concevoir et à écrire un succès. Par exemple, parmi les sujets que vous pourriez être amené à gérer, figurent l'authentification, l'hypermédia / HATEOS, la gestion des versions, les limites de débit et la négociation de contenu. Plutôt que de nous attaquer à tous ces concepts, concentrons-nous plutôt sur les bases de REST. Nous allons créer des points de terminaison JSON derrière un système d'authentification de base et apprendre quelques astuces de Laravel 4 au cours du processus..
Si vous avez besoin d’aide pour votre développement Laravel, essayez quelques-uns des scripts et des plugins Laravel utiles disponibles sur Envato Market..
Construisons une API pour une application simple Read-It-Later. Les utilisateurs pourront créer, lire, mettre à jour et supprimer les URL qu'ils souhaitent lire ultérieurement.
Prêt à plonger et à démarrer?
Créez une nouvelle installation de Laravel 4. Si vous maîtrisez l’utilisation de la CLI, essayez ce guide de démarrage rapide. Sinon, nous avons un tutoriel vidéo ici sur Nettuts + qui couvre le processus.
Nous allons d’abord créer une clé de chiffrement pour le hachage sécurisé des mots de passe. Vous pouvez le faire facilement en exécutant cette commande à partir de la racine de votre projet:
$ clé artisan php: générer
Alternativement, vous pouvez simplement éditer votre app / config / app.php Clé de cryptage:
Accentsconagua
/ * | --------------------------------------------------- --------------------------- | Clé de cryptage | --------------------------------------------------- --------------------------- | | Cette clé est utilisée par le service de cryptage Illuminate et doit être définie | à une longue chaîne aléatoire, sinon ces valeurs chiffrées ne seront pas | fais attention. Assurez-vous de le changer avant de déployer une application! | * / 'clé' => md5 ('il s'agit d'un moyen d'obtenir un jeu de clés de cryptage'), Une fois que vous avez une installation fonctionnelle de Laravel 4, vous pouvez commencer à vous amuser. Nous allons commencer par créer la base de données de l'application.
Cela nécessitera seulement deux tables de base de données:
Nous allons utiliser les migrations de Laravel pour créer et remplir la base de données..
modifier app / config / database.php et remplissez-le avec vos paramètres de base de données. Remarque: cela signifie créer une base de données à utiliser par cette application. Cet article suppose une base de données MySQL.
'connections' => array ('mysql' => array ('driver' => 'mysql', 'host' => 'localhost', 'database' => 'read_it_later', 'username' => 'votre_username', 'password' => 'your_password', 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => ",),), $ php artisan migrate: make create_users_table --table = utilisateurs --create $ php artisan migrate: make create_urls_table --table = urls --create
Ces commandes configurent les scripts de migration de base que nous utiliserons pour créer les tables de base de données. Notre travail consiste maintenant à les remplir avec les bonnes colonnes.
modifier app / database / migrations / SOME_DATE_create_users_table.php et ajouter à la up () méthode:
fonction publique up () Schema :: create ('utilisateurs', fonction (table $ Blueprint) $ table-> incréments ('id'); $ table-> chaîne ('nom d'utilisateur') -> unique (); $ table-> chaîne ('mot de passe'); $ table-> timestamps ();); Ci-dessus, nous définissons un nom d'utilisateur (qui devrait être unique), un mot de passe, ainsi que les horodatages. Enregistrez-le et modifiez-le maintenant app / database / migrations / SOME_DATE_create_urls_table.php, et ajouter à la up () méthode:
fonction publique up () Schema :: create ('urls', fonction (Blueprint $ table) $ table-> incréments ('id'); $ table-> entier ('utilisateur_id'); $ table-> chaîne ( 'url'); $ table-> chaîne ('description'); $ table-> horodatage ();); La seule remarque importante dans cet extrait est que nous créons un lien entre le url et utilisateurs table, via le identifiant d'utilisateur champ.
Nous pouvons utiliser les graines de Laravel pour créer quelques exemples d'utilisateurs..
Créer un fichier dans le app / base de données / graines dossier qui porte le même nom que la table à laquelle il correspond; dans notre cas, UserTableSeeder.php. Ajouter:
effacer(); User :: create (array ('username' => 'firstuser', 'password' => hachage :: make ('first_password'))); User :: create (array ('username' => 'seconduser', 'password' => Hash :: make ('second_password'))); Ensuite, assurez-vous que la classe Seeder est exécutée lorsque la base de données est créée. modifier app / database / seed / DatabaseSeeder.php:
fonction publique run () Eloquent :: unguard (); // Ajoute ou commente cette ligne $ this-> call ('UserTableSeeder'); Voici comment créer ces deux tables et insérer nos exemples d'utilisateurs..
// Créer les deux tables $ php artisan migrate // Créer les exemples d'utilisateurs $ php artisan db: seed
Laravel 4 continue à utiliser l'excellent ORM Eloquent. Cela rendra le processus de traitement des appels de base de données très facile. Nous aurons besoin d'un modèle par table.
Heureusement, Laravel est livré avec une configuration de modèle utilisateur, alors créons un modèle pour notre table urls.
Créer et éditer un fichier app / models / Url.php.
Authentification
Les filtres de Laravel peuvent gérer l'authentification pour nous. En particulier, Laravel est maintenant livré avec un filtre d'authentification de base, que nous pouvons utiliser comme modèle d'authentification rapide à utiliser avec nos requêtes d'API..
Si vous ouvrez
app / filters.php, vous verrez à quoi ça ressemble:Route :: filter ('auth.basic', function () return Auth :: basic (););Nous avons juste besoin de faire un ajustement. Par défaut, ce filtre recherche un champ "email" pour identifier l'utilisateur. Étant donné que nous utilisons des noms d'utilisateur plutôt que des adresses électroniques, nous devons simplement ajuster cette préférence. Changer la
Auth :: basic ()appelez en lui donnant notre champ nom d'utilisateur comme paramètre:Route :: filter ('auth.basic', function () return Auth :: basic ("nom d'utilisateur"););Itinéraires
Testons ceci. Créez un itinéraire, appelé
testauth, et assurez-vous que notreauth.basicle filtre passe devant.modifier
app / routes.php:Route :: get ('/ authtest', array ('before' => 'auth.basic', function () return View :: make ('hello');));Nous pouvons tester cela avec une requête curl. Depuis votre terminal, essayez de pointer vers votre version de Laravel. Dans le mien, cela ressemble à ceci (votre URL sera probablement différente!):
$ curl -i localhost / l4api / public / index.php / authtest HTTP / 1.1 401 non autorisé Date: mar, 21 mai 2013 18:47:59 GMT - authentifiez-vous: basique Vary: acceptez-encodez le contenu-Type: text / html ; charset = UTF-8 Informations d'identification non validesComme vous pouvez le constater, une demande non autorisée est détectée et un message "Invalid Credentials" (Informations d'identification non valides) est renvoyé avec un code d'état 401. Ensuite, essayez d'inclure l'authentification de base.
$ curl --utilisateur firstuser: first_password localhost / l4api / public / index.php / authtest HTTP / 1.1 200 OK Date: mar, 21 mai 2013 18:50:51 GMT Vary: code de contenu accepté-encodé: texte / html; jeu de caractères = UTF-8Bonjour le monde!
Ça a marché!
À ce stade, le travail de base de notre API est terminé. On a:
Vous connaissez peut-être les contrôleurs RESTful de Laravel. Ils existent toujours dans Laravel 4; Cependant, nous pouvons également utiliser les contrôleurs de ressources de Laravel, qui configurent certains paradigmes que nous pouvons utiliser pour créer une interface API cohérente. Nous allons utiliser un contrôleur Resourceful.
Voici une ventilation de ce que chaque méthode du contrôleur ingénieux va gérer. Veuillez noter que vous pouvez supprimer les itinéraires / resource / create et / resource / id / edit, car nous n'aurons pas besoin d'afficher les formulaires 'create' ou 'edit' dans une API..
$ php artisan controller: make UrlController
Ensuite, configurez une route pour utiliser le contrôleur et demandez à chaque route d'être authentifiée.
modifier app / routes.php et ajouter:
// Groupe de routes pour la gestion des versions d'API Route :: group (array ('prefix' => 'api / v1', 'before' => 'auth.basic'), function () Route :: resource ('url', 'UrlController');); Quelques choses se passent là-bas.
http://example.com/api/v1/url./ api / v1 / user.Remarque: Vous voudrez peut-être envisager des techniques de versioning plus avancées, telles que l’utilisation d’un Acceptez en-tête ou sous-domaine pouvant vous aider à pointer différentes versions d'API, bases de codes distinctes.
Modifier le nouveau app / controllers / UrlController.php fichier:
// Edite ceci: index de fonction public () return 'Hello, API';
Testons le:
$ curl -i localhost / l4api / public / index.php / api / v1 / url HTTP / 1.1 401 non autorisé Date: mar, 21 mai 2013 19:02:59 GMT Authentification WWW: Authentification de base: modification du type de contenu accepté-encodé : text / html; charset = UTF-8 Informations d'identification non valides. $ curl --user firstuser: first_password localhost / l4api / public / index.php / api / v1 / url HTTP / 1.1 200 OK Date: mar, 21 mai 2013 19:04:19 GMT Vary: Accept-Encoding Content-Type: text / html; charset = UTF-8 Bonjour, API
Nous avons maintenant un contrôleur de ressources avec authentification qui fonctionne et sommes prêts à ajouter des fonctionnalités.
modifier app / controllers / UrlController.php:
/ ** * Stocke une ressource nouvellement créée dans la mémoire. * * @return Response * / public function store () $ url = nouvelle URL; $ url-> url = Request :: get ('url'); $ url-> description = Request :: get ('description'); $ url-> user_id = Auth :: user () -> id; // La validation et le filtrage sont indispensables !! Sérieusement, je suis une mauvaise personne pour avoir laissé cela de côté. $ url-> save (); return Response :: json (array ('error' => false, 'urls' => $ urls-> toArray ()), 200); Il est temps de tester cela avec une autre requête curl. Celui-ci enverra une demande POST, qui correspondra à la le magasin() méthode créée ci-dessus.
$ curl -i --user firstuser: first_password -d 'url = http: //google.com&description=A moteur de recherche' localhost / l4api / public / index.php / api / v1 / url HTTP / 1.1 201 Date de création: Mardi , 21 mai 2013 19:10:52 GMT Type de contenu: application / json "erreur": faux, "message": "URL créée"
Cool! Créons un peu plus, pour nos deux utilisateurs.
$ curl --user firstuser: first_password -d 'url = http: //fideloper.com&description=A grand blogh' localhost / l4api / public / index.php / api / v1 / url $ curl --user seconduser: second_password -d 'url = http: //digitalsurgeons.com&description=A agence de marketing' localhost / l4api / public / index.php / api / v1 / url $ curl --user seconduser: second_password -d 'url = http: //www.poppstrong .com / & description = Je sens pour lui 'localhost / l4api / public / index.php / api / v1 / url
Ensuite, créons des méthodes pour récupérer les URL.
/ ** * Affiche une liste de la ressource. * * @return Response * / public function index () // Anciennement: return 'Hello, API'; $ urls = Url :: where ('user_id', Auth :: user () -> id) -> get (); return Response :: json (array ('error' => false, 'urls' => $ urls-> toArray ()), 200); / ** * Affiche la ressource spécifiée. * * @param int $ id * @return Response * / fonction publique show ($ id) // Assurez-vous que l'utilisateur actuel possède la ressource demandée $ url = Url :: where ('user_id', Auth :: user () - > id) -> où ('id', $ id) -> prendre (1) -> get (); return Response :: json (array ('error' => false, 'urls' => $ url-> toArray ()), 200); Testons-les:
$ curl --user firstuser: first_password localhost / l4api / public / index.php / api / v1 / url "erreur": false, "urls": ["created_at": "2013-02-01 02:39: 10 "," description ":" Un moteur de recherche "," 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 super blog "," id ":" 3 "," updated_at " : "2013-02-01 02:44:34", "url": "http://fideloper.com", "id_utilisateur": "1" $ curl --user premier utilisateur: premier_ mot de passe localhost / l4api / public / index.php / api / v1 / url / 1 "erreur": faux, "urls": ["created_at": "2013-02-01 02:39:10", "description": "A Rechercher Moteur "," id ":" 2 "," updated_at ":" 2013-02-01 02:39:10 "," url ":" http://google.com "," user_id ":" 1 " ]
Presque fini. Permettons maintenant aux utilisateurs de supprimer une URL.
/ ** * Supprime la ressource spécifiée de la mémoire. * * @param int $ id * @return Response * / fonction publique destroy ($ id) $ url = Url :: where ('user_id', Auth :: user () -> id) -> find ($ id) ; $ url-> delete (); return Response :: json (array ('erreur' => faux, 'message' => 'url supprimée'), 200); Maintenant, nous pouvons supprimer une URL en utilisant une requête DELETE:
$ curl -i -X DELETE --utilisateur firstuser: first_password localhost / l4api / public / index.php / api / v1 / url / 1 HTTP / 1.1 200 OK Date: mar, 21 mai 2013 19:24:19 GMT Contenu- Type: application / json "erreur": faux, "message": "URL supprimée"
Enfin, permettons aux utilisateurs de mettre à jour une URL.
/ ** * Met à jour la ressource spécifiée dans le stockage. * * @param int $ id * @return Response * / mise à jour de la fonction publique ($ 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); Pour tester les mises à jour d'URL, exécutez:
$ 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 Date: Mar, 21 mai 2013 19:34:21 GMT Content-Type: application / json "erreur": false, "message": "url mise à jour" // Afficher nos modifications $ 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 sentir pour lui "," id ":" 3 "," updated_at ":" 2013-02-02 18:44:18 "," url ":" http://yahoo.com "," user_id ":" 1 "]
Nous avons maintenant les débuts d'une API pleinement opérationnelle. J'espère que vous avez beaucoup appris sur la mise en place d'une API avec Laravel 4.
Pour récapituler, nous avons atteint les objectifs suivants dans cette leçon:
Si vous souhaitez pousser votre API d'un cran, vous pouvez envisager l'une des solutions suivantes comme étape suivante..
