原标題：10分鐘，帶你用Python建構RESTful API 服務
1. 前言
上一篇文章，介紹了使用 Java + Spring Boot + MyBatis 建構 RESTful API 的詳細步驟；很多小夥伴表示，更願意用 Python 編寫 RESTful API 服務，希望我能寫一下
本篇将以 Python 開始介紹搭建 RESTful API 的流程 ，使用的技術棧是：Flask + flask-restful + flasgger
2. 安裝依賴 使用 Python 編寫 RESTful API 之前，我們需要先在虛拟環境内安裝對應的依賴
具體包含：
Flask - 基礎 Web 架構
flask_restful - Flask 的擴充，增加了對快速建構 REST API 的支援
flasgger - flask 支援的 Swagger UI，可以生成 API 接口文檔# 安裝flask
pip3 install flask
# 安裝flask-restful
pip3 install flask-restful
# 安裝flasgger
# 注意：需要更新setuptools
pip3 install -U setuptools
pip3 install flasgger
# 管理資料庫的依賴
pip3 install flask_
pip3 install flask_migrate
3. Hello World
首先，我們使用 Pycharm 建立一個 Flask Web 項目，初始化代碼如下：
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world:
return 'Hello World!'
if __name__ == '__main__':
app.run
從 flask_restful 檔案中導入 Api、Resource 兩個類，使用上面的 app 對象，建構一個 api 對象，接着準備一個清單資料
from flask_restful import Api,Resource
app = Flask(__name__)
# 執行個體化一個 Api 對象，用來建立、管理 RESTful Api
api = Api(app)
# 準備一個清單資料
datas = [{'id': 1, 'name': 'xag', 'age': 18}, {'id': 2, 'name': 'xingag', 'age': 19}]
然後，利用 Flask 中的 CBV 模式，建立一個 Resource 類的子類，用于定義資源路由
這裡以 GET / POST 動作為例，重寫 get、post 方法，并編寫内部邏輯，傳回資料即可
class UserView(Resource):
"""
通過繼承 Resource 來實作調用 GET/POST 等動作方法
"""
def get(self):
"""
GET 請求
:return:
"""
return {'code': 200, 'msg': 'success', 'data': datas}
def post(self):
# 參數資料
json_data = request.get_json
# 追加資料到清單中
new_id = len(datas)+1
datas.append({'id':new_id,**json_data})
# 傳回新增的最後一條資料
return {'code': 200, 'msg': 'ok', 'success': datas[new_id - 1]}
最後，使用 Api 的執行個體對象，将上面定義的資源，利用路徑，完全暴露出去
# 暴露接口出去
# 資源路由：UserView
# 路徑：/user
api.add_resource(UserView,'/user')
運作程式後，就可以拿 Postman 或 cURL 去測試接口了
4. 項目實戰
在實際項目開發中，資料結構、層級關系往往要複雜很多，我們需要對項目進行一次整合，按功能進行封裝，具體步驟如下：
第 1 步， 編寫配置檔案
建立一個配置檔案 config.py，将資料庫( 以 Mysql 為例 )的連接配接資訊，包含：使用者名、密碼、端口号、資料庫名、連接配接驅動和 Swagger 的設定資訊追加進去
# config.py
USERNAME = 'root'
PASSWORD = 'root'
HOSTNAME = "127.0.0.1"
PORT = '3306'
DATABASE = 'xag'
DIALECT = 'mysql'
DRIVER = 'pymysql'
# 連接配接資料的URI
DB_URI = "{}+{}://{}:{}@{}:{}/{}?charset=utf8".format(DIALECT, DRIVER, USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)
SQLALCHEMY_DATABASE_URI = DB_URI
SQLALCHEMY_TRACK_MODIFICATIONS = True
SWAGGER_TITLE = "API"
SWAGGER_DESC = "API接口"
# 位址，必須帶上端口号
SWAGGER_HOST = "localhost:5000"
第 2 步， 模型映射資料庫
建立一個模型類 Foo 繼承 SQLAlchemy 對象，使用 __tablename__ 指定生成資料表的名稱、然後新增幾個常用字段
# models.py
from exts import db
class Foo(db.Model):
"""
模型，将映射到資料庫表中
"""
__tablename__ = 'foo'
# 主鍵ID
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
# 名字
name = db.Column(db.String(100), able=False)
# 年齡
age = db.Column(db.INTEGER)
接着，建立 manage.py 檔案
顯式導入上面建立的 Foo 類，使用 flask_migrate 中的 Migrate 綁定 App 和資料庫，利用 flask_ 中的 Manager 執行個體去添加一個腳本指令
# manager.py
from flask_migrate import Migrate, MigrateCommand
from flask_ import Manager
from exts import db
from api_app import app
from models import Foo
manager = Manager(app)
migrate=Migrate(app, db)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run
需要注意的是，Foo 模型必須顯式導入，否則沒法映射到資料庫中
最後，通過下面 3 個腳本指令，将模型映射到資料庫中
除了第一次需要生成遷移腳本外，後面映射資料庫，隻需要執行後面兩個指令即可
# 初始化遷移檔案
python3 manager.py db init
# 映射到檔案
python3 manager.py db migrate
# 映射到資料庫
python3 manager.py db upgrade
打開 Navicat For Mysql，即可以看到剛剛映射過來的資料表及遷移表
第 3 步， 建立資源路由
下面以建立清單查詢( GET )、單條記錄的查詢( GET )、更新( PUT )、新增( POST )、删除( DELETE )為例
flask_restful 中的 marshal_with 類可以作為裝飾器，定義到動作函數上，指定要傳回的字段；然後使用 SQLAlchemy ORM 操作資料庫，将資料直接進行傳回
比如：傳回擷取資料清單
# api_foo.py
from flask_restful import Resource, fields, marshal_with, request
class FooListApi(Resource):
# 定義要傳回的字段
resource_fields = {
'id': fields.Integer,
'name': fields.String,
'age': fields.String
}
# 裝飾器，定義傳回資料
@marshal_with(resource_fields)
def get(self):
"""
傳回所有記錄
:return:
"""
# 查詢資料庫
foos = db.session.query(Foo).all
return foos
對于新增一個對象( POST 動作)
# api_foo.py
class FooApi(Resource):
def post(self):
"""
建立一條記錄
:return:
"""
# 參數
params = request.get_json
name = params.get("name")
age = params.get("age")
# 建構一個模型
foo = Foo(name=name, age=age)
# 加入到資料庫
db.session.add(foo)
db.session.commit
return success("新增一條記錄成功！")
第 4 步， 傳回資料統一化
為了保證傳回的資料結構一緻，可以将傳回碼、傳回資訊及資料進行一次封裝，通過jsonify進行格式化傳回
# restful_utils.py
from flask import jsonify
class HttpCode(object):
ok = 200
un_auth_error = 401
params_error = 400
server_error = 500
def restful_result(code, message, data):
return jsonify({"code": code, "message": message, "data": data or {}})
def success(message="", data=None):
"""
正确傳回
:return:
"""
return restful_result(code=HttpCode.ok, message=message, data=data)
第 5 步， 暴露接口
使用 flask_restful 中的 Api 執行個體對象，将上面定義的資源路由暴露出去
#api_app.py
from flask_restful import Api
api = Api(app)
# 某一條記錄
api.add_resource(FooApi, '/api/v1/foo','/api/v1/foo/')
# 所有記錄
api.add_resource(FooListApi, '/api/v1/foos')
第 6 步， 自動生成接口文檔
Flask 中同樣可以利用 Swagger 自動生成接口幫助文檔
首先，從配置檔案 config.py 中讀取配置，執行個體化 Swagger 對象
#api_app.py
from flasgger import Swagger
# API可視化管理
swagger_config = Swagger.DEFAULT_CONFIG
# 标題
swagger_config['title'] = config.SWAGGER_TITLE
# 描述資訊
swagger_config['deion'] = config.SWAGGER_DESC
# Host
swagger_config['host'] = config.SWAGGER_HOST
# 執行個體化
swagger = Swagger(app,config=swagger_config)
然後，在資源路由的動作内新增 swagger 注釋内容，包含：請求方式、參數、響應資料、描述資訊等
具體可以參考：http://editor.swagger.io/#/
以擷取某一條資料為例：
class FooApi(Resource):
resource_fields = {
'id': fields.Integer,
'name': fields.String,
'age': fields.String
}
@marshal_with(resource_fields)
def get(self, id):
"""擷取使用者資訊
---
schemes:
- http
parameters:
- name: id
in: path
type: integer
required: true
default: 1
deion: 使用者id
responses:
200:
deion: 傳回使用者資訊
examples:
{
"id": 1,
"name": "xag",
"age":"18"
}
"""
foo = db.session.query(Foo).get(id)
return foo
最後，運作項目，通路下面的連結，即可以看到定義好的 RESTful API 服務了
http://localhost:5000/apidocs/#/
5. 最後
上面就是通過 Flask + flask_restful 單表實作 RESTful API 完整的流程了，項目中涉及的多表，隻需要更改資料庫的邏輯操作就可以了傳回搜狐，檢視更多
責任編輯：