手把手教你使用Flask框架构建Python接口以及如何请求该接口_python flask api接口开发

---

前言

Flask是一个轻量级的Web应用框架，基于Python编写，其核心思想是保持简洁，灵活性和易于扩展。

0、Flask框架的详细介绍

Flask是一个轻量级的Web应用框架，基于Python编写，其核心思想是保持简洁，灵活性和易于扩展。Flask提供了基本的Web开发工具和应用程序的结构，但同时也允许开发者自由选择其他库和工具来扩展其功能。Flask的设计目标是使开发者能够快速构建具有基本功能的Web应用程序。在日常生活中我们需要将模型打包为api接口，这里需要借助一些web框架，最常用的就是flask框架。

下面是一些Flask框架的主要特点：

• 轻量级：Flask是一个轻量级的框架，其代码库非常小，并且不需要依赖大量的外部库和工具，因此可以轻松地安装和部署。
• 灵活性：Flask允许开发者自由选择其他库和工具来扩展其功能，这使得开发者可以根据自己的需求进行灵活的配置。
• 易于扩展：Flask提供了简单易用的扩展接口，开发者可以使用这些接口来添加新功能或定制框架的行为。
• Web服务器支持：Flask支持多种Web服务器，如内置的开发服务器、Gunicorn和uWSGI等。
• RESTful支持：Flask提供了内置的RESTful路由，使得开发RESTful API变得非常容易。
• Jinja2模板引擎：Flask集成了Jinja2模板引擎，开发者可以使用模板来构建灵活的Web应用程序。
• Flask-WTF表单：Flask提供了Flask-WTF扩展，使得表单处理变得简单而直观。
• 内置的调试器：Flask提供了内置的调试器，使得开发者可以轻松地调试和排除错误。
• 序列化与反序列化：Flask提供了内置的序列化和反序列化功能，使得开发RESTful API变得更加容易。

总的来说，Flask是一个非常适合快速构建小型Web应用程序的框架。它提供了基本的Web开发工具和应用程序的结构，同时也支持灵活的扩展和定制。如果您需要快速构建一个小型的Web应用程序，Flask是一个非常好的选择。

一、Flask 框架封装接口

1-1、分步解析在python中调用Flask框架

• 安装Flask：在命令行终端中输入以下命令：

pip install Flask
1

• 创建一个Flask应用程序：在Python脚本中导入Flask模块，然后创建一个Flask应用程序实例。例如：

from flask import Flask
app = Flask(__name__)

# 在这个例子中，__name__ 参数传递给Flask构造函数，以便Flask知道应用程序的名称。
1
2
3
4

• 定义路由：在Flask应用程序中，路由用于指定URL与执行相应代码的函数之间的映射。可以使用@app.route() 装饰器来定义路由。例如：

@app.route('/')
def hello_world():
    return 'Hello, World!'

# 在这个例子中，@app.route('/') 指定了根URL路径（即'/'），而hello_world()函数是在URL被访问时执行的函数。
1
2
3
4
5

• 运行应用程序：最后一步是在应用程序中运行app.run() 方法。例如：

if __name__ == '__main__':
    app.run()
# 在这个例子中，__name__ 参数是特殊的Python变量，当脚本被执行时，它的值为'__main__'，这个条件语句保证应用程序只在被作为主程序运行时才会执行。
1
2
3

• 完整代码如下：

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()
1
2
3
4
5
6
7
8
9
10

1-2、示例代码分析

以下是一个使用 Flask 框架封装接口的示例代码：

from flask import Flask, request, jsonify

app = Flask(__name__)

# methods: 指定请求方式
@app.route('/process', methods=['POST'])
def process_data():
	# 请求方式为post时，可以使用 request.get_json()接收到JSON数据
    data = request.get_json()  # 获取 POST 请求中的 JSON 数据

    # 处理数据
    # 调用do_something_with_data函数来处理接收到的数据。
    processed_data = do_something_with_data(data)

    # 请求方得到处理后的数据
    return jsonify(processed_data)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这个示例中，我们定义了一个 /process 的路由，并且指定了它只接受 POST 请求。当接收到请求时，我们首先从请求中获取 JSON 数据，然后使用 do_something_with_data 函数处理数据，最后将处理后的结果作为 JSON 数据返回给调用者。

注意，这个示例中的 do_something_with_data 函数并没有实现，你需要根据你的具体需求自己实现它。此外，你也可以根据你的需求修改路由和请求方法，例如改为 GET 请求或者定义不同的路由。

1-3、示例代码改进

# 添加异常检测代码
from flask import Flask, request, jsonify

app = Flask(__name__)

# methods: 指定请求方式
@app.route('/process', methods=['POST'])
def process_data():
	# 请求方式为post时，可以使用 request.get_json()接收到JSON数据
    try:
        data = request.get_json()
        # 如果得到的data是字符串格式，则需要用json.loads来变换成python格式，看个人需求
        # data = json.loads(data)
        print(data)# 获取 POST 请求中的 JSON 数据
    except Exception as e:
        return jsonify({'error': '请求数据失败'}), 400

    # 处理数据
    # 调用do_something_with_data函数来处理接收到的数据。
    # 判断是否接收到数据
	if data:
        try:
            processed_data= do_something_with_data(data)
        except Exception as e:
            return jsonify({'error': '处理数据失败'}), 666
    # 返回的数据格式看请求方的要求了，也有可能需要json处理后的数据，即jsonify(processed_data)
    return str(processed_data)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

1-4、其他注意问题

转义问题：在字符串中，反斜杠（\）通常用于转义字符，如\n表示换行符。而在LaTeX中，\也被用于表示一些特殊的符号。因此，在Python中，如果要在字符串中表示LaTeX代码中的特殊符号，需要在其前面加上一个反斜杠。

• 解决办法：
  即原本的：
  ‘c = 2 \cdot a + \frac{ b }{ 3 }’
  变为：
  ‘c = 2 \cdot a + \frac{ b }{ 3 }’

• 解决办法2：
  我们在字符串前面加上一个r，表示这是一个“原始字符串”，其中的反斜杠不会被解释为转义符号。
  即原本的：
  ‘c = 2 \cdot a + \frac{ b }{ 3 }’
  变为：
  r’c = 2 \cdot a + \frac{ b }{ 3 }’

• 注意：
  输出的结果中有多出来的\，是因为它们是表示LaTeX语法的一部分，而不是Python中的转义符号。

1-5、app.run()详细介绍

app.run() 是 Flask 框架中启动服务器的方法。该方法会启动一个开发用的服务器，它会监听指定的主机和端口，接收来自客户端的请求，并将请求交给应用程序处理。

该方法有如下几个参数：

host: 服务器监听的主机名或 IP 地址，默认为 127.0.0.1，即本地回环地址。
port: 服务器监听的端口号，默认为 5000。
debug: 是否启用调试模式，默认为 False。调试模式下，Flask 会自动重载代码、打印详细的错误信息等，方便开发和调试。
threaded: 是否开启多线程模式，开启后可以提高服务器的并发处理能力，默认为 True。
options: 其它选项，如 SSL/TLS 配置等。
processes: 指定启动的进程数，用于多进程模式，默认为 1。
ssl_context: 用于配置 SSL/TLS 加密连接的上下文，用于启用 HTTPS，默认为 None。
1
2
3
4
5
6
7

案例分析：

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080, debug=True)

1
2
3
4
5
6
7
8
9
10
11

该示例代码中，我们定义了一个简单的 Flask 应用程序，当客户端访问根路由时，会返回一个字符串消息。在启动应用程序时，我们将主机地址指定为 0.0.0.0，表示可以通过任何网络接口进行访问，将端口号指定为 8080，开启了调试模式。这样，我们就可以通过浏览器或其他 HTTP 客户端访问我们的应用程序了。

注意：
将 Flask 应用程序的 debug 参数设置为 True 是为了在开发阶段方便调试。但是在生产环境中，应该将其设置为 False，因为开启调试模式可能会带来一些安全风险和性能问题，例如：

• 安全风险：开启调试模式会在错误页面中显示详细的错误信息，包括源代码和堆栈跟踪，如果攻击者利用这些信息，可能会对应用程序造成安全威胁。
• 性能问题：开启调试模式会影响应用程序的性能，因为它会启用额外的调试代码和功能，例如自动重新加载和调试工具栏，这些功能会消耗计算资源。

因此，当你将 Flask 应用程序部署到生产环境时，应该将 debug 参数设置为 False，以确保应用程序的安全性和性能。

二、请求该接口

2-1、接口请求

可以使用类似 requests 的 Python 库来编写发送请求的代码。以下是一个使用 requests 库发送 POST 请求的示例：

import requests
import json

# 要传入的数据
data = {'param1': 'value1', 'param2': 'value2'}

# 要监听的地址
url = 'http://localhost:5000/process'  # 假设 Flask 应用监听在本地的 5000 端口上

response = requests.post(url, json=data)

if response.status_code == 200:
    processed_data = json.loads(response.content)
    print(processed_data)
else:
    print('请求失败：', response.status_code)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个示例中，我们定义了一个 data 字典，它包含了我们要传递给接口的参数。然后，我们使用 requests.post 函数向接口发送 POST 请求，并将参数以 JSON 格式传递给接口。

如果接口成功处理了请求并返回了正确的数据，我们可以使用 json.loads 函数将接口返回的 JSON 数据解析为 Python 对象，并进行进一步的处理。否则，我们可以查看响应的状态码来了解请求是否成功。

2-2、接口请求改进

接口请求改进: 为了增加代码的健壮性，我们需要添加异常检测代码

import requests
import json

# 要传入的数据
data = {'param1': 'value1', 'param2': 'value2'}

# 要监听的地址
url = 'http://localhost:5000/process'  # 假设 Flask 应用监听在本地的 5000 端口上

try:
	# 需要注意的是：JSON 格式不支持包含 Python 对象的字符串，需要json.dumps方法将其编码为 JSON 格式的字符串
	# response = requests.post(url, json=json.dumps(data))
    response = requests.post(url, json=data)
    response.raise_for_status()
except requests.exceptions.RequestException as e:
    print('请求出错：', e)

if response.status_code == 200:
    processed_data = json.loads(response.content)
    print(processed_data)
else:
    print('请求失败：', response.status_code)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

三、请求接口代码转换为java

后端开发工程师需要调用我们的接口？请求接口代码转换为java格式：

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.OutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;

import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class SendPOSTRequest {
    public static void main(String[] args) {
        String url = "http://localhost:5000/process"; // 假设 Flask 应用监听在本地的 5000 端口上

        // 构造请求参数
        JsonObject data = new JsonObject();
        data.addProperty("param1", "value1");
        data.addProperty("param2", "value2");

        try {
            // 发送 POST 请求
            URL obj = new URL(url);
            HttpURLConnection con = (HttpURLConnection) obj.openConnection();
            con.setRequestMethod("POST");
            con.setRequestProperty("Content-Type", "application/json");

            // 将参数写入请求体
            con.setDoOutput(true);
            OutputStream os = con.getOutputStream();
            os.write(new Gson().toJson(data).getBytes("utf-8"));
            os.flush();
            os.close();

            // 处理响应结果
            BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String inputLine;
            StringBuffer response = new StringBuffer();
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();

            // 解析 JSON 数据
            JsonObject processedData = new Gson().fromJson(response.toString(), JsonObject.class);
            System.out.println(processedData);
        } catch (Exception e) {
            System.out.println("请求失败：" + e.getMessage());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

在这个示例中，我们使用 Java 的标准库 java.net 发送 POST 请求，并将参数以 JSON 格式传递给接口。我们使用 Google 的 Gson 库来解析接口返回的 JSON 数据。

注意，这个示例中的代码并不包含异常处理，你需要根据实际情况添加适当的异常处理代码。此外，你也可以根据你的需求修改请求方法、请求头和请求体的格式。

四、拓展Flask高级用法

4-1、使用蓝图（Blueprints）

当应用程序的规模增大时，为了方便管理，可以使用蓝图将应用程序分解成更小的模块。每个蓝图代表一个功能模块，包含自己的路由、模板、静态文件等。例如：

from flask import Blueprint

auth_bp = Blueprint('auth', __name__)

@auth_bp.route('/login')
def login():
    return 'Login page'

@auth_bp.route('/logout')
def logout():
    return 'Logout page'
1
2
3
4
5
6
7
8
9
10
11

在这个例子中，auth_bp 是一个蓝图，包含两个路由：/login 和 /logout。
将蓝图注册到应用程序中：

app.register_blueprint(auth_bp, url_prefix='/auth')
1

在这个例子中，url_prefix=‘/auth’ 指定了蓝图中所有路由的URL前缀。

4-2、使用模板

Flask提供了内置的模板引擎Jinja2，用于将数据渲染到HTML页面中。例如：

from flask import render_template

@app.route('/user/<username>')
def show_user_profile(username):
    user = {'username': username, 'age': 18}
    return render_template('user.html', user=user)
1
2
3
4
5
6

在这个例子中，render_template() 函数将数据 user 渲染到名为 user.html 的模板中，然后返回渲染后的HTML页面。

在模板中，可以使用Jinja2语法来获取数据、控制流程、引入子模板等。例如：

<h1>Hello, {{ user.username }}!</h1>
{% if user.age >= 18 %}
<p>You are an adult.</p>
{% else %}
<p>You are a minor.</p>
{% endif %}
1
2
3
4
5
6

4-3、使用数据库

Flask没有内置的数据库支持，但可以轻松地集成第三方数据库库（如SQLAlchemy）来访问数据库。例如：

from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///myapp.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

    def __repr__(self):
        return '<User %r>' % self.username
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个例子中，SQLAlchemy 是一个第三方数据库库，使用SQLite数据库来存储数据。User 类是一个模型类，用于定义数据库中的表结构。

在使用模型之前，需要执行一次数据库初始化操作：

with app.app_context():
    db.create_all()
1
2

然后就可以使用模型类来访问数据库了。例如：

user = User(username='john', email='john@example.com')
1

---

总结