Flask中能否在函数运行时显示模板，完成后重定向至另一模板？

嘿，这个需求我在项目里经常碰到，核心就是前后端配合，让用户在等待耗时任务的时候有明确的反馈，等任务完成再跳转到目标页面。我给你拆解成具体的实现步骤，分前后端来讲：

用户触发耗时操作后，后端先启动异步任务，然后立刻把用户重定向到加载页面；加载页面通过轮询后端接口的方式，持续检查任务状态，一旦任务完成，就自动跳转到复杂页面。这样既避免了用户盯着无响应的页面，也能保证任务完成后准确跳转。

1. 前端：加载页实现 + 状态轮询 #

首先做一个带加载动画的页面，用户进入后自动发起轮询请求，直到任务完成后跳转。这里给你一个完整的示例代码：

<!DOCTYPE html>
<html>
<head>
    <title>处理中，请稍候</title>
    <style>
        .container {
            display: flex;
            flex-direction: column;
            align-items: center;
            margin-top: 100px;
        }
        .loader {
            border: 8px solid #f0f0f0;
            border-top: 8px solid #2563eb;
            border-radius: 50%;
            width: 60px;
            height: 60px;
            animation: spin 1.5s linear infinite;
        }
        @keyframes spin {
            0% { transform: rotate(0deg); }
            100% { transform: rotate(360deg); }
        }
        .status-text {
            margin-top: 20px;
            font-size: 18px;
            color: #6b7280;
        }
        .error-text {
            margin-top: 10px;
            color: #ef4444;
            font-size: 14px;
            display: none;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="loader"></div>
        <div class="status-text">正在处理您的请求...</div>
        <div class="error-text" id="errorMsg">请求超时，请稍后重试</div>
    </div>

    <script>
        // 从URL参数获取任务ID（后端跳转时传递）
        const urlParams = new URLSearchParams(window.location.search);
        const taskId = urlParams.get('task_id');
        let pollCount = 0;
        const MAX_POLL_TIMES = 60; // 最多轮询60次（假设每次1秒，就是1分钟超时）

        function checkTaskStatus() {
            fetch(`/api/check-task-status?task_id=${taskId}`)
                .then(res => res.json())
                .then(data => {
                    if (data.completed) {
                        // 任务完成，跳转到复杂页面
                        window.location.href = '/your-complex-page';
                    } else {
                        pollCount++;
                        if (pollCount >= MAX_POLL_TIMES) {
                            // 超时显示错误
                            document.getElementById('errorMsg').style.display = 'block';
                            return;
                        }
                        // 未完成，继续轮询，间隔1秒
                        setTimeout(checkTaskStatus, 1000);
                    }
                })
                .catch(err => {
                    console.error('检查状态失败:', err);
                    setTimeout(checkTaskStatus, 3000); // 失败后间隔3秒重试
                });
        }

        // 页面加载后立即开始轮询
        window.onload = checkTaskStatus;
    </script>
</body>
</html>

这段代码里做了这些优化：

• 带旋转动画的加载器，给用户明确的等待反馈
• 从URL获取后端传递的task_id，用来跟踪具体任务
• 加入了超时逻辑，避免无限轮询
• 失败后自动重试，提升稳定性

2. 后端：异步任务处理 + 状态维护 #

后端的关键是不能阻塞主线程，必须用异步任务来处理耗时操作，同时要把任务状态存在共享存储里（比如Redis），方便前端查询。这里用Python Flask + Redis举个例子：

from flask import Flask, redirect, request, jsonify
import time
from threading import Thread
import redis
import uuid

app = Flask(__name__)
# 连接Redis，用来存储任务状态（生产环境要配置正确的地址和密码）
redis_client = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)

# 模拟耗时任务：比如数据导出、批量处理等
def execute_long_task(task_id):
    try:
        # 这里替换成你的实际耗时逻辑
        time.sleep(15)
        # 任务完成后，更新Redis中的状态为completed
        redis_client.set(task_id, 'completed')
    except Exception as e:
        print(f"任务执行失败: {e}")
        redis_client.set(task_id, 'failed')

@app.route('/trigger-long-task')
def trigger_task():
    # 生成唯一的任务ID，用来跟踪任务状态
    task_id = str(uuid.uuid4())
    # 初始化任务状态为pending（待处理）
    redis_client.set(task_id, 'pending')
    # 启动异步线程执行耗时任务（生产环境建议用Celery/RQ等专业任务队列）
    Thread(target=execute_long_task, args=(task_id,)).start()
    # 重定向到加载页面，并传递task_id
    return redirect(f'/loading-page?task_id={task_id}')

@app.route('/api/check-task-status')
def check_task_status():
    task_id = request.args.get('task_id')
    if not task_id:
        return jsonify({'error': '缺少task_id参数'}), 400
    
    status = redis_client.get(task_id)
    if not status:
        return jsonify({'error': '任务不存在'}), 404
    
    return jsonify({
        'completed': status == 'completed',
        'failed': status == 'failed'
    })

@app.route('/your-complex-page')
def complex_page():
    # 这里是你的复杂页面内容
    return '<h1>任务处理完成！这是你的复杂页面</h1>'

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

后端注意事项： #

• 生产环境不要用Thread：上面用Thread只是示例，生产环境建议用专业的任务队列，比如Celery（Python）、BullMQ（Node.js），能更好地管理任务、处理失败重试、监控状态。
• 状态存储选择：如果是多服务器部署，绝对不能用内存存状态，必须用Redis、MongoDB这种共享存储，否则前端轮询的时候可能找不到任务状态。
• 任务清理：记得定期清理Redis中已完成的任务状态，避免占用过多存储。

• 进度条展示：如果你的耗时任务能拆分进度（比如处理100条数据，每处理10条更新一次进度），可以在后端返回进度百分比，前端显示进度条，体验更好。
• WebSocket替代轮询：如果用户量较大，轮询会增加服务器压力，可以用WebSocket实现后端主动推送任务完成的消息，减少请求次数。

内容的提问来源于stack exchange，提问作者William Irvine