[TOC]
# 一、请求中间件
**中间件：**
```python
1 before_first_request 当项目启动后，接收到的第一个请求，就会执行before_first_request装饰的函数，执行顺序也是谁先注册就谁先执行
2 before_request 请求没有经过响应函数的时候，会执行before_request装饰的函数，谁先注册谁先执行。只要有一个函数有返回值，后面的所有before_request都不会执行，且响应函数也不会执行。其有没有返回值都不会影响after_request的执行
3 after_request是再before_request与响应函数执行后执行。他必须接收响应参数，并且要把响应返回。执行顺序是谁先注册后执行。
```
**使用**
```python
from flask import Flask, request
app = Flask(__name__)
# 执行顺序：1-2-3-5-4
# 1.整个项目的第一次
@app.before_first_request
def first():
print('我的第一次')
# 2.响应函数之前执行，先注册先执行
@app.before_request
def beforel():
print('我是before1')
# 3.响应函数之前执行，先注册先执行
@app.before_request
def before2():
print('我是before2')
# 5.响应函数之后执行,先注册后执行
@app.after_request
def after1(response):
print('响应后的参数2', response)
print('after1')
return response
# 4.响应函数之后执行,先注册后执行
@app.after_request
def after2(response):
print('响应后的参数1', response)
print('after2')
return response
@app.route('/')
def index():
return "ok"
if __name__ == '__main__':
app.run()
```
# 二、请求中间件额外方法(重写源码)
```python
##了解的知识点
from flask import Flask
app = Flask(__name__)
class MyMiddleware:
def __init__(self,old_wsgi_app):
self.old_wsgi_app =old_wsgi_app
def __call__(self, environ, start_response):
#这befor的befor
print("响应函数开始之前干的事情")
ret = self.old_wsgi_app(environ, start_response)
#这是after的after
print("结束函数结束之后干的事情")
return ret
@app.route("/")
def index():
return "ok"
if __name__ == '__main__':
app.wsgi_app = MyMiddleware(app.wsgi_app)
app.run()
```
# 三、请求错误处理
```
1 teardown_request,一旦遇到错误就会执行，并且把错误传递给teardown_request装饰的函数, 没有错误也会执行，但是是错误为None,他并不能处理错误，只能记录
2 errorhandle 可以捕获错误，并且对错误做出响应，返回给用户,如果你要用errorhandler你必须指定他捕获哪种类型的错误，就必须传错误码，然后就返回值，返回给用户
```
```python
# 遇到错误就执行
@app.teardown_request
def tear(e):
print(e)
print('我是teardown')
# 捕获错误，传错误码
@app.errorhandler(500)
def error_500(e):
print(e)
return '程序已崩500'
# 捕获错误，传错误码
@app.errorhandler(404)
def error_500(e):
print(e)
return '程序已崩404'
@app.route('/')
def index():
return render_template('index1.html')
if __name__ == '__main__':
app.run()
```
# 四、请求标签、过滤器
```python
# 相当于一个函数，可以在页面中使用它,要加括号
# 相当于django中的标签
@app.template_global()
def get_sum(a,b):
return a+b
# django中的过滤器
@app.template_filter()
def get_something(a,b,c,d):
return a+b+c+d
@app.route('/')
def index():
return render_template('index1.html')
if __name__ == '__main__':
app.run()
```
index1.html 使用
```html
index1页面
{{get_sum(1,1)}}
{{1|get_something(1,1,1)}}
```
# 五、CBV写法
## 基础版
```python
from flask import Flask,views,url_for
app = Flask(__name__)
def tt(func):
def inner(*args,**kwargs):
print("你追到我。。")
rv = func(*args,**kwargs)
print("嘿嘿嘿。。。")
return rv
return inner
class Index(views.View):
methods = ["GET"] #规定哪些请求方式可以请求我这个路由
decorators =[tt,] #这个是给 我们的响应添加装饰器
def dispatch_request(self):
return "ojbk"
app.add_url_rule("/index",view_func=Index.as_view(name="index"),endpoint="index1")
# 1 为什么要给as_view传递name= "index",
# 2 他作用Index.as_view(name="index")他返回是的view这个函数对象，我们传递name="index"是给view的__name__改变名字。如果不传，我没有办法通过名字来找路由的映射关系，因为都是”view“
```
## 常用版
```python
from flask import Flask,views,url_for
app = Flask(__name__)
def tt(func):
def inner(*args,**kwargs):
print("响应函数开始之前干的事情")
rv = func(*args,**kwargs)
print("结束函数结束之后干的事情")
return rv
return inner
class Login(views.MethodView):
methods = ["GET","POST"] # 规定哪些请求方式可以请求我这个路由
decorators = [tt, ] # 这个是给 我们的响应添加装饰器
def get(self):
print(url_for("index1"))
return "get"
def post(self):
return "post"
app.add_url_rule("/login",view_func=Login.as_view(name="login"))
#实现方法是重写了dispatch_request,通过请求方法，来找到当前类中的函数。
if __name__ == '__main__':
app.run()
```
