Flask 网络通讯

本文档详细介绍了如何使用 Flask 框架构建一个功能全面的服务端应用。Flask 是一个轻量级的 Python Web 框架，非常适合快速开发简单但功能强大的 web 应用。在本指南中，我们将探讨 Flask 的基本功能，包括处理 HTTP GET 和 POST 请求，以及实现文件上传和下载功能。通过本文档，您将学习到如何设置和配置 Flask 服务器，从而处理各种网络请求，实现数据的接收和发送，并提供文件管理操作，如安全地上传和下载文件。

Flask 基本项目

在 Flask 中，你首先创建一个项目结构来组织应用的各个部分，然后通过定义和注册蓝图模块化你的路由和视图，最后运行应用以启动服务并处理网络请求。

项目结构

基本Flaks项目结构如下，__init__.py 文件在每个目录中使Python将这些目录作为包处理。users.py 和 data.py 包含不同的蓝图，分别用于用户和数据相关的路由。run.py 是启动应用的脚本。

/your-app
    /app
        __init__.py
        /blueprints
            __init__.py
            users.py
            data.py
    run.py

设置蓝图

在app/__init__.py在这个文件中，你将初始化 Flask 应用并注册蓝图。

from flask import Flask
def create_app():
    app = Flask(__name__)
    # 导入蓝图
    from .blueprints.users import users_bp
    from .blueprints.data import data_bp
    # 注册蓝图
    app.register_blueprint(users_bp, url_prefix='/users')
    app.register_blueprint(data_bp, url_prefix='/data')
    return app

蓝图服务

对于不同的服务，定义在不同蓝图文件中，以user为例，下面定义了服务和调用方法：

# 服务创建
from flask import Blueprint, jsonify
# 创建蓝图
users_bp = Blueprint('users', __name__)
@users_bp.route('/<username>')
def get_user(username):
    return jsonify({'message': f'Hello, {username}'})

服务启动

在每一次增加或减少服务之后需要重新启动，只需运行run.py即可。

from app import create_app
app = create_app()
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

服务调用

要调用上述通过蓝图分组织好的服务，你可以使用相应的HTTP请求，针对不同的路由发送GET或POST请求。这些请求可以通过多种方式进行，这里主要介绍Python的requests库。

import requests
response = requests.get('http://localhost:5000/users/john')
print(response.text)

进阶服务

在详述了 Flask 的基本项目结构和基础服务之后，接下来将深入探讨更复杂的功能，包括多样化的 GET 和 POST 请求处理、高级数据库交互、以及文件的上传和下载操作。

进阶GET请求

下列定义了三个不同的路由在 Flask 应用中，每个路由都演示了不同的 GET 请求处理方式：

1. 简单的 GET 路由：第一个路由 @data_bp.route('/') 对应的函数 home 直接返回一个欢迎字符串 “Welcome to the Flask API!”。这是最基础的 HTTP GET 请求处理，通常用于提供 API 的入口点或健康检查。

2. 返回 JSON 数据的 GET 路由：第二个路由 @data_bp.route('/data') 对应的函数 get_data 返回一个 JSON 对象，包含一条消息和一个数据列表 [1, 2, 3, 4]。这种方式常用于 API 中，用于返回结构化数据。

3. 带参数的 GET 路由：第三个路由 @data_bp.route('/data/<username>') 允许通过 URL 传递一个用户名参数 username，相关的函数 get_user 则将这个用户名包含在返回的 JSON 响应中。这允许动态响应请求，根据请求的 URL 参数提供个性化数据。

这三个示例展示了如何使用 Flask 路由来处理不同类型的 GET 请求，从简单的文本响应到更复杂的带参数的 JSON 数据响应，体现了 Flask 在 Web 应用和 API 开发中的灵活性和强大功能。

# 简单的GET路由，返回字符串
@data_bp.route('/')
def home():
    return "Welcome to the Flask API!"
    
# GET路由，返回JSON数据
@data_bp.route('/data')
def get_data():
    return jsonify({'message': 'Here is your data', 'data': [1, 2, 3, 4]})

# 带参数的GET路由
@data_bp.route('/data/<username>')
def get_user(username):
    return jsonify({'message': f'Hello, {username}'})

下列函数 GetTest 使用 Python 的 requests 库演示了如何发送 HTTP GET 请求到一个 Flask 应用，展示了三种不同的请求：一种是请求基本的 JSON 数据，一种是请求包含更多详细信息的结构化 JSON 数据，以及一种是带有用户名参数的请求，用于获取特定用户的个性化数据。这些示例展示了如何通过改变请求的 URL 来访问和展示服务端的不同数据响应，从基础数据到动态生成的用户相关数据。

def GetTest():
    response = requests.get('http://127.0.0.1:5000/data')
    print(response.text)

    response = requests.get('http://localhost:5000/data/data')
    print(response.json())

    response = requests.get('http://localhost:5000/data/data/YourName')
    print(response.json())

进阶POST请求

下面的代码段展示了如何在 Flask 应用中设置路由，以处理不同类型的用户相关请求：

1. 获取特定用户信息：使用动态路由 /<username>，当用户访问类似 /john 的 URL 时，get_user 函数将被调用，返回一个 JSON 响应，其中包含一条欢迎信息和用户名。
2. 接收并处理 JSON 数据的 POST 请求：在路由 /user/json 上，定义了一个 POST 方法的处理函数 post_json，它读取请求体中的 JSON 数据，然后将这些数据回传给客户端，确认数据已被接收。
3. 接收并处理表单数据的 POST 请求：在路由 /user/form 上，定义了另一个 POST 方法的处理函数 post_form，它从表单数据中获取用户名和年龄信息，然后以 JSON 格式响应这些数据。
   这三个路由展示了 Flask 应用如何灵活处理各种 HTTP 请求，从简单的数据返回到处理复杂的 JSON 或表单数据，使得开发者能够根据需要快速实现各种 Web 服务。

@users_bp.route('/<username>')
def get_user(username):
    return jsonify({'message': f'Hello, {username}'})
    
# 接收JSON数据的POST路由
@users_bp.route('/user/json', methods=['POST'])
def post_json():
    data = request.get_json()  # 解析JSON数据
    return jsonify({'received': data}), 200
    
# 接收表单数据的POST路由
@users_bp.route('/user/form', methods=['POST'])
def post_form():
    username = request.form['username']
    age = request.form['age']
    return jsonify({'username': username, 'age': age}), 200

下了 PostTest 函数展示了如何使用 Python 的 requests 库发送两种类型的 POST 请求：首先通过发送 JSON 数据到指定的 URL 来测试服务器对 JSON 格式的处理，随后发送表单数据以验证服务器对表单格式的响应。每次请求后，它打印出服务器返回的 JSON 响应，这有助于开发者快速验证和调试服务端的请求处理逻辑。

def PostTest():
    # 发送JSON数据
    json_data = {'username': 'john', 'age': 30}
    response = requests.post('http://localhost:5000/users/json', json=json_data)
    print(response.json())
    # 发送表单数据
    form_data = {'username': 'john', 'age': 30}
    response = requests.post('http://localhost:5000/post/form', data=form_data)
    print(response.json())

POST数据库服务

在前文中，我们已经讨论了如何在 Flask 应用中处理基本的 GET 和 POST 请求。接下来，我们将探讨如何将这些基本请求扩展到更复杂的服务中，尤其是如何结合数据库操作来响应客户端的请求，这将显著增强应用的功能和互动性。

数据库服务的整合

在现代 web 应用中，与数据库的交互是不可或缺的。通过结合 Flask 的请求处理能力和数据库操作，可以实现数据的动态存取、更新和删除，这为用户提供了丰富的交互体验。例如，可以通过 POST 请求接收用户数据，并将其存储到数据库中；同样，可以通过 GET 请求从数据库中检索数据。

结合 POST 服务和数据库操作

在现代 Web 应用开发中，服务器不仅仅处理数据存储和检索的请求，还可以执行更复杂的操作，如数据分析和可视化。下面，我们将以一个具体例子说明，如何通过 Flask 服务器接收客户端通过 POST 请求发送的 JSON 格式数据，使用这些数据进行绘图，并将绘图结果返回给客户端以便在用户本地展示。

假设我们需要开发一个功能，允许用户通过上传需要用到的数据库数据，服务器接收后生成图表，然后将图表以图片格式返回给客户端。这种功能在统计分析、商业智能报告等领域非常有用。

下列代码通过一个 Flask 路由 plot_image 处理从客户端通过 POST 请求发送的表单数据，用于从指定的数据库表中查询特定时间范围内的数据。然后，根据请求中定义的图表类型（如线图或散点图），利用 matplotlib 生成图表，并将图表保存到内存中的 BytesIO 流。最终，将这个图像作为 PNG 文件直接从内存返回给客户端，使得用户可以即时查看生成的图表。如果在数据查询或图表生成过程中发生任何错误，服务将返回一个错误消息，指示数据不可用或查询失败。

示例代码

@plot_bp.route('/image', methods=['POST'])
def plot_image():
    table = request.form['table']
    print(table)
    time_column = request.form['time_column']
    value_columns = request.form['value_columns'].split(',')
    start_time = request.form['start_time']
    end_time = request.form['end_time']
    plot_type = request.form['plot_type']
    xlabel = request.form['xlabel']
    ylabel = request.form['ylabel']
    try:
        img = plot_data(table,time_column,value_columns,start_time,end_time,plot_type,xlabel,ylabel)
        if img == 404:
            return "No data available for the specified criteria.", 404
        return send_file(img, mimetype='image/png')
    except Exception as e:
        return "No data available for the specified criteria.", 404

def plot_data(table, time_column, value_columns, start_time, end_time, plot_type, xlabel, ylabel):
    # 数据库连接
    conn = pymysql.connect(host='host', port='port', user='user', passwd='passwd', db='db')
    cursor = conn.cursor()

    # 构建并执行SQL查询
    value_columns_query = ', '.join([f"`{col}`" for col in value_columns])
    query = f"""
        SELECT `{time_column}`, {value_columns_query}
        FROM `{table}`
        WHERE `{time_column}` BETWEEN '{start_time}' AND '{end_time}'
        """
    cursor.execute(query)
    results = cursor.fetchall()
    if not results:
        return 404
    df = pd.DataFrame(results, columns=[time_column] + value_columns)
    x = df[xlabel]
    y = df[ylabel]
    plt.figure()
    if plot_type == 'line':
        plt.plot(x, y)
    elif plot_type == 'scatter':
        plt.scatter(x, y)
    # 保存图像到临时缓冲区
    img = io.BytesIO()
    plt.savefig(img, format='png')
    img.seek(0)
    plt.close()
    cursor.close()
    conn.close()
    return img

说明

• 这个简单的例子展示了从接收数据到处理数据再到生成和返回图像的完整流程。
• 客户端需要将数据库数据以 JSON 格式发送到 /plot 路由。
• 服务器处理这些数据，生成一个条形图，然后将图像作为响应返回。
• 使用 io.BytesIO() 可以避免服务器上的文件操作，使处理过程更高效。

这种类型的应用扩展了传统的数据交互方式，使服务器能够进行更加复杂的数据处理和反馈，极大地增强了 应用的交互性和功能性。通过此方式，客户端用户可以便捷地获取复杂数据处理和可视化服务，而无需在本地安装复杂的数据分析和图表生成软件。

调用示例

这段代码定义了一个名为 PlotImage 的函数，用于发送 POST 请求到本地服务器以请求生成特定数据图表。它通过 URL http://localhost:5000/plot/image 发送包含数据库表名、时间列名、值列名、时间范围、图表类型以及坐标轴标签的数据。服务器响应此请求后，若成功（状态码 200），将从响应中读取图像数据，使用 Python 的 PIL 库展示并保存图像到本地文件。如果请求失败，会打印出错误状态码，说明数据获取失败。这使得用户可以动态地生成和查看从数据库中提取的数据的图表，便于分析和记录。

def PlotImage():
    url = 'http://localhost:5000/plot/image'

    data = {
        'table': 'tian_hu_shan',  # 数据库中的表名
        'time_column': 'time',  # 用于时间的列名
        'value_columns': 'wind_speed,active_power',  # 用于值的列名
        'start_time': '2024-04-01',  # 时间范围的开始
        'end_time': '2024-05-31',  # 时间范围的结束
        'plot_type': 'scatter',  # 图表类型（line 或 scatter）
        'xlabel': 'wind_speed',  # X轴标签
        'ylabel': 'active_power'  # Y轴标签
    }

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

    if response.status_code == 200:
        image = Image.open(BytesIO(response.content))
        image.show()
        image.save('output.png')
    else:
        print(f"Failed to retrieve data: {response.status_code}")

文件上传与下载

在前文中，我们详细介绍了如何在 Flask 应用中整合深层数据库服务，包括如何处理复杂查询和动态数据交互。继续我们的讨论，下一节将探讨文件上传和下载功能——这是几乎每个现代 web 应用必需的功能。我们将展示如何在 Flask 框架中安全高效地实现文件的上传和下载，不仅支持基本的文件操作，还包括文件类型验证、安全措施以及如何处理上传后的文件数据。这些功能对于维护用户数据的完整性及保证应用安全尤为关键，特别是在处理个人数据和敏感信息时。接下来的部分将提供代码实例和最佳实践，帮助开发者构建可靠且用户友好的文件管理系统。

文件上传

下面这段代码定义了一个 Flask 蓝图 file_bp，用于处理图像和一般文件的上传功能。设置了两个 POST 路由，分别用于接收和验证上传的文件是否符合预设的文件类型（如 png, jpg, pdf 等）。如果文件不存在、未选择文件或文件类型不被允许，服务将返回相应的错误信息。成功上传的文件将被保存在指定的上传目录中，并返回一个确认消息表明文件已成功上传。这个功能模块使用安全措施如 secure_filename 来防止文件名相关的安全风险，确保上传过程既高效又安全。

from flask import Blueprint, request, jsonify
from werkzeug.utils import secure_filename
import os

file_bp = Blueprint('file', __name__)

UPLOAD_FOLDER = 'uploads/'
ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'txt', 'pdf', 'docx'}

def allowed_file(filename):
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS

@file_bp.route('/upload-image', methods=['POST'])
def upload_image():
    if 'file' not in request.files:
        return jsonify({'error': 'No file part'}), 400
    file = request.files['file']
    if file.filename == '':
        return jsonify({'error': 'No selected file'}), 400
    if file and allowed_file(file.filename):
        filename = secure_filename(file.filename)
        file.save(os.path.join(UPLOAD_FOLDER, filename))
        return jsonify({'message': f'File {filename} uploaded successfully'}), 200
    return jsonify({'error': 'File type not allowed'}), 400

@file_bp.route('/upload-file', methods=['POST'])
def upload_file():
    if 'file' not in request.files:
        return jsonify({'error': 'No file part'}), 400
    file = request.files['file']
    print(file.filename)
    if file.filename == '':
        return jsonify({'error': 'No selected file'}), 400
    if file and allowed_file(file.filename):
        filename = secure_filename(file.filename)
        file.save(os.path.join(UPLOAD_FOLDER, filename))
        return jsonify({'message': f'File {filename} uploaded successfully'}), 200
    return jsonify({'error': 'File type not allowed'}), 400

下列 upload 函数演示了如何使用 Python 的 requests 库通过 POST 方法上传文件到 Flask 服务器。内部的 upload_file 功能函数负责打开指定的文件并以二进制模式读取，然后将其作为文件传输到指定的 URL。函数被用来上传两种类型的文件：一张图片和一个文本文件，分别通过不同的 URL (image_url 和 file_url) 进行上传。每次文件上传后，函数将打印出响应状态码和服务器返回的文本消息，提供上传操作的结果反馈，使用户可以验证文件是否成功上传到服务器。

def upload():
    def upload_file(url, file_path):
        """通过POST方法上传文件到指定的URL"""
        with open(file_path, 'rb') as file:
            files = {'file': (file_path, file)}
            response = requests.post(url, files=files)
            return response

    # Flask服务的URL，根据你的本地服务器或部署地址可能需要调整
    image_url = 'http://localhost:5000/file/upload-image'
    file_url = 'http://localhost:5000/file/upload-file'

    # 替换为实际的文件路径
    image_path = 'output.png'
    file_path = '../uploads/测试.txt'

    # 调用函数上传图片
    image_response = upload_file(image_url, image_path)
    print(f"Image Upload Response: {image_response.status_code}, {image_response.text}")

    # 调用函数上传一般文件
    file_response = upload_file(file_url, file_path)
    print(f"File Upload Response: {file_response.status_code}, {file_response.text}")

下列代码段展示了如何在 Flask 应用中利用蓝图 (Blueprint) 实现文件和图片的安全下载功能。通过定义两个 POST 路由 download-file 和 view-image，用户可以通过发送包含文件名的 JSON 请求来下载文件或查看图片。代码中使用了 safe_join 来确保文件路径的安全性，避免路径遍历攻击，而 send_from_directory 函数则用于从指定目录发送文件，支持以附件形式返回或直接在浏览器中显示图片。此方法的优势在于提高了服务器的安全性，同时通过打印详细的调试信息帮助开发者追踪和处理可能的错误，确保了文件传输的透明度和可追溯性。此外，这种方式允许用户通过简单的 API 调用灵活地访问和下载服务器上的资源，极大地提高了用户交互的便利性。

文件下载

from flask import Blueprint, request, send_from_directory, jsonify
from werkzeug.utils import safe_join
import os
down_bp = Blueprint('down', __name__)  # 创建Blueprint实例

# 路径注意修改
UPLOAD_FOLDER = 'D:/ZhihuiCao/Server/uploads/'

@down_bp.route('/download-file', methods=['POST'])
def download_file():
    filename = request.json.get('filename')
    print(f"Requested filename: {filename}")

    if not filename:
        print("No filename provided")
        return jsonify({'error': 'No filename provided'}), 400

    safe_path = safe_join(UPLOAD_FOLDER, filename)
    if not os.path.isfile(safe_path):
        print(f"File not found: {safe_path}")
        return jsonify({'error': 'File not found'}), 404

    print(f"Sending file: {safe_path}")
    return send_from_directory(UPLOAD_FOLDER, filename, as_attachment=True)

@down_bp.route('/view-image', methods=['POST'])
def view_image():
    filename = request.json.get('filename')
    if not filename:
        return jsonify({'error': 'No filename provided'}), 400

    safe_path = safe_join(UPLOAD_FOLDER, filename)
    print("Safe path:", safe_path)  # 调试信息

    if not os.path.isfile(safe_path):
        print(f"File not found at path: {safe_path}")  # 调试信息
        return jsonify({'error': 'Image not found'}), 404
    try:
        return send_from_directory(UPLOAD_FOLDER, filename, as_attachment=False)
    except Exception as e:
        print("Error sending file:", str(e))  # 输出错误信息
        return jsonify({'error': 'Error sending file'}), 500

下列代码定义了一个名为 download 的函数，用于从服务器下载文件和图片。首先，通过发送 POST 请求到 download_url 地址，该函数尝试下载一个文本文件（‘ceshi.txt’）。如果请求成功（状态码为 200），它会将文件内容保存到本地。如果下载失败，将打印相关的错误信息和响应状态码。

接着，函数尝试下载一个图片文件（‘output.png’）通过发送 POST 请求到 view_url 地址。同样，如果图片成功下载，内容会被保存到本地文件中。下载成功或失败的状态都会通过打印消息来反馈。

此函数的设计旨在处理从特定服务器下载并本地保存文件的任务，它展示了如何处理网络请求的响应，包括如何根据响应状态码处理成功或失败的结果，并确保在本地文件系统中正确地创建和保存文件。这种方法有效地将网络资源的获取和本地资源的管理结合起来，提供了一个实用的网络资源下载和本地化存储的解决方案。

def download():
    download_url = 'http://localhost:5001/down/download-file'
    download_filename = 'ceshi.txt'  # 确保这个文件在服务器的 uploads/ 文件夹中
    download_response = post_request(download_url, download_filename)

    if download_response.status_code == 200:
        # 文件保存到本地
        with open(download_filename, 'wb') as f:
            f.write(download_response.content)
        print(f'File {download_filename} downloaded successfully.')
    else:
        print(
            f'Download File Response: {download_response.status_code}, Content-Type: {download_response.headers["Content-Type"]}')

    # 测试查看图片
    view_url = 'http://localhost:5001/down/view-image'
    view_filename = 'output.png'  # 确保这个图片在服务器的 uploads/ 文件夹中
    view_response = post_request(view_url, view_filename)

    if view_response.status_code == 200:
        with open(view_filename, 'wb') as f:
            f.write(view_response.content)
        print(f'Image {view_filename} viewed and saved successfully.')
    else:
        print(
            f'View Image Response: {view_response.status_code}, Content-Type: {view_response.headers["Content-Type"]}')

总结

在本系列讨论中，我们深入探讨了使用 Flask 框架实现 Web 应用的各个方面。首先，我们介绍了如何处理基本的 GET 和 POST 请求，允许用户检索信息和提交数据。接着，我们扩展到更复杂的数据库交互，说明了如何执行数据查询和动态数据生成。此外，我们也涵盖了文件上传和下载功能，展示了如何安全地接收用户上传的文件并将文件或生成的图像数据提供给用户下载。整体而言，这些功能的实现展示了 Flask 在构建动态和互动网站中的强大能力和灵活性。

在之后的开发阶段，我们计划利用前述的基本功能结合 PyQt 来创建一个可执行的 .exe 文件，实现一个高度模块化和可配置的应用程序。这种设计使得 .exe 文件在不需要任何修改的前提下，可以通过外部配置文件和服务器交互来灵活调整前端界面展示和功能实现。所有的功能将通过网络请求实现，例如数据处理、文件上传下载等，而 GUI 的布局和元素也将通过从服务器获取的配置动态生成。这将允许我们通过简单更新服务器端的配置，即可改变客户端应用的行为和外观，从而使应用更加灵活，更易于维护和升级。这种策略不仅提高了开发效率，也使得应用能够快速适应变化的业务需求和用户界面设计趋势。