Flask请求与响应

请求与响应

# 请求对象 request
def index():
    print(request.method)  # 请求方式
    print(request.form)  # post请求数据 
    print(request.args)  # get请求数据
    print(request.path)  # 不带域名的请求路径
    print(request.data)  # 获取的json格式数据 二进制
    print(request.cookies)  # 获取客户端的cookie
    print('----', request.headers, '-----')  # 请求头中的数据
    print(request.host)  # 请求地址
    print(request.files) # 文件数据
    return ''

# 响应对象 response
def index():
    # 先做一个响应对象
    response = make_response()
    response.headers['session'] = 'wasdzsgfhyjtdjfaiaug2134'  # 给响应头里写数据
    response.set_cookie('cookie','hahhaha')  # 设置cookie 以k，v形式设置
    response.delete_cookie('cookie')  # 删除cookie
    return response
 '''
 cookie的一些参数：
 1.max_age=None 超时时间 cookie需要延续的时间，如果为none会延续到浏览器关闭为止
 2.expires=None 过期时间
 3.path='/' cookie生效的路径【根路径的cookie可以被任何url的页面访问，浏览器只会把cookie回传给带有该路径的页面，这样可以避免将cookie传给站点中的其他应用】
 4.domain=None cookie生效的域名，可以用这个参数来构造一个跨站cookie 【如果为none只能由设置它的站点读取】
 5.secure=False  浏览器将通过https来回传cookie
 6.HTTP only=False 只能按照http协议传输 无法被js获取
 '''

session的使用【很重要】

# session原理  【django】
1.请求过来的时候设置一个session request.session['name']='hahhahah'
    - 会随机生成一个字符串  ghhvjxjbkf
    - 把session字典序列化放到djangosession表中
    - 以session为key,随机字符串为value,写入到cookie中
       session：ghhvjxjbkf
2.下次再访问的时候
   - 携带随机字符串
   - 根据session取出随机字符串
   - 去django-session表中根据这个随机字符串取出value值，解密，得到字典
   - 放到request.session中  下次直接点session就可以获取到上次写入的name的值

session的生成是在中间件中完成的
1.先判断request.session是否为空 如果是空的不做任何操作
2.不为空的话
     - 判断值是否改过：改过的话重写到session表中的value
     - 没改过：不做任何操作

# flask的session设置
1.设置session
 - app.secret_key = 'dsazfdgfhjghjz'
 - session['name'] = 'summer'
2.取值
 - session.get('name')
 
- 先判断session是否为空,不是空的话又加了东西，把这个字典序列化使用密钥加密把加密串以cookie的形式写入到浏览器中
- 在进入视图函数之前，根据session取出三段，反序列化解密成session对象，在后续的视图函数中使用

session源码分析

# 入口是app() 对象加括号会执行类的__call__方法
 - return self.wsgi_app(environ, start_response)

1.查看wsgi_app方法
def wsgi_app(self, environ,start_response):
    ctx = self.request_context(environ)
            try:
                try:
                    ctx.push()  # 执行了push方法
                    response = self.full_dispatch_request()
                except Exception as e:
                    error = e
                    response = self.handle_exception(e)
                except: 
                    error = sys.exc_info()[1]
                    raise
                return response(environ, start_response)
            finally:
                ctx.pop(error)
2.查看push方法
def push(self):
    if self.session is None:
        # flask对象中的方法 session_interface = SecureCookieSessionInterface()
        session_interface = self.app.session_interface   
        # 如果session是空的会执行open_session方法
        self.session = session_interface.open_session(self.app, self.request)
        if self.session is None:
            self.session = session_interface.make_null_session(self.app)
            
3.查看SecureCookieSessionInterface()里的open_session方法 【请求来的时候执行】
def open_session(self, app, request):
        s = self.get_signing_serializer(app)
        if s is None: 
            return None
        # 此时的val就是上面的session的三段式 【加密串】
        val = request.cookies.get(self.get_cookie_name(app))
        if not val:  # 判断session是否有值
            return self.session_class()
        max_age = int(app.permanent_session_lifetime.total_seconds())
        try:
            data = s.loads(val, max_age=max_age)
            return self.session_class(data)
        except BadSignature:
            return self.session_class()
        
 4.查看save_session方法【请求走的时候执行】
def save_session(self, app, session,response) :
    name = self.get_cookie_name(app)
    domain = self.get_cookie_domain(app)
    path = self.get_cookie_path(app)
    secure = self.get_cookie_secure(app)
    samesite = self.get_cookie_samesite(app)
    httponly = self.get_cookie_httponly(app)
    if not session:  # 如果session有值的话
        if session.modified:   # 判断当前的session是否改值
            response.delete_cookie(  # 将当前的cookie删除
                name,
                domain=domain,
                path=path,
                secure=secure,
                samesite=samesite,
                httponly=httponly,)
            return
        if session.accessed:
            response.vary.add("Cookie")

            if not self.should_set_cookie(app, session):
                return

            expires = self.get_expiration_time(app, session) 
            # 给重写的session做序列化 加密
            val = self.get_signing_serializer(app).dumps(dict(session))  
            response.set_cookie(  # 设置cookie
                name,
                val,  
                expires=expires,
                httponly=httponly,
                domain=domain,
                path=path,
                secure=secure,
                samesite=samesite,)


  # 总结
1.当请求来的时候，会执行open_session,从中取出cookie，判断是否为空，不为空的话反序列化解密，变成字典转到session对象中，从视图函数中用session.get就可以取值
2.当请求走的时候，会执行save_session,session转成字典,序列化加密成三段放到cookie中

闪现

# 作用： 访问a页面时，出现错误，重定向到b页面，要在b页面展示a页面的错误信息
必须要设置 app.secret_key = '' 才可以使用

使用: 【方式一】
    flash('没有权限访问')
取值：
    get_flashed_messages() 

分类设置和获取 【方式二】
设置：
    flash('没有访问权限',category='1')
    flash('没有登录',category='2')
取值：
    errors = get_flashed_messages(category_filter=['1'])
    
【类似于django中的message框架】

请求扩展

# 类似于django的中间件 
1.before_request:在请求进视图函数之前执行
    【从上往下依次执行 遇到返回四件套就会直接返回 不再走后面的视图函数】
2.after_request:在请求从视图函数走之后执行 【可以在响应头中写东西】
    【从下往上执行，要有参数和返回值，参数就是response对象，返回值也是response对象】
3.before_first_request：项目启动后，第一次访问会执行，以后再也不执行了
4.teardown_request:每一个请求之后绑定一个函数，即使遇到了异常，每个请求走，都会执行，记录错误日志
    @app.teardown_request
    def tear_down(e):
        print(e)  # 如果有异常，这是异常对象
        print('我执行了')
        
5.errorhandler路径不存在时404，服务器内部错误500
# @app.errorhandler(404)
# def error_404(arg):
#     print('404会执行我')
#     # return "404错误了"
#     return render_template('404.html')

@app.errorhandler(500)  # debug为False请情况下才能看到
def error_500(arg):
    print('500会执行我')
    return "服务器内部错误"

6.template_global 标签 ，在模板中用  {{sb(1,2)}}
@app.template_global()
def sb(a1, a2):
    return a1 + a2

7.template_filter过滤器  在模板中用  {{10|db(1,2)}}
@app.template_filter()
def db(a1, a2, a3):
    return a1 + a2 + a3

蓝图

# 就是为了划分目录结构的
使用步骤：
   1.在不同的view的py文件中定义蓝图
   2.使用app对象，注册蓝图
   3.使用蓝图注册路由，注册请求扩展
# 蓝图小型项目
flask_blueprint_little  # 项目名
	-src                # 项目代码所在路径
    	-__init__.py   # app对象创建的地方
    	-templates     # 模板
        	-user.html
		-static       # 静态文件
        -views        # 视图函数存放位置
        	-user.py  # 用户相关视图
        	-order.py # 订单相关视图
	-manage.py  # 启动文件


# 大型项目
flask_blurprint_big   # 项目名字
	-src   # 项目代码所在位置
    	-__init__.py # src的init，falsk，app实例化
        -settings.py # 配置文件
    	-admin       # 类似于django的admin app
        	-__init__.py # 蓝图初始化
        	-template   # 模板
            	-backend.html
            -static   # 静态文件
            	-xx.jpg
            -views.py  # 视图层
            -models.py # models层
        -api
        	-__init__.py
            -template
			-static
			-models.py
            -views.py
	-manage.py  # 启动文件

异步【拓展芝士】

# 异步框架 FastAPi
async def index():
    print('sdfasd')
    a++
    await xxx  # io操作
async def goods():   
    pass
# 框架之前的web框架，开启进程，线程---》一条线程会运行多个协程函数----》协程函数中遇到io，读到await关键字，就会切换到别的协程函数


# 一旦使用了异步，以后所有的模块，都要是异步
	-pymysql ：同步的
    -redis ：同步
    -aiomysql：异步
    -aioredis：异步
    -在fastapi或sanic中，要操作mysql，redis要使用异步的框架，否则效率更低
    -django 3.x 以后页支持async 关键字
    -没有一个特别好异步的orm框架
    	-sqlalchemy在做
        -tortoise-orm
        https://tortoise-orm.readthedocs.io/en/latest/index.html
    
    
# aiomysql
import asyncio
import aiomysql

loop = asyncio.get_event_loop()

async def test_example():
    conn = await aiomysql.connect(host='127.0.0.1', port=3306,
                                       user='root', password='', db='mysql',
                                       loop=loop)

    cur = await conn.cursor()
    await cur.execute("SELECT Host,User FROM user")
    print(cur.description)
    r = await cur.fetchall()
    print(r)
    await cur.close()
    conn.close()

loop.run_until_complete(test_example())


# aioredis
import aioredis
import asyncio
class Redis:
    _redis = None
    async def get_redis_pool(self, *args, **kwargs):
        if not self._redis:
            self._redis = await aioredis.create_redis_pool(*args, **kwargs)
        return self._redis

    async def close(self):
        if self._redis:
            self._redis.close()
            await self._redis.wait_closed()


async def get_value(key):
    redis = Redis()
    r = await redis.get_redis_pool(('127.0.0.1', 6379), db=7, encoding='utf-8')
    value = await r.get(key)
    print(f'{key!r}: {value!r}')
    await redis.close()         

if __name__ == '__main__':
    asyncio.run(get_value('key'))  # need python3.7