Flask基础

配置

django中的配置是通过settings.py文件指定的，flask的配置是通过app.config加载的。app.config是一个继承于字典的对象，在字典之上还封装了一些其它的方法。
默认配置如下

default_config = ImmutableDict({
        'DEBUG':                                get_debug_flag(default=False),
        'TESTING':                              False,
        'PROPAGATE_EXCEPTIONS':                 None,
        'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
        'SECRET_KEY':                           None,
        'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
        'USE_X_SENDFILE':                       False,
        'LOGGER_NAME':                          None,
        'LOGGER_HANDLER_POLICY':               'always',
        'SERVER_NAME':                          None,
        'APPLICATION_ROOT':                     None,
        'SESSION_COOKIE_NAME':                  'session',
        'SESSION_COOKIE_DOMAIN':                None,
        'SESSION_COOKIE_PATH':                  None,
        'SESSION_COOKIE_HTTPONLY':              True,
        'SESSION_COOKIE_SECURE':                False,
        'SESSION_REFRESH_EACH_REQUEST':         True,
        'MAX_CONTENT_LENGTH':                   None,
        'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
        'TRAP_BAD_REQUEST_ERRORS':              False,
        'TRAP_HTTP_EXCEPTIONS':                 False,
        'EXPLAIN_TEMPLATE_LOADING':             False,
        'PREFERRED_URL_SCHEME':                 'http',
        'JSON_AS_ASCII':                        True,
        'JSON_SORT_KEYS':                       True,
        'JSONIFY_PRETTYPRINT_REGULAR':          True,
        'JSONIFY_MIMETYPE':                     'application/json',
        'TEMPLATES_AUTO_RELOAD':                None,
    })

想更改配置有如下几个方法：
方式一:
利用继承自字典的特性

app.config['DUBUG'] = True
或者
app.config.update(map)

方式二:
从文件中读，文件名不一定是以.py结尾

settings.cfg:
DEBUG=True

app.config.from_pyfile("settings.cfg")

方式三：
从对象中读

app.config.from_object('flask_test.settings.TestingConfig')
 
class Config(object):
    DEBUG = False
    TESTING = False
    DATABASE_URI = 'sqlite://:memory:'


class ProductionConfig(Config):
    DATABASE_URI = 'mysql://user@localhost/foo'


class DevelopmentConfig(Config):
    DEBUG = True


class TestingConfig(Config):
    TESTING = True

常用的就是方式二和方式三，当然还有其他不常用的方式：

app.config.from_json("json文件名称"):  JSON文件名称，必须是json格式，因为内部会执行json.loads
 
app.config.from_mapping({'DEBUG':True}):  字典格式

在这里需要注意一点：我们给flask应用设置的配置，有些是给flask使用的，有些是给我们程序使用的。那在我们的python程序中怎么去读取设置给程序使用的配置呢？app.config.get('xxx') 。如果在当前的视图函数所在作用域无法拿到app变量，那么可以使用current_app，这里可以先理解成一个app实例变量的代理，后续会分析其源码流程

在这里，着重强调一下from_object方法，因为这也是经常使用的。看源码


其实就是通过字符串的方式去导入，类似于django配置文件导入中间件只需要写路径的字符串形式就可以。
settings.py

class Test(object):
    pass

import importlib
setting = 'settings.Test'

module_str, class_str= setting.rsplit('.', maxsplit=1)
m = importlib.import_module(module_str)
print(getattr(m, class_str))

路由

查看所有路由

app.url_map

Map([<Rule '/index' (GET, HEAD, OPTIONS) -> index>,
 <Rule '/static/<filename>' (GET, HEAD, OPTIONS) -> static>])

Map对象，可以和django的urls.py一样，路由看作是一个列表，既然是列表就是有序的，也就是从前到后匹配，匹配成功就不会往下匹配。这也就是为什么给同一个路由绑定不同函数，最终执行的时候只有绑定的第一个函数才会被调用的原因。Map里放的是url对象，这个对象里封装了请求方法，路径等。

同一视图多个路由装饰

@app.route('/python')
@app.route('/index')
def index():
    return 'xx'

Map([<Rule '/python' (GET, HEAD, OPTIONS) -> index>,
 <Rule '/index' (GET, HEAD, OPTIONS) -> index>,
 <Rule '/static/<filename>' (GET, HEAD, OPTIONS) -> static>])

我们看到index最终对应两个路由了。要理解这个，看app.route干了什么事情？这里唯一需要注意的一点是app,route不是一个装饰器，app.route()执行得到的结果才是装饰器，知道这一点看源码就清楚了

    def route(self, rule, **options):
        def decorator(f):
            endpoint = options.pop('endpoint', None)
            self.add_url_rule(rule, endpoint, f, **options)
            return f
        return decorator

我们发现decorator做了两件事，一件就是做路由注册，另一件就是把视图函数原封不动地返回，所以最上面的装饰器装饰的也是原视图函数，只不过又再注册了一个路由而已。这里其实还用到了闭包，decorator可以访问route函数的参数。

限制请求方式

@app.route('/index', methods=['poSt', "gEt"])
def index():
    return 'xx'

methods 列表中的字符串大小写无所谓，最终都会转为大写

url_for进行反解析

url和视图函数进行绑定之后，我们通过url就能找到函数并执行，那么我们可以<font color='red'通过函数名找到对应的url吗?答案是肯定的，通过url_for函数就能实现

@app.route('/index', methods=['poSt', "gEt"], endpoint='xxx')
def index():
    return 'xx'

@app.route('/login')
def login():
    url = url_for('xxx')
    print(url)
    return url

当一个函数在路由注册的时候没有指定endpoint，默认的endpoint就是函数名。 url_for(endpoint, **values)根据*values可以创建动态url

app.route 参数

@app.route和app.add_url_rule参数：
            rule,                       URL规则
            view_func,                  视图函数名称
            defaults=None,              默认值,当URL中无参数，函数需要参数时，使用defaults={'k':'v'}为函数提供参数
            endpoint=None,              名称，用于反向生成URL，即： url_for('名称')
            methods=None,               允许的请求方式，如：["GET","POST"]
            

            strict_slashes=None,        对URL最后的 / 符号是否严格要求，
                                        如：
                                            @app.route('/index',strict_slashes=False)，
                                                访问 http://www.xx.com/index/ 或 http://www.xx.com/index均可
                                            @app.route('/index',strict_slashes=True)
                                                仅访问 http://www.xx.com/index 
            redirect_to=None,           重定向到指定地址
                                        如：
                                            @app.route('/index/<int:nid>', redirect_to='/home/<nid>')
                                            或
                                            def func(adapter, nid):
                                                return "/home/888"
                                            @app.route('/index/<int:nid>', redirect_to=func)

            subdomain=None,             子域名访问
                                                from flask import Flask, views, url_for

                                                app = Flask(import_name=__name__)
                                                app.config['SERVER_NAME'] = 'jack.com:5000'

                                                # http://admin.jack.com:5000/
                                                @app.route("/", subdomain="admin")
                                                def static_index():
                                                    """Flask supports static subdomains
                                                    This is available at static.your-domain.tld"""
                                                    return "admin.xxx.com"

　　　　　　　　　　　　　　#动态生成 # http://common.jack.com:5000/dynamic
                                                @app.route("/dynamic", subdomain="<username>")
                                                def username_index(username):
                                                    """Dynamic subdomains are also supported
                                                    Try going to user1.your-domain.tld/dynamic"""
                                                    return username + ".your-domain.tld"

                                                if __name__ == '__main__':

动态路由

默认支持6种路由转换器，不仅可以按照规则匹配路由，还可以对匹配到的内容进行转换之后再传给视图函数

@app.route('/user/<username>')   #常用的   不加参数的时候默认是字符串形式的
@app.route('/user/<str:username>')   #常用的   
@app.route('/post/<int:post_id>')  #常用的   #指定int，说明是整型的
@app.route('/post/<float:post_id>')
@app.route('/post/<uuid:uid>')
@app.route('/post/<any("jack", "lily"):name>')
@app.route('/post/<path:path>')

from werkzeug.routing import BaseConverter, DEFAULT_CONVERTERS

DEFAULT_CONVERTERS = {
    'default':          UnicodeConverter,
    'string':           UnicodeConverter,
    'any':              AnyConverter,
    'path':             PathConverter,
    'int':              IntegerConverter,
    'float':            FloatConverter,
    'uuid':             UUIDConverter,
}

自定义转换器类

from werkzeug.routing import BaseConverter
from werkzeug.urls import url_quote

app = Flask(__name__)
app.config.from_pyfile('settings.cfg')

class MyConverter(BaseConverter):
    def __init__(self, url_map, regex):
        super(MyConverter, self).__init__(url_map)
        # regex 这个属性不是我们自定义的，是BaseConverter里的，我们只是重新赋值
        self.regex = regex

    def to_python(self, value):
        # 匹配成功之后，例如匹配手机号13739191111成功，在把这个值作为变量传给视图函数之前会调用这个方法，并且把这个方法
        # 的返回值才最终传给视图函数
        print(value)
        return value

    def to_url(self, value):
        # 进行url_for的时候进行调用, 会把值先传入to_url，我们可以对value做一些自定义，自定义之后的值再放到路由里
        print(value)
        return url_quote(value, charset=self.map.charset)

# 注册到app.url_map.converters中
app.url_map.converters['re'] = MyConverter

@app.route('/index/<re(\d+):phone>',  endpoint='xxx')
def index(phone):
    return 'xx'

@app.route('/login')
def login():
    url = url_for('xxx', phone='1213123122')
    return url

请求参数

request.body 里放的是请求体数据，如果请求体是urlencoded编码的格式，那么flask就会帮我们把数据解析到request.form里面，并且会清空request.data里的数据。
如果前端name字段传了两次值，那么get方式只能拿第一个值，要想拿所有值，用getlist方法，得到的就是一个列表

上传文件

from flask import request

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
    if request.method == 'POST':
        # xx 是form表单的name值，而不是文件名
        f = request.files['xx']
        # save方法是flask帮我们封装的，这样我们就不需要自己打开文件读取内容再自己写进去了
         f.save('/var/www/uploads/' + secure_filename(f.filename))

abort函数与自定义异常处理

我们在视图函数想要提前终止函数的执行，可以使用return。但是函数如果执行逻辑会有出错的地方，我们通过raise抛出的错误会显示在页面上。abort的作用就是提前终止函数，并抛出错误，而这种错误和之间raise错误是有区别的。
abort一般有两种用法，要么传字符串参数，要么传http状态码(flask根据不同状态码都定制了相应的页面，我们可以重写这些页面)

from from flask import abort

@app.route('/index',  endpoint='xxx', methods=['POST', 'GET'])
def index():
    abort(404)
    return 'xx'

@app.errorhandler(404)
def error(e):
    return '您请求的页面不存在了，请确认后再次访问！%s'%e

返回响应数据

返回响应数据有两种形式，一种是返回元组，一种是返回Response对象
元组：(response, status, headers) 或者 (response, status) 其中status可以是’404'这样额数字字符串，也可以是带有code说明信息的字符串'666 not find',其中not find就是666的这个自定义状态码的说明信息
Response对象

from flask import  make_response

resp = make_response()
resp.headers[“sample”] = “value”
resp.status = “404 not found”

使用jsonify返回json数据

如果想返回json数据，自己写代码是这样的

@app.route('/index',  endpoint='xxx', methods=['POST', 'GET'])
def index():
    re_str = json.dumps({'name':"jack"})
    return re_str, 200, {"Content-type":'json'}

jsonify 实现的就是re_str, 200, {"Content-type":'json'}的功能，jsonify可以穿一个字典，也可以传键值对的形式

请求响应相关

from flask import Flask
    from flask import request
    from flask import render_template
    from flask import redirect
    from flask import make_response

    app = Flask(__name__)


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

        # 请求相关信息
        # request.method
        # request.args
        # request.form
        # request.values
        # request.cookies
        # request.headers
        # request.path
        # request.full_path
        # request.script_root
        # request.url
        # request.base_url
        # 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))

        # 响应相关信息
        # return "字符串"
        # return render_template('html模板路径',**{})
        # return redirect('/index.html')

        # 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 response


        return "内容"

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

session

基本使用当中字典来使用即可，后续源码分析会解析session流程

from flask import Flask, jsonify, session


app = Flask(__name__)
app.config.from_pyfile('settings.cfg')
app.secret_key = 'asdasd'
app.config['SESSION_COOKIE_NAME'] = 'xxx'
@app.route('/index',  endpoint='xxx', methods=['POST', 'GET'])
def index():
    print(session.get("a"))
    return jsonify({'a':1})

@app.route('/login')
def login():
    session['a'] = 1
    return 'login'

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

flash

flask的flash(闪现)是基于session来做的，我们知道session使用的时候可以看做是一个字典，字典里的值可以取多次，但是flash与其不同，flash存储的值取完就没有了。其实没有flash，我们完全可以自己实现，取完就没有无外乎就是一个pop操作。flask的闪现使用是用两个方法：flash和get_flashed_messages

from flask import Flask,flash, get_flashed_messages

app = Flask(__name__)
app.secret_key = 'adasd'
@app.route("/")
def index():
    # flash({'a':1})
    # get_flashed_messages()  取到是一个列表 [{'a': 1}]
    # 借助catogary对数据进行分类
    flash('xiyouji','book')
    flash('monkey', 'animal')
    return 'index'


@app.route('/index')
def i():
    # 需要指明category_filter参数，否则get_flashed_messages('animal')取到的是所有的值
    print(get_flashed_messages(category_filter='animal'))
    return 'i'

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

flash函数源码

def flash(message, category='message'):
    flashes = session.get('_flashes', [])
    flashes.append((category, message))
    session['_flashes'] = flashes
    message_flashed.send(current_app._get_current_object(),
                         message=message, category=category)

说白了，就是在session的那个大字典加一个key:value, 其中key是_flashes.

全局中间件

请求进来执行self(), 其中self是一个对象，self.call, 也就是app.call

现在问题来了，我想要在执行self.wsgi_app(environ, start_response)之前和之后做点事情，比如说打印什么东西，应该怎么做？纳尼，改源码？好想法，但是你写的程序别人要使用难不成让别人机器上的flask源码都要修改一下吗？这肯定不行，要么是装饰器，要么是继承。装饰器也是需要改源码，那么只能用继承了。

class MyFlask(Flask):
    def __call__(self, environ, start_response):
        print('进来了')
        ret =  super(MyFlask, self).__call__(environ, start_response)
        print('出去了')
        return ret

这样我们的app只需要用MyFlask来实例化就行。但是如果我就想使用Flask来实例化，那么应该怎么做呢？因为self.wsgi_app是一个函数，加括号运行，那么这里我们能不能把self.wsgi_app封装成一个类的对象呢，然后调用对象的__call__ 方法。

class MyWsgiApp(object):
    def __init__(self, wsgi_app):
        self.wsgi_app = wsgi_app

    def __call__(self, *args, **kwargs):
        print('come in')
        ret = self.wsgi_app(*args, **kwargs)
        print('out')
        return ret

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

flask中的装饰器

想要每次请求判断是否登录，登录之后才能访问某些网页，没有登录就跳转到登录页面

from flask import Flask,session, redirect

app = Flask(__name__)
app.secret_key = 'adasd'
app.debug = True
def auth(func):
    def inner(*args, **kwargs):
        sid = session.get('sid')
        if sid:
            ret = func(*args, **kwargs)
            return ret
        else:
            return redirect('/login')

    return inner

@app.route("/")
@auth
def index():
    return 'index'


@app.route('/login')
@auth
def login():
    return 'login'

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

发现报错了

问题就出在不同的路径对应相同的endpoint，那么通过url_for反推路径的时候应该取不同路径中的哪一个呢？所以就报错了，现在从源码角度看看

因为使用装饰器的时候，所有的被装饰函数的__name__都是inner，但是得到的对象都是不一样的(内部的inner函数可以看做一个对象，每次执行一次auth就会生成一个新的inner对象)。
装饰器修改如下：

from functools import wraps
def auth(func):
    @wraps(func)
    def inner(*args, **kwargs):
        sid = session.get('sid')
        if sid:
            ret = func(*args, **kwargs)
            return ret
        else:
            return redirect('/login')
    return inner

flask的CBV

from flask.views import MethodView

class MyView(MethodView):
    # 对所有请求的装饰器
    decorators = []
    methods = []

    def get(self, *args, **kwargs):
        pass
    def post(self, *args, **kwargs):
        pass
# xxx 就是
app.add_url_rule('/', view_func=MyView.as_view(name='xxx'))