Pythonでのインターフェースの実装例

インターフェイスの基本知識:

インターフェイスのテストについて簡単に説明します。現在、一般的に使用されている 2 つのインターフェイスは、http API と RPC プロトコル インターフェイスです。今日は主に次のことについて説明します。 http api インターフェイスは、パスを介した呼び出しを区別する方法です。 http プロトコル。リクエスト メッセージの形式はキーと値の形式で、戻りメッセージは通常、

インターフェイス プロトコル: http、webservice、rpc などです。

リクエストメソッド：get、postメソッド

リクエストパラメータの形式：

a. getリクエストはすべてurl?param=xxx¶m1=xxx

b.リクエストパラメータの種類には、application/json、application/x-www-form-urlencoded、multipart/form-data、text/html などが含まれます。

インターフェースの URL、パラメーターのタイプ、返された結果のデータ形式、インターフェースにヘッダー、Cookie、その他の情報があるかどうかも知る必要があります。

インターフェースの実装:

リクエストメソッド -get、インターフェースの書き込み:

 1 import flask 
 2 from flask import request 
 3 from flask import jsonify 
 4 import tools 
 5 import OP_db 
 6 import settings 
 7 ''' 
 8 flask： web框架，可以通过flask提供的装饰器@server.route()将普通函数转换为服务 
 9 登录接口，需要传url、username、passwd
 10 '''
 11 #创建一个服务，把当前这个python文件当做一个服务
 12 server = flask.Flask(__name__)
 13 #server.config['JSON_AS_ASCII'] = False
 14 
 15 # @server.route()可以将普通函数转变为服务  登录接口的路径、请求方式
 16 @server.route('/login', methods=['get'])
 17 def login():
 18     # 获取通过url请求传参的数据19     username = request.values.get('name')
 20     # 获取url请求传的密码，明文
 21     pwd = request.values.get('pwd')
 22     # 判断用户名、密码都不为空，如果不传用户名、密码则username和pwd为None
 23     if username and pwd:
 24         # 获取加密后的密码
 25         password = tools.md5_pwd(pwd)
 26         #执行sql，如果查询的username和password不为空，说明数据库存在admin的账号
 27         sql = 'select name,password from test where name= "%s" and password= "%s";' %(username, password)
 28         # 从数据查询结果后，res返回是元组
 29         res = OP_db.getconn(
 30             host=settings.mysql_info['host'],
 31             user=settings.mysql_info['user'],
 32             passwd=settings.mysql_info['pwd'],
 33             db=settings.mysql_info['db'],
 34             port=settings.mysql_info['port'],
 35             sql=sql
 36         )
 37         if res:      #res的结果不为空，说明找到了username=admin的用户，且password为加密前的123456
 38             resu = {'code': 200, 'message': '登录成功'}
 39             return jsonify(resu) #将字典转换为json串, json是字符串
 40         else:
 41             resu = {'code': -1, 'message': '账号/密码错误'}
 42             return jsonify(resu)
 43     else:
 44         res = {'code': 999, 'message': '必填参数未填写'}
 45         return jsonify(res)
 46 
 47 if __name__ == '__main__':
 48       server.run(debug=True, port=8888, host=0.0.0.0)  #指定端口、host,0.0.0.0代表不管几个网卡，任何ip都可以访问

md5暗号化、データベースmysql操作の詳細は、私の他のブログを参照してください~~~~~

アクセスインターフェースを取得:

プロジェクトが起動された後のインターフェースアドレスは http://127.0.0.1:5000/ で、デフォルトのポートは 5000 です。

ブラウザを開いて、URL http://127.0.0.1:5000/xxx?name=xxx&pwd=123456 を入力し、その後にインターフェイス アドレス ログインを入力します。パラメーターと URL は直接使用できますか? Connected では、各リクエスト パラメータが & を使用して直接接続されます。 リクエストが成功すると、{'code': 200, 'message': 'Login success'} が返されます。

リクエストメソッド -post、インターフェイス書き込み:

 1 import flask 
 2 from flask import jsonify 
 3 from flask import request 
 4 from conf import opMysql 
 5 from conf import md5_create 
 6 ''' 
 7 注册接口： 
 8 post请求，请求参数入参类型json 
 9 {
 10     "username":"aaa",
 11     "pwd":"123456",
 12     "c_pwd":"123456"
 13 }
 14 '''
 15 server = flask.Flask(__name__)
 16 @server.route('/register', methods=['GET', 'POST'])
 17 def registerPost():
 18     #判断接口的请求方式是GET还是POST
 19     if request.method == 'POST':
 20         # 获取请求参数是json格式，返回结果是字典
 21         params = request.json
 22         username = params.get('username')
 23         pwd = params.get('pwd')
 24         confirmpwd = params.get('confirmpwd')
 25         if username and pwd and confirmpwd:  # 判断输入的用户名、密码、确认密码都不为空
 26             select_sql = 'select username from lhldemo  where username = "%s" ;'%username
 27             # 查询注册的用户是否存在数据库，如果存在，则username不为空，否则username为空
 28             res_mysql = opMysql.op_select(select_sql)
 29             if res_mysql:
 30                 return jsonify({"code": 999, "mesg": "用户已注册"})
 31             else:
 32                 if pwd == confirmpwd:  # 判断pwd和confirmpwd一致
 33                     new_pwd = md5_create.md5_test(pwd)  # 加密后的密码
 34                     insert_sql = 'insert into lhldemo(username,password) values("%s", "%s") ;' % (username, new_pwd)
 35                     opMysql.op_insert(insert_sql)
 36                     return jsonify({"code": 200, "msg": "注册成功"})
 37                 else:
 38                     return jsonify({"code":998, "msg":"密码不一样"})
 39         else:
 40             return jsonify({"code": 504, "msg": "必填项不能为空"})
 41     else:
 42         return jsonify({"code": 201, "msg": "请求方式不正确"})
 43 
 44 if __name__ == '__main__':
 45     #port可以指定端口，默认端口是5000
 46     #host写成0.0.0.0的话，其他人可以访问，代表监听多块网卡上面，默认是127.0.0.1
 47     server.run(debug=True, port=8899, host='0.0.0.0')

ポストアクセスインターフェイス:

プロジェクト開始後のインターフェイスアドレスは: 127.0.0.1:5000/、デフォルトポートは5000です。

ブラウザを開き、URL http://127.0.0.1:5000/xxx を入力し、その後にインターフェイス レジスタのアドレスを入力します。postman または jmeter を使用してパラメータをリクエストします。パラメータのタイプは json です。リクエストが成功すると、{'code': 200, 'message': 'Login success'} が返されます。

リクエストメソッド - get と post の両方にアクセスできます。記述は次のとおりです:

 1 import flask 
 2 from flask import jsonify 
 3 from flask import request 
 4 from conf import opMysql 
 5 from conf import md5_create 
 6 ''' 
 7 注册接口： 
 8 post请求，请求参数入参类型json 
 9 {
 10     "username":"aaa",
 11     "pwd":"123456",
 12     "c_pwd":"123456"
 13 }
 14 '''
 15 server = flask.Flask(__name__)
 16 @server.route('/register', methods=['get', 'post'])
 17 def registerPost():
 18     #post请求获取请求的参数，返回结果类型是str
 19     username = request.values.get('username')
 20     pwd = request.values.get('pwd')
 21     confirmpwd = request.values.get('confirmpwd')
 22     if username and pwd and confirmpwd:  # 判断输入的用户名、密码、确认密码都不为空
 23         select_sql = 'select username from lhldemo  where username = "%s" ;'%username
 24         # 查询注册的用户是否存在数据库，如果存在，则username不为空，否则username为空
 25         res_mysql = opMysql.op_select(select_sql)
 26         if res_mysql:
 27             return jsonify({"code": 999, "mesg": "用户已注册"})
 28         else:
 29             if pwd == confirmpwd:  # 判断pwd和confirmpwd一致
 30                 new_pwd = md5_create.md5_test(pwd)  # 加密后的密码
 31                 insert_sql = 'insert into lhldemo(username,password) values("%s", "%s") ;' % (username, new_pwd)
 32                 opMysql.op_insert(insert_sql)
 33                 return jsonify({"code": 200, "msg": "注册成功"})
 34             else:
 35                 return jsonify({"code": 998, "msg": "密码不一样"})
 36     else:
 37         return jsonify({"code": 504, "msg": "必填项不能为空"})
 38 
 39 
 40 if __name__ == '__main__':
 41     #port可以指定端口，默认端口是5000
 42     #host默认是127.0.0.1,写成0.0.0.0的话，其他人可以访问，代表监听多块网卡上面，
 43     server.run(debug=True, port=8899, host='0.0.0.0')

投稿リクエストは次の 2 つの方法で行うことができます。1 つは次のとおりです:

URL を介してパラメータを結合します:

2 番目のアクセス方法: キーと値の方法によるアクセス:

redis 関連の操作、redis にハッシュ タイプの値を追加します。インターフェイスは次のように実装されます:

 1 import flask 
 2 from flask import jsonify 
 3 from conf import opRedis 
 4 from flask import request 
 5 ''' 
 6 redis添加数据，存入数据的类型是hash类型，格式如下： 
 7 post请求，请求参数入参类型json 
 8 {name:{"key":"value"}} 
 9 {"username":"url"}
 10 '''
 11 server = flask.Flask(__name__)
 12 @server.route('/set_sties', methods =['post'])
 13 def set_sties():
 14     # 获取url请求参数，返回结果是字典{"username":"byz","url":"http://www.baidu.com"}
 15     res_dic = request.json
 16     if res_dic.get('username') and res_dic.get('url'):
 17         username = res_dic.get('username')
 18         url = res_dic.get('url')
 19         #调用redis的hset方法，将username、url存入redis
 20         opRedis.get_hashall('sites', username, url)
 21         return jsonify({"code":20})
 22     else:
 23         return jsonify({"code": 204, "msg": "必填项不能为空"})
 24 
 25 if __name__ == '__main__':
 26     #port可以指定端口，默认端口是5000
 27     #host默认是127.0.0.1,写成0.0.0.0的话，其他人可以访问，代表监听多块网卡上面，
 28     server.run(debug=True, port=8899, host='0.0.0.0')

ハッシュ タイプの構造は次のとおりです:

{name :{key,value}}, インターフェイスへのアクセスが成功すると、redis のデータ ストレージ構造は次のようになります:

redis がデータを追加した後、インターフェイスは次のように実装されます:

 1 import flask 
 2 from flask import jsonify 
 3 from conf import opRedis 
 4 from flask import request 
 5 ''' 
 6 读取redis内的数据，redis数据存储类型是hash类型，格式如下 
 7 {name:{"key":"value"}} 
 8 思路： 1.通过redis的hgetall(name)方法读取redis所有数据，返回结果类型是字典 
 9        2. 循环字典内容，将元素类型转换为str，并将结果存放到字典内
 10 '''
 11 server = flask.Flask(__name__)
 12 @server.route('/get_sties', methods =['get', 'post'])
 13 def get_sties():
 14     #获取redis内所有的数据信息，返回结果类型是字典，里面元素是bytes类型，name=sites
 15     dic = opRedis.get_hashall('sites')
 16     redisList = []
 17     for key, value in dic.items():
 18         redis_dic = {}
 19         #将字典内元素的类型由bytes转换为str
 20         k = key.decode()
 21         v = value.decode()
 22         #字典redis_dic内结构{"username:k, "url":v}
 23         redis_dic['username'] = k
 24         redis_dic['url'] = v
 25         redisList.append(redis_dic)
 26     return jsonify({"code": 200, "msg": redisList})
 27 
 28 if __name__ == '__main__':
 29     #port可以指定端口，默认端口是5000
 30     #host默认是127.0.0.1,写成0.0.0.0的话，其他人可以访问，代表监听多块网卡上面，
 31     server.run(debug=True, port=8899, host='0.0.0.0')

postman メソッド インターフェイスを通じて返されるデータは次のとおりです:

ユーザーにクエリを実行するには、トークン値を渡す必要があります。実装メソッドは次のとおりです:

ログイン インターフェイス:

 1 import flask 
 2 from flask import jsonify 
 3 from conf import opRedis 
 4 from conf import opMysql 
 5 from conf import md5_create 
 6 from flask import request 
 7 import time
 8 ''' 
 9 登录接口，需要传用户名、密码，通过查询数据库判断用户是否登录成功，若登录成功则将用户名和token存入redis内
 10 '''
 11 server = flask.Flask(__name__)
 12 @server.route('/login', methods=['get','post'])
 13 def set_cookies():
 14     name = request.values.get('username')
 15     pwd = request.values.get('pwd')
 16     if name and pwd:17         #加密后的密码
 18         new_pwd = md5_create.md5_test(pwd)
 19         sql = 'select username,password from lhldemo where username="%s" and password="%s" ; ' % (name, new_pwd)
 20         res_sql = opMysql.op_select(sql)
 21         if res_sql:
 22             token = name + time.strftime('%Y%m%d%H%M%S')
 23             new_token = md5_create.md5_test(token)
 24             #用户登录成功后，将name和token存入redis，存入数据类型是hash类型
 25             opRedis.get_hashall('user', name, new_token)
 26             return jsonify({"code": 200})
 27         else:
 28             return jsonify({"code": 204})
 29     else:
 30         return jsonify({"code": 304})

ユーザーをクエリするには、ユーザー名とトークン値を渡す必要があります。実装方法は次のとおりです:

 1 import flask 
 2 from flask import jsonify 
 3 from conf import opRedis 
 4 from conf import opMysql 
 5 from conf import md5_create 
 6 from flask import request 
 7 import time 
 8 ''' 
 9 登录接口，需要传用户名、密码，通过查询数据库判断用户是否登录成功，若登录成功则将用户名和token存入redis内
 10 '''
 11 server = flask.Flask(__name__)
 12 @server.route('/search_user', methods=['get','post'])
 13 def set_cookies():
 14     name = request.values.get('username')
 15     token = request.values.get('token')
 16     print('token',token)
 17     if name and token:
 18         #查看数据库，看查询的用户是否存在，若存在则返回用户id
 19         sql = 'select id from lhldemo where username="%s" ; ' % (name)
 20         res_sql = opMysql.op_select(sql)
 21         if res_sql:
 22             #从redis中获取user下的用户名对应的token值
 23             res_token = opRedis.getRedis('user:'+name)
 26             if res_token == token:
 27                 return jsonify({"msg": "用户id", "id": res_sql})
 28             else:
 29                 return jsonify({"msg": "token错误"})
 30         else:
 31             return jsonify({"code": "用户不存在"})
 32     else:
 33         return jsonify({"code": "必填项不能为空"})
 34 
 35 if __name__ == '__main__':
 36     #port可以指定端口，默认端口是5000
 37     #host默认是127.0.0.1,写成0.0.0.0的话，其他人可以访问，代表监听多块网卡上面，
 38     server.run(debug=True, port=8899, host='0.0.0.0')

上記は、支払い関連のインターフェイスをテストするとき、または 3 番目のインターフェイスのシナリオで一般的に使用されるものです。パーティのインターフェイスでは、インターフェイスをモックして偽のデータを返すことができます~~~~

以上がPythonでのインターフェースの実装例の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。