轻量级web开发框架：Flask 扩展

最新推荐文章于 2022-09-08 21:49:37 发布

薛定谔的猫96

最新推荐文章于 2022-09-08 21:49:37 发布

阅读量1k

点赞数

分类专栏： Python Flask 文章标签： Flask

本文链接：https://blog.csdn.net/qq_42415326/article/details/95590007

版权

Python 同时被 2 个专栏收录

83 篇文章 27 订阅

订阅专栏

Flask

3 篇文章 9 订阅

订阅专栏

Flask扩展

Flask通常被称为微框架，因为核心功能包括基于Werkzeug的WSGI和路由以及基于Jinja2的模板引擎。此外，Flask框架还支持cookie和会话，以及JSON，静态文件等Web帮助程序。

显然，这不足以开发完整的Web应用程序。而Flask扩展就具备这样的功能。Flask扩展为Flask框架提供了可扩展性。有大量的Flask扩展可用。

Flask扩展是一个Python模块，它向Flask应用程序添加了特定类型的支持。Flask Extension Registry（Flask扩展注册表）是一个可用的扩展目录。可以通过pip管理工具下载所需的扩展名。

在本教程中，我们将讨论以下重要的Flask扩展：

Flask Mail - 为Flask应用程序提供SMTP接口
Flask WTF - 添加WTForms的渲染和验证
Flask SQLAlchemy - 为Flask应用程序添加SQLAlchemy支持
Flask Sijax - Sijax的接口 - Python/jQuery库，使AJAX易于在Web应用程序中使用

由于扩展是一个Python模块，因此需要导入它才能使用它。Flask扩展名通常命名为flask-foo。导入的操作如下：

from flask_foo import [class, function]

对于0.7以后的Flask版本，您还可以使用语法：

import flaskext_compat
flaskext_compat.activate()
from flask.ext import foo

对于此用法，因为需要激活兼容性模块。所以是通过运行flaskext_compat.py来安装

日志

有时候你会遇到一种情况：理论上来说你处理的数据应该是正确的，然而实际上并不正确的状况。

比如你可能有一些客户端代码，代码向服务器发送一个 HTTP 请求但是显然它是错误的。这可能是由于用户篡改数据，或客户端代码失败。大部分时候针对这一情况返回400 Bad Request就可以了，但是有时候不能这样做，代码必须继续工作。

你也有可能想要记录一些发生的不正常事情。这时候日志就派上用处。

从 Flask 0.3 开始日志记录是预先配置好的。附带的 logger 是一个标准的日志类 Logger

这里有一些日志调用的例子:

app.logger.debug('A value for debugging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('An error occurred')

整合 WSGI 中间件

如果你想给你的应用添加 WSGI 中间件，你可以对内部 WSGI 应用进行封装。例如如果你想使用 Werkzeug 包中的某个中间件来应付 lighttpd 中的 bugs，你可以这样做:

from werkzeug.contrib.fixers import LighttpdCGIRootFix
app.wsgi_app = LighttpdCGIRootFix(app.wsgi_app)

Flask 邮件

基于web的应用程序通常需要具有向用户/客户端发送邮件的功能。Flask-Mail扩展使得与任何电子邮件服务器建立简单的接口变得非常容易。

首先，pip包管理工具安装Flask-Mail扩展:

pip install Flask-Mail

然后需要通过设置以下应用程序参数的值来配置Flask-Mail。

序号	参数与描述
1	MAIL_SERVER 电子邮件服务器的名称/IP地址
2	MAIL_PORT 使用的服务器的端口号
3	MAIL_USE_TLS 启用/禁用传输安全层加密
4	MAIL_USE_SSL 启用/禁用安全套接字层加密
5	MAIL_DEBUG 调试支持。默认值是Flask应用程序的调试状态
6	MAIL_USERNAME 发件人的用户名
7	MAIL_PASSWORD 发件人的密码
8	MAIL_DEFAULT_SENDER 设置默认发件人
9	MAIL_MAX_EMAILS 设置要发送的最大邮件数
10	MAIL_SUPPRESS_SEND 如果app.testing设置为true，则发送被抑制
11	MAIL_ASCII_ATTACHMENTS 如果设置为true，则附加的文件名将转换为ASCII

Flask-mail模块包含以下重要类的定义:

1. Mail类

管理电子邮件消息传递需求。类构造函数采用以下形式：

flask-mail.Mail(app = None)  #构造函数将Flask应用程序对象作为参数。

Mail类的方法：

序号	方法与描述
1	send() 发送Message类对象的内容
2	connect() 打开与邮件主机的连接
3	send_message() 发送消息对象

序号

方法与描述

send()

发送Message类对象的内容

connect()

打开与邮件主机的连接

send_message()

发送消息对象

2.Message类

封装了一封电子邮件。Message类构造函数采用以下形式：

flask-mail.Message(subject, recipients, body, html, sender, cc, bcc, reply-to, date, charset, extra_headers, mail_options, rcpt_options)

Message类方法：

attach() — 为邮件添加附件。此方法采用以下参数：

filename - 要附加的文件的名称
content_type - MIME类型的文件
data - 原始文件数据
处置 - 内容处置（如果有的话）。

add_recipient() — 向邮件添加另一个收件人。

举一个栗子：

qq mail服务的SMTP服务器用作Flask-Mail配置的MAIL_SERVER。

from flask import Flask
from flask_mail import Mail, Message   #从flask-mail导入Mail和Message类

app =Flask(__name__)

#配置Flask-Mail
app.config['DEBUG'] = True
app.config['MAIL_SERVER']='smtp.qq.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = 'yourId@gmail.com'  #你的qq邮箱
app.config['MAIL_PASSWORD'] = '*****'  #不是邮箱密码，是STMP授权码，在qq邮的设置-账号里，开启后获取
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True

mail = Mail(app)    #创建Mail类的实例

#在由URL规则（‘/’）映射的Python函数中设置Message对象。
@app.route("/")       
def index():
    msg = Message('Hello',sender='yourId@gmail.com',recipients = ['id1@gmail.com'])   #recipients是接收邮箱    msg.body = "Hello Flask message sent from Flask-Mail"
    mail.send(msg)
    return "Sent"

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

Flask WTF

Web应用程序的一个重要方面是为用户提供用户界面。HTML提供了一个<form>表单

标签，可以适当地使用Form（表单）元素，实现例如文本输入，单选按钮，选择等。

用户输入的数据以Http请求消息的形式通过GET或POST方法提交给服务器端脚本。

服务器端脚本必须从http请求数据重新创建表单元素。因此，实际上，表单元素必须定义两次 - 一次在HTML中，另一次在服务器端脚本中。
使用HTML表单的另一个缺点是很难（如果可能的话）动态呈现表单元素。HTML本身无法验证用户的输入。

这就是WTForms的作用，一个灵活的表单，渲染和验证库，能够方便使用。Flask-WTF扩展为这个WTForms库提供了一个简单的接口。

使用Flask-WTF，我们可以在Python脚本中定义表单字段，并使用HTML模板进行渲染。还可以将验证应用于WTF字段。

首先，需要pip安装Flask-WTF扩展：

pip install flask-WTF

flask-WTF包含一个Form类，该类必须用作用户定义表单的父级。

WTforms包中包含各种表单字段的定义。下面列出了一些标准表单字段。

序号	标准表单字段与描述
1	TextField 表示<input type ='text'> HTML表单元素
2	BooleanField 表示<input type ='checkbox'> HTML表单元素
3	DecimalField 用于显示带小数的数字的文本字段
4	IntegerField 用于显示整数的文本字段
5	RadioField 表示<input type = 'radio'> HTML表单元素
6	SelectField 表示选择表单元素
7	TextAreaField 表示<testarea> HTML表单元素
8	PasswordField 表示<input type = 'password'> HTML表单元素
9	SubmitField 表示<input type = 'submit'>表单元素

除了'name'字段，还会自动创建CSRF令牌的隐藏字段。这是为了防止Cross Site Request Forgery（跨站请求伪造）攻击。

渲染时，这将导致如下等效的HTML脚本：

<input id = "csrf_token" name = "csrf_token" type = "hidden" />
<label for = "name">Name Of Student</label><br>
<input id = "name" name = "name" type = "text" value = "" />

WTForms包也包含验证器类，它对表单字段应用验证很有用。

以下列表显示了常用的验证器：

序号	验证器类与描述
1	DataRequired 检查输入字段是否为空
2	Email 检查字段中的文本是否遵循电子邮件ID约定
3	IPAddress 在输入字段中验证IP地址
4	Length 验证输入字段中的字符串的长度是否在给定范围内
5	NumberRange 验证给定范围内输入字段中的数字
6	URL 验证在输入字段中输入的URL

举一个栗子：

以下示例验证器应用于Name和Email字段。需要我们自己编写下面这个Contact表单（forms.py）验证器模块，设计如下：

from flask_wtf import FlaskForm
from wtforms import TextField, IntegerField, TextAreaField, SubmitField, RadioField,SelectField

from wtforms import validators, ValidationError

class ContactForm(FlaskForm):
    name = TextField("Name Of Student",[validators.DataRequired("Please enter your name.")])   #如果验证失败，表单对象的validate()函数将验证表单数据并抛出验证错误。Error消息将发送到模板

    Gender = RadioField('Gender', choices = [('M','Male'),('F','Female')])
    Address = TextAreaField("Address")
   
    email = TextField("Email",[validators.DataRequired("Please enter your email address."),validators.Email("Please enter correct format of your email address.")])
   
    Age = IntegerField("age")
    language = SelectField('Languages', choices = [('cpp', 'C++'), ('py', 'Python')])
    submit = SubmitField("Send")

Flask应用程序脚本（formexample.py）如下：

from flask import Flask, render_template, request, flash
from forms import ContactForm     #form模块为自定义的验证器

app = Flask(__name__)
app.secret_key = 'development key'

@app.route('/contact', methods = ['GET', 'POST'])
def contact():
    form = ContactForm()
   
    if request.method == 'POST':
        if form.validate() == False:
     
            return render_template('contact.html', form = form) 
        else:
            return render_template('success.html')

    elif request.method == 'GET':
            return render_template('contact.html', form = form)

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

模板（contact.html）的脚本如下：

<!doctype html>
<html>
   <body>
   
      <h2 style = "text-align: center">Contact Form</h2>
		
      {% for message in form.name.errors %}
         <div>{{ message }}</div>
      {% endfor %}
      
      {% for message in form.email.errors %}
         <div>{{ message }}</div>
      {% endfor %}
      
      <form action = "http://localhost:5000/contact" method = post>
         <fieldset>
            <legend>Contact Form</legend>
            {{ form.hidden_tag() }}
            
            <div style = font-size:20px; font-weight:bold; margin-left:150px;>
               {{ form.name.label }}<br>
               {{ form.name }}
               <br>
               
               {{ form.Gender.label }} {{ form.Gender }}
               {{ form.Address.label }}<br>
               {{ form.Address }}
               <br>
               
               {{ form.email.label }}<br>
               {{ form.email }}
               <br>
               
               {{ form.Age.label }}<br>
               {{ form.Age }}
               <br>
               
               {{ form.language.label }}<br>
               {{ form.language }}
               <br>
               {{ form.submit }}
            </div>
            
         </fieldset>
      </form>
      
   </body>
</html>

模板success.html文件如下：

<!DOCTYPE html>
<html>
   <body>
   
      <h1>Form posted successfully</h1>

   </body>
</html>

在Python shell中运行formexample.py，访问URL http://localhost:5000/contact。显示Contact表单将如下所示：

如果有任何错误，页面将如下所示：

如果没有错误，将显示'success.html'：

Form Success Page

Flask SQLite

Python对SQlite有内置的支持。SQlite3模块附带Python发行版。在本节中，我们将了解Flask应用程序如何与SQLite交互。

创建一个SQLite数据库'database.db'并在其中创建学生表。

import sqlite3

conn = sqlite3.connect('database.db')

#print("Opened database successfully")

conn.execute('DROP TABLE students')

conn.execute('CREATE TABLE students (name TEXT, addr TEXT, city TEXT, pin TEXT)')

#print("Table created successfully")

conn.close()

#print("Close successfully")

以下举一个Flask和sqlite交互的实例

以下是Flask-SQLite应用程序的完整代码。

from flask import Flask, render_template, request
import sqlite3 as sql

app = Flask(__name__)

#'/' URL规则呈现'home.html'，它作为应用程序的入口点。
@app.route('/')
def home():
    return render_template('home.html')

#new_student()函数已绑定到URL规则（'/ addnew'）,它呈现包含学生信息表单的HTML文件。
@app.route('/enternew')
def new_student():
    return render_template('Addstudentinfo.html')

#表单数据被发布到绑定addrec()函数的'/ addrec' URL。

这个addrec()函数通过POST方法检索表单的数据，并插入学生表中。与insert操作中的成功或错误相对应的消息将呈现为'result.html'。

@app.route('/addrec',methods = ['POST', 'GET']) def addrec(): if request.method == 'POST': try: nm = request.form['nm'] addr = request.form['add'] city = request.form['city'] pin = request.form['pin'] with sql.connect("database.db") as con: #链接数据库 con.execute('CREATE TABLE students (name TEXT, addr TEXT, city TEXT, pin TEXT)') cur = con.cursor() #游标 cur.execute("INSERT INTO students (name,addr,city,pin) VALUES (?,?,?,?)",(nm,addr,city,pin) ) con.commit() #提交 msg = "Record successfully added" except: con.rollback() #回滚 msg = "error in insert operation" finally: return render_template("result.html",msg = msg) con.close() #关闭连接 #'/ list' URL将'rows'填充为包含学生表中所有记录的MultiDict对象。此对象将传递给list.html模板。 @app.route('/list') def list(): con = sql.connect("database.db") con.row_factory = sql.Row cur = con.cursor() cur.execute("select * from students") rows = cur.fetchall(); return render_template("list.html",rows = rows) if __name__ == '__main__': app.run(debug = True)

home.html 脚本如下：

<!DOCTYPE html>
<html>
   
   <head>
      <title>Student record</title>
   </head>
   <body>
     
     <a href= '/enternew'><b><h1>Add new record</h1></b></a>
     <br>
     <br>
     <a href= '/list'><b><h1>Show list</h1></b></a>
   </body>
</html>

Addstudentinfo.html的HTML脚本如下：

<!DOCTYPE html>
<html>
   <body>
      
      <form action = "{{ url_for('addrec') }}" method = "POST">
         <h3>Student Information</h3>
         Name<br>
         <input type = "text" name = "nm" /></br>
         
         Address<br>
         <textarea name = "add" ></textarea><br>
         
         City<br>
         <input type = "text" name = "city" /><br>
         
         PINCODE<br>
         <input type = "text" name = "pin" /><br>
         <input type = "submit" value = "submit" /><br>
      </form>
      
   </body>
</html>

result.html的HTML脚本包含一个转义语句{{msg}}，它显示Insert操作的结果。

<!DOCTYPE html>
<html>
   <body>
   
      result of addition : {{ msg }}
      <h2><a href = "/">go back to home page</a></h2>
      
   </body>
</html>

此list.html是一个模板，它遍历行集并在HTML表中呈现数据。

<!DOCTYPE html>
<html>
   <body>
   
      <table border = 1>
         <thead>
            <td>Name</td>
            <td>Address>/td<
            <td>city</td>
            <td>Pincode</td>
         </thead>
         
         {% for row in rows %}
            <tr>
               <td>{{row["name"]}}</td>
               <td>{{row["addr"]}}</td>
               <td> {{ row["city"]}}</td>
               <td>{{row['pin']}}</td>	
            </tr>
         {% endfor %}
      </table>
      
      <a href = "/">Go back to home page</a>
      
   </body>
</html>

从Python shell运行此脚本。在浏览器中访问http://localhost:5000/，显示一个简单的菜单：

Simple Menu

点击“添加新记录”链接以打开学生信息表单。

Adding New Record

填写表单字段并提交。底层函数在学生表中插入记录。

Record Successfully Added

返回首页，然后点击'显示列表'链接。将显示一个显示样品数据的表。

Table Showing Sample Data

Flask SQLAlchemy

在Flask Web应用程序中使用原始SQL对数据库执行CRUD（crud是指在做计算处理时的增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)）操作可能很繁琐。

相反，SQLAlchemy模块是一个强大的OR Mapper，它为应用程序开发人员提供了SQL的全部功能和灵活性。

Flask-SQLAlchemy是Flask扩展，它将对SQLAlchemy的支持添加到Flask应用程序中。

什么是ORM（Object Relation Mapping，对象关系映射）？

大多数编程语言平台是面向对象的。另一方面，RDBMS服务器中的数据存储为表。对象关系映射是将对象参数映射到底层RDBMS表结构的技术。ORM API提供了执行CRUD操作的方法，而不必编写原始SQL语句。

在本节中，我们将研究Flask-SQLAlchemy的ORM技术并构建一个小型Web应用程序。

首先，使用pip安装Flask-SQLAlchemy扩展模块。

pip install flask-sqlalchemy

然后从此模块导入SQLAlchemy类。

from flask_sqlalchemy import SQLAlchemy

要创建/使用URI中提及的数据库，需要主函数运行create_all()方法：

db.create_all()

SQLAlchemy的Session对象管理ORM对象的所有持久性操作。

以下session方法执行CRUD操作：

db.session.add (模型对象) - 将记录插入到映射表中
db.session.delete (模型对象) - 从表中删除记录
model.query.all() - 从表中检索所有记录（对应于SELECT查询）。

通过使用filter属性将过滤器应用于检索到的记录集。例如，要在学生表中检索city ='Hyderabad'的记录，请使用以下语句：

Students.query.filter_by(city = ’Hyderabad’).all()

有了这么多的背景，现在我们将为我们的应用程序提供视图函数来添加学生数据。

下面给出了应用程序（Flasksqlalchemy.py）的完整代码。

from flask import Flask, request, flash, url_for, redirect, render_template
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

#创建一个Flask应用程序对象并为要使用的数据库设置URI。
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///students.sqlite3'

#设置密钥
app.config['SECRET_KEY'] = "random string"

#应用程序对象作为参数创建SQLAlchemy类的对象，该对象包含用于ORM操作的辅助函数。
db = SQLAlchemy(app)

#db对象提供了一个Model类，使用它来声明用户定义的模型。
class students(db.Model):
    id = db.Column('student_id', db.Integer, primary_key = True)
    name = db.Column(db.String(100))
    city = db.Column(db.String(50))
    addr = db.Column(db.String(200)) 
    pin = db.Column(db.String(10))

    def __init__(self, name, city, addr,pin):
        self.name = name
        self.city = city
        self.addr = addr
        self.pin = pin

#应用程序的入口点是绑定到'/' URL的show_all()函数。学生表的记录集作为参数发送到HTML模板。模板中的服务器端代码以HTML表格形式呈现记录。
@app.route('/')
def show_all():
   return render_template('show_all.html', students = students.query.all() )

#当http方法被检测为POST时，表单数据被添加到学生表中，并且应用返回到显示添加数据的主页。
@app.route('/new', methods = ['GET', 'POST'])
def new():
    if request.method == 'POST':
        if not request.form['name'] or not request.form['city'] or not request.form['addr']:
            flash('Please enter all the fields', 'error')
        else:
            student = students(request.form['name'], request.form['city'],
            request.form['addr'], request.form['pin'])
         
            db.session.add(student)
            db.session.commit()
            flash('Record was successfully added')
            return redirect(url_for('show_all'))
    return render_template('new.html')

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

'show_all.html'的HTML脚本如下：

<!DOCTYPE html>
<html lang = "en">
   <head></head>
   <body>
      
      <h3>
         <a href = "{{ url_for('show_all') }}">Comments - Flask 
            SQLAlchemy example</a>
      </h3>
      
      <hr/>
      {%- for message in get_flashed_messages() %}
         {{ message }}
      {%- endfor %}
		
      <h3>Students (<a href = "{{ url_for('new') }}">Add Student
         </a>)</h3>
      
      <table>
         <thead>
            <tr>
               <th>Name</th>
               <th>City</th>
               <th>Address</th>
               <th>Pin</th>
            </tr>
         </thead>
         
         <tbody>
            {% for student in students %}
               <tr>
                  <td>{{ student.name }}</td>
                  <td>{{ student.city }}</td>
                  <td>{{ student.addr }}</td>
                  <td>{{ student.pin }}</td>
               </tr>
            {% endfor %}
         </tbody>
      </table>
      
   </body>
</html>

new.html的脚本如下：

<!DOCTYPE html>
<html>
   <body>
   
      <h3>Students - Flask SQLAlchemy example</h3>
      <hr/>
      
      {%- for category, message in get_flashed_messages(with_categories = true) %}
         <div class = "alert alert-danger">
            {{ message }}
         </div>
      {%- endfor %}
      
      <form action = "{{ request.path }}" method = "post">
         <label for = "name">Name</label><br>
         <input type = "text" name = "name" placeholder = "Name" /><br>
         <label for = "email">City</label><br>
         <input type = "text" name = "city" placeholder = "city" /><br>
         <label for = "addr">addr</label><br>
         <textarea name = "addr" placeholder = "addr"></textarea><br>
         <label for = "PIN">pincode</label><br>
         <input type = "text" name = "pin" placeholder = "pin" /><br>
         <input type = "submit" value = "Submit" />
      </form>
      
   </body>
</html>

从Python shell运行脚本，并在浏览器中输入http://localhost:5000/。

Flask SQLAlchemy Example

点击“添加学生”链接以打开学生信息表单。

Add Student

填写表单并提交。主页将重新显示提交的数据。

我们可以看到输出如下所示。

Flask SQLAlchemy Example Output

Flask Sijax

AJAX 是与服务器交换数据的技术，它在不重载全部页面的情况下，实现了对部分网页的更新。

AJAX = 异步 JavaScript 和 XML（Asynchronous JavaScript and XML）。

Sijax代表'Simple Ajax'，它是一个Python/jQuery库，旨在帮助您轻松地将Ajax引入到您的应用程序。它使用jQuery.ajax来发出AJAX请求。

首先，通过pip安装Flask-Sijax：

pip install flask-sijax

配置：

SIJAX_STATIC_PATH - Sijax javascript文件的静态路径。默认位置是static/js/sijax。在这个文件夹中，保存了sijax.js和json2.js文件。
SIJAX_JSON_URI - 从中加载json2.js静态文件的URI

Sijax使用JSON在浏览器和服务器之间传递数据。这意味着浏览器需要本机支持JSON或从json2.js文件支持JSON支持。

以这种方式注册的函数不能提供Sijax功能，因为默认情况下无法使用POST方法访问它们（并且Sijax使用POST请求）。

要使View函数能够处理Sijax请求，可以使用@app.route('/url'，methods = ['GET'，'POST'])通过POST对其进行访问，或使用类似@flask_sijax.route辅助装饰器，比如：

@flask_sijax.route(app, '/hello')

每个Sijax处理函数（像这样）都会自动接收至少一个参数，就像Python将'self'传递给对象方法一样。'obj_response'参数是函数回复浏览器的方式。

def say_hi(obj_response):
   obj_response.alert('Hi there!')

当检测到Ajax请求时，Sijax会像这样处理它：

g.sijax.register_callback('say_hi', say_hi)
   return g.sijax.process_request()

Sijax应用程序

最小的Sijax应用程序代码如下：

import os
from flask import Flask, g
from flask_sijax import sijax

path = os.path.join('.', os.path.dirname(__file__), 'static/js/sijax/')
app = Flask(__name__)

app.config['SIJAX_STATIC_PATH'] = path
app.config['SIJAX_JSON_URI'] = '/static/js/sijax/json2.js'
flask_sijax.Sijax(app)

@app.route('/')
def index():
    return 'Index'
	
@flask_sijax.route(app, '/hello')
def hello():
    def say_hi(obj_response):
        obj_response.alert('Hi there!')
    if g.sijax.is_sijax_request:
        #检测到Sijax请求-让Sijax处理它
        g.sijax.register_callback('say_hi', say_hi)
        return g.sijax.process_request()
    return _render_template('sijaxexample.html')

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

当一个Sijax向服务器请求(一个特殊的jQuery.ajax()请求)时，这个请求在服务器上被g.sijax.is_sijax_request()检测到，在这种情况下，就会自动让Sijax处理请求。所有使用g.sijax.register_callback()注册的函数都公开给浏览器进行调用。调用g.sijax.process_request()告诉Sijax执行适当的(之前注册的)函数并将响应返回给浏览器。

Flask FastCGI

FastCGI是在nginx，lighttpd和Cherokee等web服务器上的Flask应用程序的另一个部署选项。

配置FastCGI？

首先，您需要创建FastCGI服务器文件。例如它的名称为:yourapplication.fcgiC 。

from flup.server.fcgi import WSGIServer
from yourapplication import app

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

nginx和较早版本的lighttpd需要显式传递套接字以与FastCGI服务器通信。为此，您需要将套接字的路径传递到WSGIServer。

WSGIServer(application, bindAddress = '/path/to/fcgi.sock').run()

配置Apache？

对于基本的Apache部署，您的.fcgi文件将出现在您的应用程序URL中。例如：http://example.com/yourapplication.fcgi/hello/。有几种方法可以配置您的应用程序，以使yourapplication.fcgi不会出现在URL中，比如：

<VirtualHost *>
   ServerName example.com
   ScriptAlias / /path/to/yourapplication.fcgi/
</VirtualHost>

配置lighttpd？

lighttpd的基本配置如下所示：

fastcgi.server = ("/yourapplication.fcgi" => ((
   "socket" => "/tmp/yourapplication-fcgi.sock",
   "bin-path" => "/var/www/yourapplication/yourapplication.fcgi",
   "check-local" => "disable",
   "max-procs" => 1
)))

alias.url = (
   "/static/" => "/path/to/your/static"
)

url.rewrite-once = (
   "^(/static($|/.*))$" => "$1",
   "^(/.*)$" => "/yourapplication.fcgi$1"
)

请记住启用FastCGI，alias和rewrite模块。此配置将应用程序绑定到/yourapplication。

薛定谔的猫96

关注

0
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
轻量级web开发框架：Flask 扩展

Flask扩展Flask通常被称为微框架，因为核心功能包括基于Werkzeug的WSGI和路由以及基于Jinja2的模板引擎。此外，Flask框架还支持cookie和会话，以及JSON，静态文件等Web帮助程序。显然，这不足以开发完整的Web应用程序。而Flask扩展就具备这样的功能。Flask扩展为Flask框架提供了可扩展性。有大量的Flask扩展可用。Flask扩展是一个Pyth...
复制链接

扫一扫