13-flask部落格專案之restful api詳解2-使用

from flask import Flask
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)

class HelloWorld(Resource):
    def get(self):
        return {'hello': 'world'}

api.add_resource(HelloWorld, '/')

if __name__ == '__main__':
    app.run(debug=True)

from flask import Blueprint
from flask_restful import Resource
from exts import api
user_bp = Blueprint('user', __name__, url_prefix='/api')

# 定義類檢視
class UserResource(Resource):
    # get 請求的處理
    def get(self):
        return {'msg': '------>get'}

    # post
    def post(self):
        return {'msg': '------>post'}

    # put
    def put(self):
        return {'msg': '------>put'}

    # delete
    def delete(self):
        return {'msg': '------>delete'}


api.add_resource(UserResource, '/user')

from flask import Blueprint
from flask_restful import Resource, marshal_with, fields
from exts import api
user_bp = Blueprint('user', __name__, url_prefix='/api')
from apps.user.model import User

user_fields = {
    'id': fields.Integer,
    'username': fields.String,
    'password': fields.String,
    'udatetime': fields.DateTime
}

# 定義類檢視
class UserResource(Resource):
    # get 請求的處理
    @marshal_with(user_fields)
    def get(self):
        users = User.query.all()
        # userList = []
        # for user in users:
        #     userList.append(user.__dict__)
        return users

    # post
    def post(self):
        return {'msg': '------>post'}

    # put
    def put(self):
        return {'msg': '------>put'}

    # delete
    def delete(self):
        return {'msg': '------>delete'}


api.add_resource(UserResource, '/user')

什麼是RESTful架構：

（1）每一個URI代表一種資源；

（2）使用者端和伺服器之間，傳遞這種資源的某種表現層；

（3）使用者端通過四個HTTP動詞(GET,POST,PUT,DELETE,[PATCH])，對伺服器端資源進行操作，實現"表現層狀態轉化"。

Postman

前後端分離：
前端： app，小程式，pc頁面

後端： 沒有頁面，mtv： 模型模板檢視  去掉了t模板。
      mv：模型 檢視
      模型的使用：跟原來的用法相同
      檢視： api構建檢視
  步驟：
     1. pip3 install flask-restful

     2.建立api物件
      api = Api(app=app)
      api = Api(app=藍圖物件)
     3.
      定義類檢視：
      from flask_restful import Resource
      class xxxApi(Resource):
        def get(self):
            pass

        def post(self):
            pass

        def put(self):
            pass

        def delete(self):
            pass
      4. 繫結

      api.add_resource(xxxApi,'/user')

from flask import Blueprint
from flask_restful import Resource, marshal_with, fields
from exts import api
user_bp = Blueprint('user', __name__, url_prefix='/api')
from apps.user.model import User

user_fields = {
    'id': fields.Integer,
    'username': fields.String,
    'password': fields.String,
    'udatetime': fields.DateTime
}

# 定義類檢視
class UserResource(Resource):
    # get 請求的處理
    @marshal_with(user_fields)
    def get(self):
        users = User.query.all()
        # userList = []
        # for user in users:
        #     userList.append(user.__dict__)
        return users
    # post
    def post(self):
        return {'msg': '------>post'}
    # put
    def put(self):
        return {'msg': '------>put'}
    # delete
    def delete(self):
        return {'msg': '------>delete'}

class UserSimpleResource(Resource):
    @marshal_with(user_fields)  # user轉成一個序列化物件，
    def get(self, id):
        user = User.query.get(id)
        return user  # 不是str，list，int，。。。

    def put(self, id):
        pass

    def delete(self, id):
        pass

api.add_resource(UserResource, '/user')
api.add_resource(UserSimpleResource, '/user/<int:id>')

from flask_restful import reqparse

parser = reqparse.RequestParser()
parser.add_argument('foo', type=int)

parser_copy = parser.copy()
parser_copy.add_argument('bar', type=int)

# parser_copy has both 'foo' and 'bar'

parser_copy.replace_argument('foo', required=True, location='json')
# 'foo' is now a required str located in json, not an int as defined
#  by original parser

parser_copy.remove_argument('foo')
# parser_copy no longer has 'foo' argument

from flask_restful import reqparse

parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('foo', type=int, required=True)
parser.add_argument('bar', type=int, required=True)

# If a request comes in not containing both 'foo' and 'bar', the error that
# will come back will look something like this.

{
    "message":  {
        "foo": "foo error message",
        "bar": "bar error message"
    }
}

# The default behavior would only return the first error

parser = RequestParser()
parser.add_argument('foo', type=int, required=True)
parser.add_argument('bar', type=int, required=True)

{
    "message":  {
        "foo": "foo error message"
    }
}

from flask_restful import reqparse

parser = reqparse.RequestParser()
parser.add_argument(
    'foo',
    choices=('one', 'two'),
    help='Bad choice: {error_msg}'
)

# If a request comes in with a value of "three" for `foo`:

{
    "message":  {
        "foo": "Bad choice: three is not a valid choice",
    }
}

from flask_restful import Resource, fields, marshal_with

resource_fields = {
    'name': fields.String,
    'address': fields.String,
    'date_updated': fields.DateTime(dt_format='rfc822'),
}

class Todo(Resource):
    @marshal_with(resource_fields, envelope='resource')
    def get(self, **kwargs):
        return db_get_todo()  # Some function that queries the db

fields = {
    'name': fields.String(attribute='private_name'),
    'address': fields.String,
}

1.需要定義字典，字典的格式就是給使用者端看的格式
user_fields = {
    'id': fields.Integer,
    'username': fields.String(default='匿名'),
    'pwd': fields.String(attribute='password'),
    'udatetime': fields.DateTime(dt_format='rfc822')
}

使用者端能看到的是： id，username，pwd，udatetime這四個key
預設key的名字是跟model中的模型屬性名一致，如果不想讓前端看到命名，則可以修改
但是必須結合attribute='模型的欄位名'

fields = {
    'name': fields.String(attribute=lambda x: x._private_name),
    'address': fields.String,
}

fields = {
    'name': fields.String(attribute='people_list.0.person_dictionary.name'),
    'address': fields.String,
}

fields = {
    'name': fields.String(default='Anonymous User'),
    'address': fields.String,
}

class UrgentItem(fields.Raw):
    def format(self, value):
        return "Urgent" if value & 0x01 else "Normal"

class UnreadItem(fields.Raw):
    def format(self, value):
        return "Unread" if value & 0x02 else "Read"

fields = {
    'name': fields.String,
    'priority': UrgentItem(attribute='flags'),
    'status': UnreadItem(attribute='flags'),
}

class RandomNumber(fields.Raw):
    def output(self, key, obj):
        return random.random()

fields = {
    'name': fields.String,
    # todo_resource is the endpoint name when you called api.add_resource()
    'uri': fields.Url('todo_resource'),
    'random': RandomNumber,
}

fields = {
    'uri': fields.Url('todo_resource', absolute=True)
    'https_uri': fields.Url('todo_resource', absolute=True, scheme='https')
}

>>> from flask_restful import fields, marshal
>>> import json
>>>
>>> resource_fields = {'name': fields.String}
>>> resource_fields['address'] = {}
>>> resource_fields['address']['line 1'] = fields.String(attribute='addr1')
>>> resource_fields['address']['line 2'] = fields.String(attribute='addr2')
>>> resource_fields['address']['city'] = fields.String
>>> resource_fields['address']['state'] = fields.String
>>> resource_fields['address']['zip'] = fields.String
>>> data = {'name': 'bob', 'addr1': '123 fake street', 'addr2': '', 'city': 'New York', 'state': 'NY', 'zip': '10468'}
>>> json.dumps(marshal(data, resource_fields))
'{"name": "bob", "address": {"line 1": "123 fake street", "line 2": "", "state": "NY", "zip": "10468", "city": "New York"}}'

  File "D:\softwareinstall\python3\lib\site-packages\sqlalchemy\util\compat.py", line 208, in raise_
    raise exception
sqlalchemy.exc.AmbiguousForeignKeysError: Could not determine join condition between parent/child tables on relationship User.friends - there are multiple foreign key paths linking the tables.  Specify th
e 'foreign_keys' argument, providing a list of those columns which should be counted as containing a foreign key reference to the parent table.

>>> from flask_restful import fields, marshal
>>> import json
>>>
>>> resource_fields = {'name': fields.String, 'first_names': fields.List(fields.String)}
>>> data = {'name': 'Bougnazal', 'first_names' : ['Emile', 'Raoul']}
>>> json.dumps(marshal(data, resource_fields))
>>> '{"first_names": ["Emile", "Raoul"], "name": "Bougnazal"}'

>>> from flask_restful import fields, marshal
>>> import json
>>>
>>> address_fields = {}
>>> address_fields['line 1'] = fields.String(attribute='addr1')
>>> address_fields['line 2'] = fields.String(attribute='addr2')
>>> address_fields['city'] = fields.String(attribute='city')
>>> address_fields['state'] = fields.String(attribute='state')
>>> address_fields['zip'] = fields.String(attribute='zip')
>>>
>>> resource_fields = {}
>>> resource_fields['name'] = fields.String
>>> resource_fields['billing_address'] = fields.Nested(address_fields)
>>> resource_fields['shipping_address'] = fields.Nested(address_fields)
>>> address1 = {'addr1': '123 fake street', 'city': 'New York', 'state': 'NY', 'zip': '10468'}
>>> address2 = {'addr1': '555 nowhere', 'city': 'New York', 'state': 'NY', 'zip': '10468'}
>>> data = { 'name': 'bob', 'billing_address': address1, 'shipping_address': address2}
>>>
>>> json.dumps(marshal_with(data, resource_fields))
'{"billing_address": {"line 1": "123 fake street", "line 2": null, "state": "NY", "zip": "10468", "city": "New York"}, "name": "bob", "shipping_address": {"line 1": "555 nowhere", "line 2": null, "state": "NY", "zip": "10468", "city": "New York"}}'

user_fields = {
    'id': fields.Integer(attribute='id'),
    'private_name': fields.String(attribute='username',default='匿名'),
    'password': fields.String,
    'isDelete': fields.Boolean(attribute='isdelete'),
    'isDelete1': IsDelete(attribute='isdelete'),
    'udatetime': fields.DateTime(dt_format='rfc822')
}



user_friend_fields = {
    'username': fields.String,
    'nums': fields.Integer,
    'friends': fields.List(fields.Nested(user_fields))
}

class UserFriendResource(Resource):
    @marshal_with(user_friend_fields)
    def get(self, id):
        friends = Friend.query.filter(Friend.uid == id).all()
        user = User.query.get(id)

        friend_list = []
        for friend in friends:
            u = User.query.get(friend.fid)
            friend_list.append(u)

        data = {
            'username': user.username,
            'nums': len(friends),
            'friends': friend_list  # [user,user,user]
        }
        return data

什麼是RESTful架構：

（1）每一個URI代表一種資源；

（2）使用者端和伺服器之間，傳遞這種資源的某種表現層；

（3）使用者端通過四個HTTP動詞(GET,POST,PUT,DELETE,[PATCH])，對伺服器端資源進行操作，實現"表現層狀態轉化"。

Postman

前後端分離：
前端： app，小程式，pc頁面

後端： 沒有頁面，mtv： 模型模板檢視  去掉了t模板。
      mv：模型 檢視
      模型的使用：跟原來的用法相同
      檢視： api構建檢視
  步驟：
     1. pip3 install flask-restful

     2.建立api物件
      api = Api(app=app)
      api = Api(app=藍圖物件)
     3.
      定義類檢視：
      from flask_restful import Resource
      class xxxApi(Resource):
        def get(self):
            pass

        def post(self):
            pass

        def put(self):
            pass

        def delete(self):
            pass
      4. 繫結

      api.add_resource(xxxApi,'/user')

參照：http://www.pythondoc.com/Flask-RESTful/quickstart.html
https://flask-restful.readthedocs.io/en/latest/


路由：
@app.route('/user')
def user():              -------》檢視函數
    .....
    return response物件

增加  修改   刪除   查詢  按鈕動作

http://127.0.0.1:5000/user?id=1
http://127.0.0.1:5000/user/1


restful: ---->api ----> 介面 ---->資源 ----> url

class xxx（Resource）：  -------> 類檢視
    def get(self):
        pass
    ....

http://127.0.0.1:5000/user
get
post
put
delete
增加  修改   刪除   查詢  是通過請求方式完成的

路徑產生:
api.add_resource(Resource的子類，'/user')
api.add_resource(Resource的子類，'/goods')
api.add_resource(Resource的子類，'/order')

endpoint:
http://127.0.0.1:5000/user/1

http://127.0.0.1:5000/goods?type=xxx&page=1&sorted=price   ----》get


----------------進：請求引數傳入-------------------

步驟：
1。建立RequestParser物件：
# 引數解析
parser = reqparse.RequestParser(bundle_errors=True)  # 解析物件
2。給解析器新增引數：
    通過parser.add_argument('名字'，type=型別，required=是否必須填寫，help=錯誤的提示資訊，location=表明獲取的位置form就是post表單提交)
    注意在type的位置可以新增一些正則的驗證等。
    例如：
    parser.add_argument('username', type=str, required=True, help='必須輸入使用者名稱', location=['form'])
    parser.add_argument('password', type=inputs.regex(r'^\d{6,12}$'), required=True, help='必須輸入6~12位元數位密碼',
                        location=['form'])
    parser.add_argument('phone', type=inputs.regex(r'^1[356789]\d{9}$'), location=['form'], help='手機號碼格式錯誤')
    parser.add_argument('hobby', action='append')  # ['籃球', '遊戲', '旅遊']
    parser.add_argument('icon', type=FileStorage, location=['files'])
只要新增上面的內容，就可以控制使用者端的提交，以及提交的格式。
3。在請求的函數中獲取資料：
  可以在get，post，put等中獲取資料，通過parser物件.parse_args()
  # 獲取資料
  args = parser.parse_args()
  args是一個字典底層的結構中，因此我們獲取具體的資料時可以通過get
  username = args.get('username')
  password = args.get('password')

------------輸出-----------------


1.需要定義字典，字典的格式就是給使用者端看的格式
user_fields = {
    'id': fields.Integer,
    'username': fields.String(default='匿名'),
    'pwd': fields.String(attribute='password'),
    'udatetime': fields.DateTime(dt_format='rfc822')
}

使用者端能看到的是： id，username，pwd，udatetime這四個key
預設key的名字是跟model中的模型屬性名一致，如果不想讓前端看到命名，則可以修改
但是必須結合attribute='模型的欄位名'

自定義fields
1。必須繼承Raw
2。重寫方法：
   def format(self):
        return 結果

class IsDelete(fields.Raw):
    def format(self, value):
        print('------------------>', value)
        return '刪除' if value else '未刪除'
user_fields = {
    。。。
    'isDelete1': IsDelete(attribute='isdelete'),
    。。。
}

URI:

xxxlist ----->點選具體的一個獲取詳情 ------> 詳情

定義兩個user_fields,
1.用於獲取使用者的列表資訊結構的fields：
user_fields_1 = {
    'id': fields.Integer,
    'username': fields.String(default='匿名'),
    'uri': fields.Url('single_user', absolute=True)  ----》引數使用的就是endpoint的值
}

2。具體使用者資訊展示的fields
user_fields = {
    'id': fields.Integer,
    'username': fields.String(default='匿名'),
    'pwd': fields.String(attribute='password'),
    'isDelete': fields.Boolean(attribute='isdelete'),
    'isDelete1': IsDelete(attribute='isdelete'),
    'udatetime': fields.DateTime(dt_format='rfc822')
}

涉及endpoint的定義：

api.add_resource(UserSimpleResource, '/user/<int:id>', endpoint='single_user')


出：
return data
注意：data必須是符合json格式
{
  'aa':10,
  'bb':[
     {
       'id':1,
       'xxxs':[
                {},{}
              ]
     },
     {

     }
  ]
}
如果直接返回不能有自定義的物件User，Friend，。。。。

如果有這種物件，需要：marchal(),marchal_with()幫助進行轉換。
1。marchal(物件，物件的fields格式)  # 物件的fields格式是指字典的輸出格式
   marchal([物件，物件]，物件的fields格式)

2。marchal_with() 作為裝飾器修飾請求方法

    @marshal_with(user_friend_fields)
    def get(self, id):
        。。。。
        return data

 函數需要引數，引數就是最終資料輸出的格式

 引數： user_friend_fields，型別是：dict型別
 例如：
 user_friend_fields = {
    'username': fields.String,
    'nums': fields.Integer,
    'friends': fields.List(fields.Nested(user_fields))
}

fields.Nested(fields.String)  ----> ['aaa','bbb','bbbc']
fields.Nested(user_fields)  -----> user_fields是一個字典結構，將裡面的每一個物件轉成user_fields
-----》[user,user,user]