初始化

初始化

Flask程序创建一个Flask类的对象，使用WSGI协议把客户端的所有请求转发给这个对象。

from flask import Flask
app = Flask(__name__)

Flask类的构造函数只有一个必须制定的参数，即程序主模块或包的名字。
Flask 用这个参数决定程序的根目录，以便稍后能够找到相对于程序根目录的资源文件位置。

路由和视图函数

客户端把请求发送给Web服务器，Web服务器再把请求发送给Flask对象，Flask对象要知道每个URL应该对应哪些代码，所以保存了一个URL到Python函数的映射关系。

处理URL和函数之间关系的程序称为路由。

@app.route('/')
def index():
    return '<h1>Hello World!</h1>'

使用修饰器把函数注册为事件的处理程序，这是python修饰器的惯用手法。

像 index() 这样的函数称为视图函数（ view function）。视图函数返回值称为响应。响应可以是包含HTML 的简单字符串，也可以是复杂的表单。

上面的视图函数是根地址的处理函数，但是在日常的某些URL中，会发现地址中包含可变的部分，例如http://www.facebook.com/<your-name>这个URL，其中的<your-name>是可变的部分。
为了统一的处理这种URL，Flask提供下面的处理方式：

@app.route('/user/<name>')
def user(name):
    return '<h1>Hello, %s!</h1>' % name

Flask将任何能匹配静态部分的URL都映射到这个路由上，调用视图函数时，Flask将动态部分作为参数传递给视图函数。

1. URL的动态部分作为视图函数的参数时，默认使用字符串，也即是说视图函数中得到的这个值是字符串类型的。当然也可以使用/user/<int:id>
2. 能匹配到静态部分，不是说可以没有动态部分，必须有动态部分。

一个完整的程序

from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
    return '<h1>Hello World!</h1>'

@app.route('/user/<name>')
def user(name):
    return '<h1>Hello, %s!</h1>' % name


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

其中debug的作用是方便调试用，利用nohup command &在后台启动程序，然后源代码修改后，自动加载。
host设定为0.0.0.0是为了能够非本机访问，默认127.0.0.1，只能本机使用localhost访问。
这里视图函数user的参数name必须和路由中的<name>命名一致。否则对应不上。其实后面处理的方式是理由key-value的字典实现的。

上面的动态路由可以修改成这样：

@app.route('/user') 
def getname():      
    name = request.args.get('name', 0)
    return '<h1>Hello, %s!</h1>' % name

客户端请求的URL修改为：

http://10.16.21.80:5000/user?name=stemon

Flask请求上下文和程序上下文

请求对象request封装了客户端发送的HTTP请求，具体的流程如下图：

由于一个路由表中有很多视图函数，要想让视图函数能够访问request请求对象， 一个显而易见的方式是将其作为参数传入视图函数，不过这会导致程序中的每个视图函数都增加一个参数。如果视图函数还要处理其他请求对象，情况就很糟糕。

路由表就是后文说到的URL映射，URL 映射是 URL 和视图函数之间的对应关系。

解决办法：
Flask 使用上下文临时把某些对象变为全局可访问。有了上下文，就可以写出下面的视图函数：

from flask import request

@app.route('/')
def index():
    user_agent = request.headers.get('User-Agent')
    return '<p>Your browser is %s</p>' % user_agent

这里问题又来了：在多线程服务器中，多个线程同时处理不同客户端发送的不同的请求时，每个线程看到的request请求对象必然是不同的。否则会发生下图中的问题：一个用户得到了另一个用户请求的内容：

所以不能不request请求对象设置成真正的全部对象，Flask使用上下文使特定变量在一个线程中全局可以访问，与此同时不会干扰其他线程。

在 Flask 中有两种上下文： 程序上下文和请求上下文。

Flask类对象在分发请求之前，必须激活（推送）请求上下文和程序上下文，请求处理完成之后，在将其删除。只有上下文被推送之后，在线程中才可以使用上图中的四个变量。

这就是真正的全局变量与线程内全局变量的区别，线程内的全局变量必须被激活（推送）后才可以使用。而真正的全局变量只要程序起来就可以使用。

>>> from app import app
>>> from flask import current_app
>>> current_app.name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/root/zhaofaquan/local/lib/python2.7/site-packages/werkzeug/local.py", line 343, in __getattr__
    return getattr(self._get_current_object(), name)
  File "/root/zhaofaquan/local/lib/python2.7/site-packages/werkzeug/local.py", line 302, in _get_current_object
    return self.__local()
  File "/root/zhaofaquan/local/lib/python2.7/site-packages/flask/globals.py", line 51, in _find_app
    raise RuntimeError(_app_ctx_err_msg)
RuntimeError: Working outside of application context.

This typically means that you attempted to use functionality that needed
to interface with the current application object in a way.  To solve
this set up an application context with app.app_context().  See the
documentation for more information.
>>> app_cxt = app.app_context()
>>> app_cxt.push()
>>> current_app.name
'app'
>>> app_cxt.pop()

在程序实例上调用 app.app_context() 可获得一个程序上下文。

Flask请求调度

再次重申：

处理URL和视图函数之间映射关系的程序称之为路由。

程序收到客户端发来的请求时，要找到处理该请求的视图函数。
为了完成这个任务， Flask会在程序的 URL 映射中查找请求的 URL。 URL 映射是 URL 和视图函数之间的对应关系。
Flask 使用 app.route 修饰器或者非修饰器形式的 app.add_url_rule() 生成映射。

>>> from app import app
>>> app.url_map
Map([<Rule '/' (HEAD, OPTIONS, GET) -> index>,
 <Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
 <Rule '/user/<name>' (HEAD, OPTIONS, GET) -> user>])

从上面可以看到url， 可以接受的http请求method，对应的视图函数。

Flask 为每个路由都指定了请求方法， 这样不同的请求方法结合到相同的 URL 上时，会使用不同的视图函数进行处理。

Flask视图函数响应

Flask调用视图函数后，视图函数会将其返回值作为响应的内容。
HTTP 响应中一个很重要的部分是状态码， Flask 默认设为 200，这个代码表明请求已经被成功处理。
如果视图函数返回的响应需要使用不同的状态码， 那么可以把数字代码作为第二个返回值，添加到响应文本之后。例如，下述视图函数返回一个 400 状态码，表示请求无效：

@app.route('/')
def index():
    return '<h1>Bad Request</h1>', 400

状态码不影响返回的内容，二者没有关系。

视图函数返回的响应还可接受第三个参数，这是一个由首部（ header）组成的字典，可以添加到 HTTP 响应中。

如果不想返回由 1 个、 2 个或 3 个值组成的元组， Flask 视图函数还可以返回 Response 对象。 make_response() 函数可接受 1 个、 2 个或 3 个参数（和视图函数的返回值一样），并
返回一个 Response 对象。有时我们需要在视图函数中进行这种转换，然后在响应对象上调用各种方法，进一步设置响应。

from flask import make_response
@app.route('/')
def index():
    response = make_response('<h1>This document carries a cookie!</h1>')
    response.set_cookie('answer', '42')
    return response

有一种名为重定向的特殊响应类型。 这种响应没有页面文档，只告诉浏览器一个新地址用以加载新页面。
重定向响应可以使用3 个值形式的返回值生成， 也可在 Response 对象中设定。不过，由于使用频繁， Flask 提供了 redirect() 辅助函数，用于生成这种响应：

from flask import redirect

@app.route('/')
def index():
    return redirect('http://www.example.com')

还有一种特殊的响应由 abort 函数生成，用于处理错误。
在下面这个例子中，如果 URL 中动态参数 id 对应的用户不存在，就返回状态码 404：

from flask import abort
@app.route('/user/<id>')
def get_user(id):
    user = load_user(id)
    if not user:
        abort(404)
    return '<h1>Hello, %s</h1>' % user.name

注意， abort 不会把控制权交还给调用它的函数，而是抛出异常把控制权交给 Web 服务器。

Flask扩展

1. 使用Flask-Script支持命令行选项

Flask的Web服务器启动支持很多设置选项，但是只能在脚本中作为app.run()的参数传递进去。使用flask-script 扩展可以以命令行参数的方式设置Web服务器的启动选项。

(venv) $ pip install flask-script

模板

Flask的视图函数的作用很明确：

生成请求的响应。

假设现在有一个需求，要从数据库中抓取数据然后以表格的形式展现给用户。
这里面有业务逻辑和表现逻辑，其中访问数据库并抓取数据是业务逻辑；以表格的形式展现给用户是表现层。

为了分离业务逻辑和表现逻辑，引入模板的概念。
Flask引入Jinja2模板，它就是一个包含响应文本的文件，其中包含用占位变量表示的动态部分，其具体值只有在请求的上下文中才能知道。

from flask import Flask, render_template

#index.html的样子：<h1>Hello World!</h1>
@app.route('/')
def index():
    return render_template('index.html')

#user.html的样子：<h1>Hello, {{ name }}!</h1>  
@app.route('/user/<name>')
def user(name):
    return render_template('user.html', name=name)

Flask 提供的 render_template 函数把 Jinja2 模板引擎集成到了程序中。 render_template 函数的第一个参数是模板的文件名。 随后的参数都是键值对，表示模板中变量对应的真实值。

左边的“ name”表示参数名，就是模板中使用的占位符；右边的“ name”是当前作用域中的变量，表示同名参数的值。

如果模板中有一些动态占位变量在渲染的过程中，没有被赋值，那么它们在展现的时候就是空。

Jinja2模板中的变量支持很多的类型，甚至可以是某个对象的方法：

<p>A value from a dictionary: {{ mydict['key'] }}.</p>
<p>A value from a list: {{ mylist[3] }}.</p>
<p>A value from a list, with a variable index: {{ mylist[myintvar] }}.</p>
<p>A value from an object's method: {{ myobj.somemethod() }}.</p>

JinJa2控制结构

{% if user %}
Hello, {{ user }}!
{% else %}
Hello, Stranger!
{% endif %}

<ul>
{% for comment in comments %}
<li>{{ comment }}</li>
{% endfor %}
</ul>

模板继承

JinJa2对宏的支持：

{% macro render_comment(comment) %}
<li>{{ comment }}</li>
{% endmacro %}
<ul>
{% for comment in comments %}
{{ render_comment(comment) }}
{% endfor %}
</ul>

为了重复使用宏，我们可以将其保存在单独的文件中，然后在需要使用的模板中导入：

{% import 'macros.html' as macros %}
<ul>
{% for comment in comments %}
{{ macros.render_comment(comment) }}
{% endfor %}
</ul>

3.4链接

如果在模板中需要URL时，可以直接在模板中编写简单的路由，但是太low了。
同时也会对代码中定义的路由产生不必要的依赖关系。如果重新定义路由，模板中的链接可能失效。

Flask提供url_for函数，可以使用程序URL映射 中保存的信息，从视图函数名映射到URL。
url_for函数的参数：

url_for(视图函数名，关键字参数，_external=True)

注意：如果关键字参数是URL动态部分中的键，就把这个值传递过去。否则就生成查询键值对。

如url_for('index', page=2)的返回结果是/?pages=2。_external控制生成的URL是相对地址的还是绝对地址。

Flask静态文件

对静态文件的引用被当成一个特殊的路由， 即 /static/<filename>。
直接来一个例子：

其中hello.js 就是一个最简单的js函数：