flask.md

Flask简介

• flask是轻量级web开发框架，依赖Jinja2模版引擎和Werkzeug WSGI工具集。
• flask是一个内核可以扩展其他应用功能，例如：邮件Flask-Mail, 用户认证Flask-Login, 数据库Flask-SQLAIchemy等。
• 安装：pip install Flask
• Flask常用扩展包：
  • Flask-SQLaIchemy: 数据库
  • Flask-script: 插入脚本
  • Flask-migrate: 管理迁移数据库
  • Flask-Session: Session存储方式指定
  • Flask-WTF: 表单
  • Flask-Mail: 邮件
  • Flask-Bable: 翻译
  • Flask-Login: 认证用户
  • Flask-OpenID: 认证
  • Flask-RESTful: 开发REST API工具
  • Flask-Bootstrap: 集成前段Twitter Bootstrap框架
  • Flask-Moment: 本地化日期和时间
  • Flask-Admin: 简单而可扩展的管理接口的框架

Web搭建

• 搭建过程包含了路由，模版，请求，响应等
• 应用模块：Flask核心模块，Web程序的入口，负责接收HTTP请求并返回响应。他负责路由、错误处理、上下文等功能。他还负责管理整个应用程序的生命周期
• 路由模块：Flask使用装饰器来定义 URL 路由和视图函数之间的映射关系。
• 视图模块：视图函数是 Flask Web 应用程序的核心，它处理 HTTP 请求并返回响应，可以返回 HTML 页面、JSON 数据等。
• 模板模块：Flask 使用 Jinja2 模板引擎来生成 HTML 页面。模板引擎提供了丰富的语法和过滤器，可以轻松地生成复杂的 HTML 页面。
• 数据库模块：Flask 可以轻松地与多种数据库集成，包括 MySQL、PostgreSQL、SQLite 等。
• 表单模块：Flask-WTF 是 Flask 的表单处理扩展，提供了方便的表单处理方法，可以轻松地创建表单、验证表单数据等。
  

应用模块

应用模块是 Flask 框架的核心模块之一，它负责创建 Flask 应用程序对象，并定义一些应用程序级别的配置和功能。

• 创建应用程序对象：Flask 类的构造函数需要传入应用程序的名称作为参数。
• 配置应用程序：可以使用 config 属性来配置应用程序的基本属性，如调试模式、密钥、数据库连接等。
• 注册路由：使用 route 装饰器来注册 URL 路由和视图函数之间的映射关系。路由定义了 HTTP 请求的 URL 地址和视图函数之间的映射关系。
• 定义视图函数：视图函数是处理 HTTP 请求的函数，可以返回 HTML 页面、JSON 数据等。视图函数通常使用 route 装饰器定义 URL 路由。
• 上下文管理：Flask 应用程序使用上下文对象来管理请求上下文和应用上下文。请求上下文包含了每个 HTTP 请求的相关信息，如请求头、请求参数等。应用上下文包含了应用程序的相关信息，如配置信息、数据库连接等。
• 错误处理：Flask 应用程序可以通过注册错误处理函数来处理 HTTP 请求中出现的错误，如 404 错误、500 错误等。
• 启动应用程序：通过 run 方法启动应用程序，使其可以接收 HTTP 请求。

from flask import Flask, render_template
#创建应用程序对象
app = Flask(__name__)
# 配置应用程序
app.config['DEBUG'] = True
app.config['SECRET_KEY'] = 'your_secret_key'
# 注册路由和视图函数
@app.route('/')
def index():    
  return 'Hello, World!'
@app.route('/user/<name>')
def user(name):    
  return 'Hello, %s!' %name
#多路由
#这个函数的主要作用是处理用户访问 /hello/ 或 /hello/<name> 时的请求。
#如果用户访问 /hello/，name 参数将保持默认值 None。
#如果用户访问 /hello/<name>，name 参数将被设置为动态传入的值。
@app.route('/hello/')
@app.route('/hello/<name>')
def hello(name=None):    
  return render_template('hello.html', name=name)
# 启动应用程序
if __name__ == '__main__':    
  app.run()

虽然run()方法使用与启动本地的开发服务，但是用户每次修改代码后需要手动的重启服务，这样并不优雅，而Flask可以做到更好。如果你启用了调试支持，服务器会在代码修改后自动重新载入，并且在发生错误的时候提供一个相当可用的调试器 相当于Java的热部署
使用方法，直接在代码中添加

app.run(debug=True)
或者
app.debug=True
app.run()

Blueprint

• 蓝图是一个存储一组视图方法的容器对象
• 一个应用可以有多个Blueprint
• 可以将一个Blueprint注册到任何一个未使用的URL路径下，例如/user, /goods
• 一个Blueprint并不是一个完整的应用，他不能独立于应用运行，必须注册到某一应用中

  from flask import Blueprint
  admin = Blueprint('admin', __name__)
  import app.admin.views

• 创建蓝图
  my_blueprint_module.py文件

  from flask import Blueprint
  
  my_blueprint = Blueprint('my_blueprint', __name__)

  from flask import Blueprint
  from controllers.registerDAO import Register
  
  register = Blueprint("register", __name__, url_prefix="/register")
  
  # 这里以register.route注册的函数都会自带/register，所以url是/register/select
  @register.route('/select', methods=["POST"])
  def HTRegiste_selectr():
      info = Register().select()
      return {"info": info}

• 蓝图中定义路由和视图
  my_blueprint_module.py文件

  @my_blueprint.route('/hello')
  def hello():
      return 'Hello from my_blueprint!'

• 在应用中注册蓝图
  app.py文件

  from flask import Flask
  
  app = Flask(__name__)
  
  from my_blueprint_module import my_blueprint
  app.register_blueprint(my_blueprint)

• 运行应用
  app.py文件

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

当你想要在蓝图中定义路由时，可以使用蓝图对象的 route 装饰器，就像在 Flask 应用对象上做的那样。如果你想要专门处理 GET 请求，你只需确保在定义视图函数时不指定任何方法，或者明确指定方法为 GET，因为默认情况下路由响应 GET 请求。

# my_blueprint.py
from flask import Blueprint

my_blueprint = Blueprint('my_blueprint', __name__)

@my_blueprint.route('/hello', methods=['GET'])
def hello():
    return 'Hello from Blueprint!'

@api.get() 装饰器，来定义一个路由。这种方式直观地指明了这个路由仅响应 HTTP GET 请求。使用 .get() 方法是 Flask 1.1 及更高版本中引入的一种便捷方式，它允许开发者直接指定该路由仅处理 GET 请求。这里的路由路径是 /test/execute，因此完整的 URL 路径会是 /wind-algorithm-model/test/execute，基于之前为蓝图指定的 URL 前缀。

import flask
from flask import Blueprint, request, jsonify, json
import app.utils.data_util as data_util
import pandas as pd

import importlib
import time
import numpy as np

from app.utils.rest_response import success, error
import logging

api = Blueprint('api', __name__, url_prefix='/wind-algorithm-model')
@api.get('/test/execute')
def execute():
    try:
        from main_job import execute
        model_name = request.args.get('name')
        execute(model_name)
    except Exception as e:
        logging.getLogger().error(f'接

路由模块

在 Flask 中，我们可以通过定义路由模块来为应用程序添加不同的路由规则，使得应用程序可以响应不同的 URL 请求。

• @app.route(rule, options)：定义路由规则和处理函数之间的映射关系。其中 rule 参数表示路由规则，options 参数表示路由的配置选项。

  from flask import Flask
  app = Flask(__name__)
  @app.route('/hello')
  def hello():    
    return 'Hello, World!'

• @app.before_request：在每个请求被处理之前执行的函数。通常用于执行一些预处理操作，例如验证用户的登录状态、设置全局变量等。下面的示例定义了一个 before_request 函数，用于在处理请求之前打印请求的 HTTP 方法和 URL：

  from flask import Flask, request
  app = Flask(__name__)
  @app.before_request
  def log_request():    
    print(f'Request: {request.method} {request.url}')

• @app.after_request：在每个请求被处理之后执行的函数。通常用于执行一些后处理操作，例如添加响应头信息、记录日志等。下面的示例定义了一个 after_request 函数，用于在处理请求之后添加一个名为 X-My-Header 的响应头：

  from flask import Flask
  app = Flask(__name__)
  @app.after_request
  def add_header(response):    
    response.headers['X-My-Header'] = 'Hello, World!'   
    return response

• @app.errorhandler：处理指定错误码的异常，例如 404 错误、500 错误等。可以定义多个不同的错误处理函数，以处理不同的异常情况。下面的示例定义了一个 404 错误处理函数，用于处理访问不存在的 URL 时的异常情况：

  from flask import Flask, render_template
  app = Flask(__name__)
  @app.errorhandler(404)
  def page_not_found(e):    
    return render_template('404.html'), 404

  在上面的示例中，我们定义了一个 page_not_found() 函数，并使用 @app.errorhandler(404) 装饰器将其注册为处理 404 错误的函数。在处理 404 错误时，Flask 会调用该函数，并将异常对象作为参数传入。函数返回一个包含错误信息的响应，并将 HTTP 状态码设置为 404。

from flask import Flask, request, render_template
app = Flask(__name__)
# 请求预处理函数@app.before_request
def log_request():    
  print(f'Request: {request.method} {request.url}')
# 路由规则和处理函数
#/ URL 请求将会调用 index() 函数，并返回一个字符串 'Hello, World!'。
@app.route('/')
def index():    
  return 'Hello, World!'
#/hello URL 请求将会调用 hello() 函数，并返回一个字符串 'Hello, World!'。
@app.route('/hello')
def hello():    
  return 'Hello, World!'
#/hello/<name> URL 请求将会调用 hello_name(name) 函数，并返回一个包含 name 参数的字符串 'Hello, {name}!'。
@app.route('/hello/<name>')
def hello_name(name):   
  return f'Hello, {name}!'
# 响应后处理函数
@app.after_request
def add_header(response):    
  response.headers['X-My-Header'] = 'Hello, World!'    
  return response
# 错误处理函数
@app.errorhandler(404)
def page_not_found(e):    
  return render_template('404.html'), 404
# 启动应用程序
if __name__ == '__main__':    
  app.run()

视图模块

在 Flask 中，视图模块用于处理请求并生成响应，通常由视图函数来实现。视图函数负责处理一个或多个 URL 请求，并返回一个响应对象。响应对象可以是纯文本、HTML、JSON、图像等。

from flask import Flask, request, jsonify
app = Flask(__name__)
# 视图函数
@app.route('/hello')
def hello():    
  name = request.args.get('name', 'World')    
  return f'Hello, {name}!'
@app.route('/json')
def json():    
  data = {'message': 'Hello, World!'}   
  return jsonify(data)
# 启动应用程序
if __name__ == '__main__':   
  app.run()

在上面的示例中，我们定义了两个视图函数：

1. hello() 函数处理 /hello URL 请求，使用 request.args.get() 方法获取请求参数中的 name 参数（默认为 ‘World’），并将其插入到响应字符串中返回给客户端。
2. json() 函数处理 /json URL 请求，生成一个包含 message 属性的字典对象，然后使用 Flask 提供的 jsonify() 函数将其转换为 JSON 格式的响应对象返回给客户端。
   启动 Flask 应用程序后，可以在浏览器中访问 /hello 或 /json URL 来测试视图函数的效果。

视图函数是 Flask 应用程序的核心组成部分，可以通过不同的方式生成响应，如使用模板引擎渲染 HTML 页面、返回纯文本或 JSON 数据等。视图函数还可以接受请求参数，通过 request 对象获取请求数据，并根据请求参数生成相应的响应。

模版模块

在 Flask 中，模板模块用于生成动态的 HTML 页面或其他类型的文档。Flask 支持多种模板引擎，如 Jinja2、Mako、Mustache 等，其中 Jinja2 是最常用的模板引擎之一。

下面是一个简单的 Flask 模板模块的示例，使用 Jinja2 模板引擎渲染一个 HTML 页面：

from flask import Flask, render_template
app = Flask(__name__)
# 路由规则和视图函数
@app.route('/')
def index():    
  return render_template('index.html', name='World')
# 启动应用程序
if __name__ == '__main__':    
  app.run()

在上面的示例中，我们定义了一个路由规则 /，并使用 render_template() 函数将模板文件 index.html 渲染为 HTML 页面，其中传递了一个名为 name 的变量值为 ‘World’。

下面是 index.html 模板文件的示例：

<!DOCTYPE html>
<html>  
  <head>    
    <title>
      Hello, {{ name }}!
    </title>  
  </head>  
  <body>    
    <h1>
      Hello, {{ name }}!
    </h1>  
  </body>
</html>

在上面的示例中，使用了 Jinja2 模板引擎的语法 ，它将在渲染模板时被替换为 render_template() 函数中传递的 name 变量的值。
启动 Flask 应用程序后，访问根 URL / 将会返回一个包含 Hello, World! 的 HTML 页面。
模板模块是 Flask 应用程序的重要组成部分，它可以实现动态生成各种类型的文档，如 HTML 页面、JSON 数据、CSV 文件等。在 Flask 中，使用模板引擎可以方便地将数据和 HTML 页面进行分离，实现更加清晰和易于维护的代码结构。

数据库模块

在 Flask 应用程序中，通常需要使用数据库来存储和管理数据。Flask 提供了多种数据库模块的支持，如 SQLAlchemy、Peewee、MongoDB 等。

• 安装mysql、SQLAIchemy等库
  pip install Flask-MySQLdb
  pip install SQLAlchemy
• 配置数据库连接

  from flask import Flask
  from flask_mysqldb import MySQL
  
  app = Flask(__name__)
  
  # MySQL configurations
  app.config['MYSQL_HOST'] = 'localhost'
  app.config['MYSQL_USER'] = 'your_username'
  app.config['MYSQL_PASSWORD'] = 'your_password'
  app.config['MYSQL_DB'] = 'your_database'
  
  mysql = MySQL(app)

• 数据库操作

  @app.route('/')
  def index():
      cur = mysql.connection.cursor()
      cur.execute('''SELECT user_name FROM users''')
      rv = cur.fetchall()
      return str(rv)
  
  if __name__ == '__main__':
      app.run(debug=True)