今日内容概要

• 闪现
• 请求扩展
• g对象

今日内容详细

闪现

1.一个请求--->假设出错了--->重定向到另一个地址--->把错误信息在另一个返回中看到
错误信息放个位置---->另一个请求过来，去那个位置拿
	把一些数据，放在某个位置--->后期可以去取出来---->取完不用删除，就没了
2.代码：
  @app.route('/')
  def index():
      return redirect('/errors')


  @app.route('/errors')
  def error():
      return render_template('index.html')

3.闪现
	1.设置:flash('aaa')
	2.取值：get_flashed_message()
	3.分类放:flash('超时错误', category="x1")
	4.分类取:data = get_flashed_messages(category_filter=['x1'])

4.django 的message就是做这个事的
5.闪现有什么用？
	1.暂时存数据
  2.当次请求出错了，下次请求要显示这个错误

代码

from flask import Flask,flash,get_flashed_messages
  app = Flask(__name__)
  app.debug = True
  app.secret_key = 'fdsgdfgbdfd'  # 只要用闪现--->就要设置secret_key---->放到session中了

  @app.route('/')
  def index():
      flash('nana')
      return 'ok'

  @app.route('/home')
  def home():
      name = get_flashed_messages()
      print(name)  # ['nana'],再访问就没了
      return 'home'

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

from flask import Flask,flash,get_flashed_messages


app = Flask(__name__)
app.debug = True

app.secret_key = 'fdsgdfgbdfd'  # 只要用闪现--->就要设置secret_key---->放到session中了

@app.route('/')
def index():
    flash('超时错误',category='x1')
    return 'ok'


@app.route('/home')
def home():
    name = get_flashed_messages(category_filter=['x1'])
    print(name)  # ['nana'],再访问就没了
    return 'home'


@app.route('/func1')
def func1():
    name = get_flashed_messages(category_filter=['x2'])
    print(name)  # ['nana'],再访问就没了
    return 'func1'

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

请求扩展

1.flask的请求扩展，类似于django中的中间件
2.请求来了，请求走了，做一些拦截
  1.before_request  # 每个请求来了，都会走
  2.after_request
  3.before_first_request
  4.teardown_request
  5.errorhandler
  6.template_global
  7.template_filter
        

before_request

请求来了执行--->process_request--->可以下多个，从上往下依次执行

类比django中间件中的process_request，在请求收到之前绑定一个函数做一些事情

1.返回None，会执行下一个请求扩展，如果返回4件套，直接就返回了，不再往下执行了
2.多个before_request，从上往下执行

from flask import Flask,request,render_template

app = Flask(__name__)
app.debug = True

app.secret_key = 'fdsgdfgbdfd'

@app.before_request
def before():
    # 当次的请求对象就是request
    # 返回None，会执行下一个请求扩展，如果返回4件套，直接就返回了，不再往下执行了
    # 1.判断当前的路进
    # if request.path =='/':
    #     print('可以访问')
    # else:
    #     print('不可以访问')
    #     return render_template('error.html')

    # 2.判断如果是跟路径，向request对象中放个name，其他不放
    # if request.path == '/':
    #     request.name ='nana'
    print('1111来了')

@app.before_request
def suibian():
    print('2222来了')

@app.route('/')
def index():
    # print(request.name)
    return 'ok'

@app.route('/home')
def home():

    # print(request.name)  # 报错
    return 'home'

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

after_request

类比django中间件中的process_response，每一个请求之后绑定一个函数，如果请求没有异常

1.作用：可以处理跨域

from flask import Flask,request,render_template
app = Flask(__name__)
app.debug = True

app.secret_key = 'fdsgdfgbdfd'

@app.before_request
def suibian():
    print('2222来了')


@app.after_request
def after1(response):
    # 1.处理跨域
    response.headers['token']='dsafcdfvdg'
    
    # 2.多个before_request，从上往下执行
    print('111走了')
    return response

@app.after_request
def after2(response):
    print('222走了')
    return response

"""
1111来了
2222来了
222走了
111走了
"""

@app.route('/')
def index():
    # print(request.name)
    return 'ok'

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

before_first_request

第一次请求时,跟浏览器无关

@app.before_first_request
def first():
    pass

teardown_request

每一个请求之后绑定一个函数，即使遇到了异常--->一般用来记录日志--->不能做统一异常处理

from flask import Flask,request,render_template,jsonify
app = Flask(__name__)
app.debug = True
app.secret_key = 'fdsgdfgbdfd'

@app.teardown_request
def tear(e):
    print(e) # 出了异常，e就是异常对象，如果没有异常，e就是None
    if e:  # 不能做统一异常处理
        return jsonify({'code':101,"msg":'错了'})  # 还是报错

@app.route('/')
def index():
    # print(request.name)
    a = [1,2,3]
    print(a[4])
    return 'ok'

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

errorhandler

路径不存在时404，服务器内部错误500

from flask import Flask,request,render_template,jsonify,redirect
app = Flask(__name__)
app.debug = True
app.secret_key = 'fdsgdfgbdfd'

@app.errorhandler(404)
def err(e):
    # print(e)
    err_msg=e
    return render_template('error.html',err_msg=err_msg)



@app.route('/')
def index():

    return redirect('/login')

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

template_global

1.template_global 全局标签，所有页面都可以用
@app.template_global()
def add(a1, a2):
    return a1 + a2
  
"""
<h1>{{add(4,5)}}</h1>
"""

template_filter

2.template_filter 全局过滤器
@app.template_filter()
def db(a1, a2, a3):
    print(a1)
    return a1 + a2 + a3
  
"""
{{4|db(5,6)}}
"""

g对象

1.请求来了，在request中放个path，后续的视图函数中都能拿到
2.flask不建议向request对象中放变量，建议使用g对象
3.g对象，当次请求中放入的变量，在当次请求中一直存在
4.global的缩写，global
5.g和session的区别
	g只针对于当次请求
  session可以跨请求

from flask import Flask, flash, get_flashed_messages, request, render_template, jsonify, g

app = Flask(__name__)

@app.before_request
def before():
    if request.path == '/':
        g.path = 'lqz'

def test():
    print("test", g.path)

def add():
    return g.a + g.b

@app.route('/')
def index():
    print(g.path)
    test()
    g.a = 10
    g.b = 100
    add()
    print(g.a)
    return 'index'

@app.route('/home')
def home():
    print(g.path)  # 没有的
    return 'home'

if __name__ == '__main__':
    app.run(port=8080)