Share
REstaatentational State Transfer (REST) is een ontwerpstijl voor webontwikkelingsarchitectuur die verwijst naar het logisch scheiden van uw API-bronnen om gemakkelijke toegang, manipulatie en schaalvergroting mogelijk te maken. Herbruikbare componenten worden op een manier geschreven, zodat ze eenvoudig kunnen worden beheerd via eenvoudige en intuïtieve HTTP-verzoeken die GET, POST, PUT, PATCH en DELETE kunnen zijn (er kunnen meer zijn, maar hierboven zijn de meest gebruikte).
Ondanks hoe het eruit ziet, beveelt REST geen protocol of standaard. Het zet gewoon een softwarearchitectuurstijl voor het schrijven van webtoepassingen en API's en resulteert in een vereenvoudiging van de interfaces binnen en buiten de applicatie. API's voor webservices die zo zijn geschreven dat ze de REST-principes volgen, heten ze RESTful API's.
In deze drieledige zelfstudiereeks zal ik verschillende manieren bespreken waarop RESTful API's kunnen worden gemaakt met behulp van Flask als een webraamwerk. In het eerste deel zal ik ingaan op het maken van op klassen gebaseerde REST API's die meer op DIY (Do it yourself) lijken, d.w.z. ze allemaal zelf implementeren zonder extensies van derden te gebruiken. In de laatste delen van deze serie zal ik bespreken hoe verschillende Fusion-extensies kunnen worden gebruikt om effectievere REST API's op een eenvoudigere manier te bouwen.
Ik neem aan dat je een basiskennis hebt van de praktische tips voor het instellen van de Flask en de omgeving met behulp van virtualenv om te volgen tijdens het ontwikkelen van een Python-applicatie.
De volgende pakketten moeten worden geïnstalleerd voor de toepassing die we gaan ontwikkelen.
$ pip install flask $ pip install flask-sqlalchemy
De bovenstaande opdrachten moeten alle vereiste pakketten installeren die nodig zijn om deze toepassing te laten werken.
Voor deze tutorial zal ik een kleine applicatie maken waarin ik een triviaal model zal maken Artikel. Vervolgens zal ik laten zien hoe we een RESTful API voor hetzelfde kunnen schrijven. Hieronder ziet u de structuur van de toepassing.
flask_app / mijn_app / - __init__.py product / - __init__.py // Leeg bestand - models.py - views.py - run.py
Ik zal geen front-end voor deze toepassing maken omdat RESTful API's-eindpunten direct kunnen worden getest door HTTP-oproepen te maken met behulp van verschillende andere methoden.
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy app = Flask (__ name__) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ////tmp/test.db' db = SQLAlchemy (app) van my_app.catalog .views importcatalogus app.register_blueprint (catalogus) db.create_all ()
In het bovenstaande bestand is de applicatie geconfigureerd met de initialisatie van de extensies en uiteindelijk het maken van de database. Met de laatste instructie wordt een nieuwe database gemaakt op de locatie die wordt aangeboden SQLALCHEMY_DATABASE_URI als een database nog niet op die locatie bestaat, anders laadt het de applicatie met dezelfde database.
from my_app import db class Product (db.Model): id = db.Column (db.Integer, primary_key = True) name = db.Column (db.String (255)) price = db.Column (db.Float (asdecimal = Waar)) def __init __ (zelf, naam, prijs): self.name = naam self.price = price def __repr __ (self): return ''% self.id
In het bovenstaande bestand heb ik een heel triviaal model gemaakt voor het opslaan van de naam en prijs van een Artikel. Hiermee wordt een tabel gemaakt in SQLite overeenkomend met de gegevens in het model.
Accentsconagua
import json uit kolf importverzoek, jsonify, Blueprint, abort van flask.views import MethodView uit my_app import db, app uit my_app.catalog.models import Productcatalogus = Blauwdruk ('catalogus', __name__) @ catalog.route ('/' ) @ catalog.route ('/ home') def home (): terug "Welkom bij de catalogus." class ProductView (MethodView): def get (self, id = None, page = 1): if not id: products = Product.query.paginate (page, 10) .items res = voor product in producten: res [product .id] = 'name': product.name, 'price': str (product.price), else: product = Product.query.filter_by (id = id). first () if not product: abort (404 ) res = 'name': product.name, 'price': str (product.price), return jsonify (res) def post (self): name = request.form.get ('name') price = request .form.get ('price') product = Product (naam, prijs) db.session.add (product) db.session.commit () return jsonify (product.id: 'name': product.name, ' price ': str (product.price),) def put (self, id): # Update de record voor het opgegeven id # met de verstrekte gegevens. return def delete (self, id): # Verwijder de record voor de opgegeven id. return product_view = ProductView.as_view ('product_view') app.add_url_rule ('/ product /', view_func = product_view, methods = ['GET', 'POST']) app.add_url_rule ('/ product /', view_func = product_view, methods = [' GET ']) De belangrijkste kern van deze zelfstudie wordt behandeld in het bovenstaande bestand. Flask biedt een hulpprogramma met inplugbare weergaven, waarmee u weergaven kunt maken in de vorm van klassen in plaats van normaal als functies. Methode-gebaseerde dispatching (MethodView) is een implementatie van pluggable views waarmee u methoden kunt schrijven die overeenkomen met de HTTP-methoden in kleine letters. In het bovenstaande voorbeeld heb ik geschreven methoden krijgen() en post() overeenkomend met HTTP's KRIJGEN en POST respectievelijk.
Routing wordt ook op een andere manier geïmplementeerd, in de laatste paar regels van het bovenstaande bestand. We kunnen de methoden specificeren die door een bepaalde regel zullen worden ondersteund. Elke andere HTTP-oproep zou worden voldaan Fout 405 Methode niet toegestaan.
Voer het script uit om de toepassing uit te voeren run.py. De inhoud van dit script is:
van my_app import app app.run (debug = True)
Voer nu uit vanaf de opdrachtregel:
$ python run.py
Als u wilt controleren of de toepassing werkt, start u http://127.0.0.1:5000/ in uw browser en een eenvoudig scherm met een welkomstbericht zou u moeten begroeten.
Om deze API te testen, kunnen we eenvoudig HTTP-oproepen maken met behulp van een van de vele beschikbare methoden. GET-oproepen kunnen rechtstreeks via de browser worden gedaan. POST-oproepen kunnen worden gedaan met behulp van een Chrome-extensie zoals Postman of via de opdrachtregel met Krul, of we kunnen Python's gebruiken verzoeken bibliotheek om het werk voor ons te doen. Ik zal de verzoekenbibliotheek hier gebruiken voor demonstratiedoeleinden.
Laten we een ... maken KRIJGEN bel eerst om te verzekeren dat we nog geen producten hebben gemaakt. Vanaf het ontwerp van RESTful API's, een get call die er ongeveer zo uitziet /artikel/ zou alle producten moeten vermelden. Vervolgens maak ik een aantal producten door te maken POST oproepen naar /artikel/ met wat gegevens. Dan een KRIJGEN bellen naar /artikel/ moet alle gemaakte producten vermelden. Om een specifiek product op te halen, KRIJGEN bellen naar /artikel/ zou het werk moeten doen. Hieronder staat een voorbeeld van alle oproepen die met dit voorbeeld kunnen worden gedaan.
$ pip install requests $ python >>> import requests >>> r = requests.get ('http: // localhost: 5000 / product /') >>> r.json () >>> r = aanvragen. post ('http: // localhost: 5000 / product /', data = 'name': 'iPhone 6s', 'price': 699) >>> r.json () u'1 ': u 'prijs': u'699.0000000000 ', u'name': u'iPhone 6s ' >>> r = requests.post (' http: // localhost: 5000 / product / ', data = ' name ': 'iPad Pro', 'prijs': 999) >>> r.json () u'2 ': u'price': u'999.0000000000 ', u'name': u'iPad Pro '> >> r = requests.get ('http: // localhost: 5000 / product /') >>> r.json () u'1 ': u'price': u'699.0000000000 ', u'name' : u'iPhone 6s ', u'2': u'price ': u'999.0000000000', u'name ': u'iPad Pro' >>> r = requests.get ('http: // localhost: 5000 / product / 1 ') >>> r.json () u'price': u'699.0000000000 ', u'name': u'iPhone 6s 'In deze zelfstudie zag je hoe je RESTful-interfaces helemaal alleen kunt maken met behulp van het hulpprogramma Pluggable views van Flask. Dit is de meest flexibele benadering bij het schrijven van REST-API's, maar er is veel meer code voor nodig om te worden geschreven.
Er zijn extensies die het leven een beetje gemakkelijker maken en de implementatie van RESTful API's in grote mate automatiseren. Ik zal deze in de volgende delen van deze tutorialserie behandelen.
