PythonWEB框架之Flask

2018/10 17 15:10

前言:

Django:1个重武器,包含了web开发中常用的功能、组件的框架;(ORM、Session、Form、Admin、分页、中间件、信号、缓存、ContenType....);

Tornado:2大特性就是异步非阻塞、原生支持WebSocket协议;

Flask:封装功能不及Django完善,性能不及Tornado,但是Flask的第三方开源组件比丰富;http://flask.pocoo.org/extensions/

Bottle:比较简单;

 

总结:

都不是我写的!!!不论优劣,不同的工具而已;

小型web应用设计的功能点不多使用Flask;

大型web应用设计的功能点比较多使用的组件也会比较多,使用Django(自带功能多不用去找插件);

如果追求性能可以考虑Tornado;

 

Flask的socket是基于Werkzeug 实现的,模板语言依赖jinja2模板,在使用Flask之前需要安装一下;

pip3 install flask           #安装flask

复制代码








from werkzeug.wrappers import Request, Response  # Flask的socket使用werkzeug实现,所以要导入 werkzeug

@Request.application

def hellow(request):
    return Response('Hello World')

if __name__ == '__main__':
    from werkzeug.serving import run_simple
    run_simple('localhost',400,hellow)
复制代码

 

Flask简单使用

复制代码









from flask import Flask

app=Flask(__name__) #创建1个Flask实例

@app.route('/')      #路由系统生成 视图对应url,1. decorator=app.route() 2. decorator(first_flask)
def first_flask():    #视图函数
    return 'Hello World'  #response


if __name__ == '__main__':
    app.run()              #启动socket
复制代码

 

 

一、配置文件

 

app=Flask(__name__,template_folder='templates',static_url_path='/static/',static_path='/zhanggen')

模板路径: template_folder='templates'

静态文件路径:static_url_path='/static/'

静态文件引入别名:static_path='/zhanggen'

设置为调试环境:app.debug=True (代码修改自动更新)

设置json编码格式 如果为False 就不使用ascii编码:app.config['JSON_AS_ASCII'] =False

设置响应头信息Content-Type   app.config['JSONIFY_MIMETYPE'] ="application/json;charset=utf-8"  (注意 ;charset=utf-8)

 

二、路由系统

 

1.动态路由(url传参)

@app.route('/user/<name>')

复制代码










from flask import Flask

app=Flask(__name__)

@app.route('/<name>')  #设置url传参数 http://127.0.0.1:5000/zhanggen
def first_flask(name):  #视图必须有对应接收参数
    print(name)
    return 'Hello World'  #response


if __name__ == '__main__':
    app.run()
复制代码

@app.route('/post/<int:age>')

复制代码







#接收整型数字参数
app=Flask(__name__)
@app.route('/<int:age>/')  #设置url传参数 http://127.0.0.1:5000/18/
def first_flask(age):  #视图必须有对应接收参数
    print(age)
    return 'Hello World'  #response

if __name__ == '__main__':
    app.run()
复制代码

@app.route('/post/<float:salary>')

复制代码







#接收浮点型型数字参数
app=Flask(__name__)
@app.route('/<float:salary>/')  #设置url传参数http://127.0.0.1:5000/2345555.8889/
def first_flask(salary):  #视图必须有对应接收参数
    print(salary)
    return 'Hello World'  #response

if __name__ == '__main__':
    app.run()
复制代码

@app.route('/post/<path:path>')

复制代码







# 接收URL链接类型参数
app=Flask(__name__)
@app.route('/<path:url>/')  #设置url传参数:http://127.0.0.1:5000/http://www.baiu.com/
def first_flask(url):  #视图必须有对应接收参数
    print(url)
    return 'Hello World'  #response

if __name__ == '__main__':
    app.run()
复制代码

 

2、指定允许的请求方法

@app.route('/login', methods=['GET', 'POST'] )

复制代码









# 指定允许的请求方法
app=Flask(__name__)
@app.route('/<path:url>/',methods=['get'] 





) #只允许get请求
def first_flask(url):
    print(url)
    return 'Hello World'  #response

if __name__ == '__main__':
    app.run()
复制代码

 

3、通过别名反向生成url

复制代码








#反向生成url
from flask import Flask,url_for
app=Flask(__name__)
@app.route('/<path:url>',endpoint='name1')
def first_flask(url):
    print(url_for('name1',url=url)) #如果设置了url参数,url_for(别名,加参数)
    return 'Hello World'

if __name__ == '__main__':
    app.run()
复制代码

 

4、通过app.add_url_rule()调用路由

复制代码














#方式2通过app.add_url_rule()方法的方式调用路由
app=Flask(__name__)

def first_flask():
    return 'Hello World' 

app.add_url_rule(rule='/index/',endpoint='name1',view_func=first_flask,methods=['GET'] 
)
#app.add_url_rule(rule=访问的url,endpoint=路由别名,view_func=视图名称,methods=[允许访问的方法] 

)
if __name__ == '__main__':
    app.run()
复制代码

 

5、扩展路由功能:正则匹配url

如果需要一些复杂的匹配规则可以自定义正则匹配url

复制代码









































































from flask import Flask, views, url_for
            from werkzeug.routing import BaseConverter

            app = Flask(import_name=__name__)


            class RegexConverter(BaseConverter):
                """
                自定义URL匹配正则表达式
                """
                def __init__(self, map, regex):
                    super(RegexConverter, self).__init__(map)
                    self.regex = regex

                def to_python(self, value):
                    """
                    路由匹配时,匹配成功后传递给视图函数中参数的值
                    :param value: 
                    :return: 
                    """
                    return int(value)

                def to_url(self, value):
                    """
                    使用url_for反向生成URL时,传递的参数经过该方法处理,返回的值用于生成URL中的参数
                    :param value: 
                    :return: 
                    """
                    val = super(RegexConverter, self).to_url(value)
                    return val

            # 添加到flask中
            app.url_map.converters['regex'] 









 = RegexConverter


            @app.route('/index/<regex("\d+"):nid>')
            def index(nid):
                print(url_for('index', nid='888'))
                return 'Index'


            if __name__ == '__main__':
                app.run()
复制代码

 

 

四、视图

 

1、给Flask视图函数加装饰器

注意如果要给视图函数加装饰器增加新功能,一点要加在路由装饰器下面,才会被路由装饰器装饰,才能生生成url关系;

复制代码






























#给Flask视图加装饰器
#1、定义1个装饰器

def auth(func):
    print('我在上面')
    def inner(*args,**kwargs):
        return func(*args,**kwargs)
    return inner


app=Flask(__name__)

@app.route('/',methods=['GET'] 






)
@auth #注意如果要给视图函数加装饰器,一点要加在路由装饰器下面,才会被路由装饰器装饰
def first_flask():
    print('ffff')
    return 'Hello World'

if __name__ == '__main__':
    app.run()
复制代码

 

2、request和response

 a.请求相关信息

request.method: 获取请求方法

request.json

request.json.get("json_key"):获取json数据 **较常用

request.argsget('name') :获取get请求参数

request.form.get('name') :获取POST请求参数

request.form.getlist('name_list'):获取POST请求参数列表(多个)

request.values.get('age') :获取GET和POST请求携带的所有参数(GET/POST通用)

request.cookies.get('name'):获取cookies信息

request.headers.get('Host'):获取请求头相关信息

request.path:获取用户访问的url地址,例如(/,/login/,/ index/);

request.full_path:获取用户访问的完整url地址+参数 例如(/login/?age=18)

request.script_root: 抱歉,暂未理解其含义;

request.url:获取访问url地址,例如http://127.0.0.1:5000/?age=18;

request.base_url:获取访问url地址,例如 http://127.0.0.1:5000/;

request.url_root

request.host_url

request.host:获取主机地址

 

request.files:获取用户上传的文件

obj = request.files['the_file_name']

obj.save('/var/www/uploads/' + secure_filename(f.filename))  直接保存

 

 b、响应相关信息

return "字符串" :响应字符串

return render_template('html模板路径',**{}):响应模板

return redirect('/index.html'):跳转页面

 

响应json数据

方式1: return jsonify(user_list)

app.config['JSON_AS_ASCII'] 
=False  #指定json编码格式 如果为False 就不使用ascii编码,
app.config['JSONIFY_MIMETYPE']  ="application/json;charset=utf-8" #指定浏览器渲染的文件类型,和解码格式;

方式2:

return Response(data,mimetype="application/json;charset=utf-8",)

 

 

如果需要设置响应头就需要借助make_response()方法

 

from flask import Flask,request,make_response

 

response = make_response(render_template('index.html'))

response是flask.wrappers.Response类型

response.delete_cookie('key')

response.set_cookie('key', 'value')

response.headers['X-Something'] = 'A value'

return respons

 

3 、Flask之CBV视图

复制代码



































#CBV视图
from flask import Flask,url_for,views
#-----------------------------------------------------
app=Flask(__name__)               #装饰器

def auth(func):
    print('我在上面')
    def inner(*args,**kwargs):
        return func(*args,**kwargs)
    return inner
#--------------------------------------------------------
class IndexView(views.MethodView):  #CBV视图
    methods=['GET'] 
                #允许的http请求方法(改CBV只允许GET方法)
    decorators = [auth,] 










            #每次请求过来都加auth装饰器

    def get(self):
        return 'Index.GET'
    def post(self):
        return 'Index.POST'

app.add_url_rule('/index/',view_func=IndexView.as_view(name='name1')) #(name='name1'反向生成url别名


if __name__ == '__main__':
    app.run()
复制代码

 

 

五、模板语言

Flask使用的是Jinja2模板,所以其语法和Django无差别(Django的模板语言参考Jinja2)

 

1.引用静态文件

方式1:别名引入

<link rel="stylesheet" href="/zhanggen/commons.css">

方式2:url_for()方法引入

<link rel="stylesheet" href="{{  url_for('static',filename='commons.css')  }}">

 

2.模板语言引用上下文对象

变量

<h1>{{user_list}}</h1> <!--变量 -->

 

循环、索引取值

复制代码






<ul>
{% for user in user_list %}   <!--循环 -->
    <li>{{user}}</li>
{% endfor %}

{{user_list.0}}             <!-- 索引取值-->

</ul>
复制代码

 

Flask的Jinjia2可以通过Context 把视图中的函数传递把模板语言中执行,这就是Django中的simple_tag和simple_fifter;

simple_tag(只能传2个参数,支持for、if)


@app.template_global()   #simple_tag
def foo(arg):
    return '<input type="text">'

<h1>{{foo(1)|safe}}</h1>                   <!--Flask的模板语言支持simple_tag-->

 

simple_fifter(对参数个数无限制,不支持for、if)


@app.template_filter()  #simple_fifter
def foo1(arg1,arg2,arg3):
    return arg1+arg2+arg3

<h1> {{ 'alex'|foo1('s ','b',) }}  </h1>     <!-- simple_fifter -->

 

3.wtform(flask表单验证插件)

3.0.简介

wtformWTForms是一个支持多个web框架的form组件,主要对用户请求数据 进行表单验证。

 

3.1. 安装

pip install wtforms  #安装wtfroms插件

 

3.2.简单使用

wtforms和Django自带的form验证插件功能相同,使用起来大同小异;

 

用户登录页面验证

 app01.py
 login.html

 

用户注册页面验证

 app02.py
 register.html

 

3.2.wtforms源码 猜想....

A.自动生成html标签

先来分析一下form验证类的结构

 

LoginForm类中包含了2个字段: name 和 pwd,而name / pwd字段 = 对象,所以LoginForm 类包含了2个对象;

如果实例化了obj=LoginForm() 就等于 在 这1个对象中嵌套了 2个对象;

 

 

前端使用Form验证插件:

那如果在前端for循环LoginForm对象,就等于调用LoginForm对象的__iter__方法,把每个字段(对象)封装的数据 返回

如果前端{{ obj }}= 直接调用了字段对象的__str__方法;

 

 

 调用关系

 

 

B.数据校验

后台定义好正则

用户发来数据

对数据进行校验

 

 

 

3.3.源码流程

生成HTML标签并显示

1.验证类(LogibForm)生成

1.1.由于 metaclass=FormMeta,所以LoginForm是由FormMeta创建的

 View Code

1.2.执行FormMeta 的__init__方法,在LoginForm中添加2个静态字段

 View Code

 

1.3.开始解释LoginForm中的 实例化字段对象name=simple.StringField()simple.PasswordField()

StringField/PasswordField开始实例化(提到实例化就应该想到:指定元类的__call__、自己/父类的__new__、__init__):

StringField/PasswordField是默认元类,自己没有__new__和__init__方法;

但父类Field类中有__new__方法,所以执行父类的__new__(Field.__new__)返回UnboundField对象

 Field.__new__()

 

由于Field.__new__方法返回了 1个 UnboundField对象,来看 UnboundField的__init__方法

 UnboundField.__init__

 

UnboundField的__init__方法在 UnboundField对象中封装了Field类的参数和计数器,所以现在LoginForml类中封装数据如下

复制代码













"""
print(LoginForm.__dict__)
LoginForm ={
    '__module__': '__main__', 
    'name': <1 UnboundField(StringField, (),{'creation_counter': 1, 'label': '用户名', 'validators': [<wtforms.validators.DataRequired object at 0x00000000037DAEB8>, <wtforms.validators.Length object at 0x000000000382B048>] 
, 'widget': <wtforms.widgets.core.TextInput object at 0x000000000382B080>, 'render_kw': {'class': 'form-control'}  })>, 
    'pwd': <2 UnboundField(PasswordField, (),{'creation_counter': 2,'label': '密码', 'validators': [<wtforms.validators.DataRequired object at 0x000000000382B0F0>, <wtforms.validators.Length object at 0x000000000382B128>, <wtforms.validators.Regexp object at 0x000000000382B160>] 




, 'widget': <wtforms.widgets.core.PasswordInput object at 0x000000000382B208>, 'render_kw': {'class': 'form-control'}})>, 
    '__doc__': None, 
    '_unbound_fields': None, 
    '_wtforms_meta': None,
}
"""
复制代码

 

 

 

启发:

不一定要把代码都写在当前类中,如过多个类和类之间有同性方法、属性可以抽出来集中到父类之中;子类继承父类所以子类实例化对象之后,继承享有2者的属性和方法;所以看源码遇到继承一点要注意 观察父类;

 

每个对象实例化(在排除MetaClass的情况下)都会执行 父类的__new__方法,再去执行__init__方法;而__new__实质性决定了实例化出来的对象是神马?

 狸猫换太子

 

2.LoginForm实例化

谈到类实例化应该先检查该类是否指定了 Meta类,如果指定了Meta类, 就需要先执行 (指定元类的__call__、自己/父类的__new__、__init__)

 

21.执行FormMeta的__call__方法,赋值LoginForm的_unbound_fields 和 _wtforms_meta属性;

 

根据unbound对象的creation_counter属性对 LoginForm中的字段进行排序,并填充到 LoginForm的_unbound_fields属性中

根据 LoginForm的__mro__继承顺序:获取当前类(FormLogin)所有父类,并在每个父类中 提取Meta属性添加到列表,转成元组,最后创建Meta类让其继承,赋值LoginForm._wtforms_meta属性

 FormMeta.__call__

 

执行完了指定元类 FormMeta.__call__()方法之后的LoginForm类中封装的数据

复制代码















print(LoginForm.__dict__)
LoginForm ={
    '__module__': '__main__', 
    'name': <1 UnboundField(StringField, (),{'creation_counter': 1, 'label': '用户名', 'validators': [<wtforms.validators.DataRequired object at 0x00000000037DAEB8>, <wtforms.validators.Length object at 0x000000000382B048>] 
, 'widget': <wtforms.widgets.core.TextInput object at 0x000000000382B080>, 'render_kw': {'class': 'form-control'}  })>, 
    'pwd': <2 UnboundField(PasswordField, (),{'creation_counter': 2,'label': '密码', 'validators': [<wtforms.validators.DataRequired object at 0x000000000382B0F0>, <wtforms.validators.Length object at 0x000000000382B128>, <wtforms.validators.Regexp object at 0x000000000382B160>] 


, 'widget': <wtforms.widgets.core.PasswordInput object at 0x000000000382B208>, 'render_kw': {'class': 'form-control'}})>, 
    '__doc__': None, 
    
    '_unbound_fields': 


[
                (name, UnboundField对象(1,simple.StringField,参数)),
                (pwd, UnboundField对象(2,simple.PasswordField,参数)),
            ] 


,, 
    '_wtforms_meta': Meta(DefaultMeta)类,
}
"""
复制代码

 

启发:

 列表的 sort()
 __mro__获取当前对象的继承顺序

 

 

 

 

2.2.执行LoginForm的__new__方法

没有__new__方法 pass

 

 

2.3.执行LoginForm的__init__方法实例化form对象

 Form.__init__

执行Form父类BaseForm.__init__方法,把UnboundField对象转换成StringField对象,并赋值到form对象的_fields:{}字典中;

 BaseForm. __init__



 form = {
        _fields: {
                name: StringField对象(),
                pwd: PasswordField对象(),
            }



循环form对象 中的_fields字段(字典),分别赋值到form对象,这样就可以通过form.name/form.pwd直接获取到Field对象了
,无需form._fields['name']  / form._fields['name'] 

代码:
for name, field in iteritems(self._fields):
    setattr(self, name, field)

                        form对象封装数据就变成以下内容喽
复制代码









 

form = {
        _fields: {
                name: StringField对象(),
                pwd: PasswordField对象(),
            }
        name:  StringField对象(widget=widgets.TextInput()),
        pwd:  PasswordField对象(widget=widgets.PasswordInput())
    
        }
复制代码

 

 

3. 当form对象生成之后 print(form.name) = 执行StringField对象的__str__方法;

StringField类中没有__str__方法,所以去执行基类Field的,Field.__str__方法返回了:  self()  =  StringFieldObj.__call__()

 Field.__str__方法

 

StringField没有__call__所以执行其基类Field.__call__方法,调用了self.meta.render_field(self, kwargs)

    def __call__(self, **kwargs):            # self=StringField对象
        return self.meta.render_field(self, kwargs) #把StringField对象传传入meta.render_field方法

 

下面来看self.meta.render_field(self, kwargs)做了什么?

复制代码










  def render_field(self, field, render_kw):

        other_kw = getattr(field, 'render_kw', None)
        if other_kw is not None:
            render_kw = dict(other_kw, **render_kw)
        # StringField对象.widget(field, **render_kw)
        #插件.__call__()
        '''
        #field =StringField对象
           StringField对象.widget对象()=调用widget对象的.__call__方法
        '''
        return field.widget(field, **render_kw)
复制代码

 

来看widget对象=TextInput()的__call__方法,最终打印了obj.name的结果

复制代码










def __call__(self, field, **kwargs):
        kwargs.setdefault('id', field.id)
        kwargs.setdefault('type', self.input_type)
        if 'value' not in kwargs:
            kwargs['value'] 
 = field._value()
        if 'required' not in kwargs and 'required' in getattr(field, 'flags', [] 
):
            kwargs['required'] 
 = True
        return HTMLString('<input %s>' % self.html_params(name=field.name, **kwargs))
复制代码
复制代码






   """
        0. Form.__iter__: 返回所有字段对象
            1. StringField对象.__str__
            2. StringField对象.__call__
            3. meta.render_field(StringField对象,)
            4. StringField对象.widget(field, **render_kw)
            5. 插件.__call__()
        """
复制代码

 

 

4.执行for iteam in form对象的执行流程

执行form对象基类BaseForm的__inter__方法,变量self._fields字典中的内容

复制代码

def __iter__(self):
        """Iterate form fields in creation order."""
        return iter(itervalues(self._fields))


_fields: {
                name: StringField对象(),
                pwd: PasswordField对象(),
            }
复制代码

 

 

用户输入数据的校验验证流程form = LoginForm(formdata=request.form)

复制代码



















# 请求发过来的值
        form = LoginForm(formdata=request.form) # 值.getlist('name')

        # 实例:编辑
        # # 从数据库对象
        # form = LoginForm(obj='值') # 值.name/值.pwd
        #
        # # 字典 {}
        # form = LoginForm(data=request.form) # 值['name'] 





        # 1. 循环所有的字段
        # 2. 获取每个字段的钩子函数
        # 3. 为每个字段执行他的验证流程 字段.validate(钩子函数+内置验证规则)
复制代码

 

 

 

 

 

 

六、session功能

 

1. Flask自带的session功能

复制代码




































from flask import session
import json
app=Flask(__name__,template_folder='templates',static_path='/static/',static_url_path='/static/')
app.debug=True
app.secret_key='sjehfjeefrjewth43u'  #设置session加密
app.config['JSON_AS_ASCII'] 
=False  #指定json编码格式 如果为False 就不使用ascii编码,
app.config['JSONIFY_MIMETYPE'] 

 ="application/json;charset=utf-8" #指定浏览器渲染的文件类型,和解码格式;

@app.route('/login/',methods=['GET','POST'] 






)
def login():
    msg = ''
    if request.method=='POST':
        name=request.values.get('user')
        pwd=request.values.get('pwd')
        if name =='zhanggen' and pwd=='123.com':
            session['user'] 





=name  #设置session的key value
            return redirect('/index/')
        else:
            msg='用户名或者密码错误'
    return render_template('login.html',msg=msg)

@app.route('/index/',methods=['GET','POST'] 

)
def index():
    user_list = ['张根', 'egon', 'eric'] 



    user=session.get('user')           #获取session
    if user:
        user=['alex','egon','eric'] 






        return jsonify(user_list)
    else:
        return redirect('/login/')

if __name__ == '__main__':
    app.run()
复制代码

 

2.第三方session组件(Session)

安装 pip install flask-session

复制代码














































from flask import session, Flask,request,make_response,render_template,redirect,jsonify,Response

from flask.ext.session import Session #引入第三方session
import json
app=Flask(__name__,template_folder='templates',static_path='/static/',static_url_path='/static/')
app.debug=True
app.secret_key='sjehfjeefrjewth43u'  #设置session加密
app.config['JSON_AS_ASCII'] 
=False  #指定json编码格式 如果为False 就不使用ascii编码,
app.config['JSONIFY_MIMETYPE'] 

 ="application/json;charset=utf-8" #指定浏览器渲染的文件类型,和解码格式;

app.config['SESSION_TYPE'] 


='redis'

from redis import Redis        #引入连接 redis模块
app.config['SESSION_REDIS'] 


=Redis(host='192.168.0.94',port=6379) #连接redis
Session(app)

@app.route('/login/',methods=['GET','POST'] 






)
def login():
    msg = ''
    if request.method=='POST':
        name=request.values.get('user')
        pwd=request.values.get('pwd')
        if name =='zhanggen' and pwd=='123.com':
            session['user'] 





=name  #设置session的key value
            return redirect('/index/')
        else:
            msg='用户名或者密码错误'
    return render_template('login.html',msg=msg)

@app.route('/index/',methods=['GET','POST'] 

)
def index():
    user_list = ['张根', 'egon', 'eric'] 



    user=session.get('user')           #获取session
    if user:
        user=['alex','egon','eric'] 






        return jsonify(user_list)
    else:
        return redirect('/login/')

if __name__ == '__main__':
    app.run()
复制代码

不仅可以把session存放到redis还可放到文件、内存、memcache...

复制代码































































def _get_interface(self, app):
        config = app.config.copy()
        config.setdefault('SESSION_TYPE', 'null')
        config.setdefault('SESSION_PERMANENT', True)
        config.setdefault('SESSION_USE_SIGNER', False)
        config.setdefault('SESSION_KEY_PREFIX', 'session:')
        config.setdefault('SESSION_REDIS', None)
        config.setdefault('SESSION_MEMCACHED', None)
        config.setdefault('SESSION_FILE_DIR',
                          os.path.join(os.getcwd(), 'flask_session'))
        config.setdefault('SESSION_FILE_THRESHOLD', 500)
        config.setdefault('SESSION_FILE_MODE', 384)
        config.setdefault('SESSION_MONGODB', None)
        config.setdefault('SESSION_MONGODB_DB', 'flask_session')
        config.setdefault('SESSION_MONGODB_COLLECT', 'sessions')
        config.setdefault('SESSION_SQLALCHEMY', None)
        config.setdefault('SESSION_SQLALCHEMY_TABLE', 'sessions')

        if config['SESSION_TYPE'] 

 == 'redis':
            session_interface = RedisSessionInterface(
                config['SESSION_REDIS'] , config['SESSION_KEY_PREFIX'] 
,
                config['SESSION_USE_SIGNER'] , config['SESSION_PERMANENT'] 
)
        elif config['SESSION_TYPE'] 

 == 'memcached':
            session_interface = MemcachedSessionInterface(
                config['SESSION_MEMCACHED'] , config['SESSION_KEY_PREFIX'] 
,
                config['SESSION_USE_SIGNER'] , config['SESSION_PERMANENT'] 
)
        elif config['SESSION_TYPE'] 

 == 'filesystem':
            session_interface = FileSystemSessionInterface(
                config['SESSION_FILE_DIR'] , config['SESSION_FILE_THRESHOLD'] 
,
                config['SESSION_FILE_MODE'] , config['SESSION_KEY_PREFIX'] 
,
                config['SESSION_USE_SIGNER'] , config['SESSION_PERMANENT'] 
)
        elif config['SESSION_TYPE'] 

 == 'mongodb':
            session_interface = MongoDBSessionInterface(
                config['SESSION_MONGODB'] , config['SESSION_MONGODB_DB'] 
,
                config['SESSION_MONGODB_COLLECT'] 
,
                config['SESSION_KEY_PREFIX'] , config['SESSION_USE_SIGNER'] 
,
                config['SESSION_PERMANENT'] 
)
        elif config['SESSION_TYPE'] 

 == 'sqlalchemy':
            session_interface = SqlAlchemySessionInterface(
                app, config['SESSION_SQLALCHEMY'] 
,
                config['SESSION_SQLALCHEMY_TABLE'] 
,
                config['SESSION_KEY_PREFIX'] , config['SESSION_USE_SIGNER'] 
,
                config['SESSION_PERMANENT'] 



)
        else:
            session_interface = NullSessionInterface()

        return session_interface
复制代码

 

3.自定义session组件

复制代码































































































#!/usr/bin/env python
# -*- coding:utf-8 -*-
import uuid
import json
from flask.sessions import SessionInterface
from flask.sessions import SessionMixin
from itsdangerous import Signer, BadSignature, want_bytes


class MySession(dict, SessionMixin):
    def __init__(self, initial=None, sid=None):
        self.sid = sid
        self.initial = initial
        super(MySession, self).__init__(initial or ())

    def __setitem__(self, key, value):
        super(MySession, self).__setitem__(key, value)

    def __getitem__(self, item):
        return super(MySession, self).__getitem__(item)

    def __delitem__(self, key):
        super(MySession, self).__delitem__(key)


class MySessionInterface(SessionInterface):
    session_class = MySession
    container = {}

    def __init__(self):
        import redis
        self.redis = redis.Redis()

    def _generate_sid(self):
        return str(uuid.uuid4())

    def _get_signer(self, app):
        if not app.secret_key:
            return None
        return Signer(app.secret_key, salt='flask-session',
                      key_derivation='hmac')

    def open_session(self, app, request):
        """
        程序刚启动时执行,需要返回一个session对象
        """
        sid = request.cookies.get(app.session_cookie_name)
        if not sid:
            sid = self._generate_sid()
            return self.session_class(sid=sid)

        signer = self._get_signer(app)
        try:
            sid_as_bytes = signer.unsign(sid)
            sid = sid_as_bytes.decode()
        except BadSignature:
            sid = self._generate_sid()
            return self.session_class(sid=sid)

        # session保存在redis中
        # val = self.redis.get(sid)
        # session保存在内存中
        val = self.container.get(sid)

        if val is not None:
            try:
                data = json.loads(val)
                return self.session_class(data, sid=sid)
            except:
                return self.session_class(sid=sid)
        return self.session_class(sid=sid)

    def save_session(self, app, session, response):
        """
        程序结束前执行,可以保存session中所有的值
        如:
            保存到resit
            写入到用户cookie
        """
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        httponly = self.get_cookie_httponly(app)
        secure = self.get_cookie_secure(app)
        expires = self.get_expiration_time(app, session)

        val = json.dumps(dict(session))

        # session保存在redis中
        # self.redis.setex(name=session.sid, value=val, time=app.permanent_session_lifetime)
        # session保存在内存中
        self.container.setdefault(session.sid, val)

        session_id = self._get_signer(app).sign(want_bytes(session.sid))

        response.set_cookie(app.session_cookie_name, session_id,
                            expires=expires, httponly=httponly,
                            domain=domain, path=path, secure=secure)
复制代码

复制代码






























from flask import Flask
from flask import session
from my_session import MySessionInterface

app = Flask(__name__)

app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
app.session_interface = MySessionInterface()


@app.route('/login/', methods=['GET', "POST"] 


)
def login():
    print(session)
    session['user1'] 
 = 'alex'
    session['user2'] 
 = 'alex'
    del session['user2'] 







    return "内容"


if __name__ == '__main__':
    app.run()
复制代码

 

 

 七、蓝图

 

使用Flask自带Blueprintmuk模块,帮助我们做代码目录结构的归类

 


import luffy   #导入luffy包就会执行luffy包中__init__.py文件

luffy.app.run()

复制代码














from flask import Flask

app=Flask(__name__,template_folder='templates',static_path='/static/',static_url_path='/static/')

app.debug=True


from .views import login
from .views import index

#把文件中蓝图对象注册到app里
app.register_blueprint(login.login,url_prefix='/login') #访问login蓝图必须以url_prefix开头
app.register_blueprint(index.index,url_prefix='/index')

if __name__ == '__main__':
    app.run()
复制代码








from flask import Blueprint     #导入蓝图
login=Blueprint('login',__name__) #在本模块实例化1个蓝图

@login.route('/login/',methods=['GET','POST'] 

)
def login1():
    return '登录页面'






from flask import Blueprint
index=Blueprint('index',__name__)
@index.route('/index/',methods=['GET','POST'] 

)
def index1():
    return '首页'

 

 

八、message (闪现)

 

message是一个基于Session实现的用于保存数据的集合,其特点是:一次性。

特点:和labada匿名函数一样不长期占用内存

复制代码
























from flask import Flask,request,flash,get_flashed_messages

app = Flask(__name__)
app.secret_key = 'some_secret'


@app.route('/set/')
def index2():
    flash('Disposable')    #在message中设置1个个值
    return 'ok'

#---------------------------------------------------------------------------------

@app.route('/')
def index1():
    messages = get_flashed_messages() #获取message中设置的值,只能获取1次。(1次性)
    print(messages)
    return "Index1"






if __name__ == "__main__":
    app.run()
复制代码

 

 

九、中间件

 

flask也有中间件功能和Django类似,不同的是使用的是使用3个装饰器来实现的;

1.@app.before_first_request :请求第1次到来执行1次,之后都不执行;

2.@app.before_request:请求到达视图之前执行;(改函数不能有返回值,否则直接在当前返回)

3.@app.after_request:请求 经过视图之后执行;(最下面的先执行)

复制代码


















































#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask, Request, render_template

app = Flask(__name__, template_folder='templates')
app.debug = True


@app.before_first_request  #第1个请求到来执行
def before_first_request1():
    print('before_first_request1')


@app.before_request #中间件2
def before_request1():
    Request.nnn = 123
    print('before_request1')  #不能有返回值,一旦有返回值在当前返回


@app.before_request
def before_request2():
    print('before_request2')



@app.errorhandler(404)
def page_not_found(error):
    return 'This page does not exist', 404



@app.route('/')
def hello_world():
    return "Hello World"





@app.after_request #中间件 执行视图之后
def after_request1(response):
    print('after_request1', response)
    return response


@app.after_request #中间件 执行视图之后 先执行 after_request2
def after_request2(response):
    print('after_request2', response)
    return response

if __name__ == '__main__':
    app.run()
复制代码

 

 

十、Flask插件

 

WTForms

SQLAchemy

等...    详细见:http://flask.pocoo.org/extensions/

--转载请注明: http://91o.cc/pythonweb%e6%a1%86%e6%9e%b6%e4%b9%8bflask/

作者 - 分类 未分类

发表回复

(必填)