本篇博文跟上一篇[Python][flask][flask-wtf]关于flask-wtf中API使用实例教程有莫大的关系。

简介：Flask-Login 为 Flask 提供了用户会话管理。它处理了日常的登入，登出并且长时间记住用户的会话。

        直白的讲，flask-login包为用户管理了涉及到用户登录相关的缓存（Session）管理。

Posted by Alima | cnblogs.

一.安装(Install)

PC环境：Windows 7，Python 3.5.2。

PS：此次配置环境阶段和上一篇博文中写的一致，如果看了上一篇博文，安装阶段可以直接跳过。

• 创建wtfdemo虚拟运行环境

用控制台（管理员运行模式）进入（cd）到想要创建工程的路径下，创建wtfdemo文件夹。

mkdir wtfdemo

进入（cd）wtfdemo文件夹，创建Python虚拟运行环境。

virtualenv flaskr

出现如下字样，说明虚拟环境创建成功

PS:本次提供第二种创建Python虚拟运行环境的使用方法

virtualenv -p source_file\python.exe target_file

为什么提出第二种创建方法，你会发现，当你的Python Web程序开发多了以后，PC上难免安装了很多版本的Python运行环境。

举例：当PC上同时安装了Python2.7和Python3.5，运行virtualenv flaskr后，建立的Python虚拟运行环境是Python2.7版本的，但是我们的开发环境是Python3.5。

在控制台中输入一下指令，你就会发现问题。

virtualenv -h

出现下面图片显示，默认的virtualenv安装路径是Python2.7，也就是默认的安装的虚拟环境是Python2.7版本。

所以，在这种情况下，请指定你需要的Python版本，并建立虚拟运行环境。

• 安装flask-wtf库文件

进入Python虚拟运行环境（在上一篇博文中写过），执行以下指令。

pip install flask
pip install flask-wtf
pip install flask-login
pip install flask-sqlalchemy

出现如下图所示，说明安装成功。

flask安装成功。

flask-wtf安装成功。

flask-login安装成功。（本次使用flask-wtf库时需要辅助以该运行库）

flask-sqlalchemy安装成功。

至此，环境配置阶段结束。

二.flask-Login介绍

它会：

①将活跃用户的ID储存在缓存(Session)中，让登录和注销更加简单。
②让你对登入（或登出）的用户限制浏览不同的视图
③处理略棘手的“记住用户”功能
④帮助保护使用用户的缓存(Session)，以免被恶意盗用
⑤可能与Flask-Principal或其他授权扩展，在以后的工作中进行整合

但是，它不会：

①强制让你使用一个特定的数据库或者其他的存储方法。你可以完全负责你的用户时如何加载的。
②限制你使用用户名和密码，OpenID或是其他的认证方法。
③处理“登入或登出”以外的权限
④处理用户注册或者账户恢复

总结，flask-Login包只管理用户登入登出的缓存(Session)管理，而不做过多的超出自己权限的功能。

三.flask-login下的API介绍

由于flask-login中的API比较少，在本文中，尽可能将所有的API功能介绍列在这里。

• LoginManager

class flask_login.LoginManager(app=None, add_context_processor=True)

这个类是用来保存用户的登录状态的，也是flask-login包的主类。

官方：LoginManager的实例是“不”绑定到特定的应用程序的，所以你可以创建LoginManager对象在你的代码主体上，所以你可以创建应用程序在工厂函数中。

解析：我们首先看LoginManager类的构造函数

__init__(self, app=None, add_context_processor=True)

该构造函数提供了一个缺省的局部变量app，默认值为None.和上文说道的，为“不绑定到特定的应用程序”解释说明。也就是说，你可以直接定义LoginManager的实例，而不必去绑定到应用程序上才可以实例化。当你在代码主题中定义了app后，可以随时绑定到LoginManager上。

该构造函数初始化了一些列变量。

'''
LoginManager构造函数
Blog:   www.cnblogs.com/alima/
Editor: Alima | cnblog
'''

#： 提供了一个游客用户，该用户是在没有登录状态下时使用
self.anonymous_user = AnonymousUserMixin

#： 提供当用户需要登录时的重定向页面参数
#： （此处也可以是一个绝对路径）
self.login_view = None

#： 提供一个蓝图，当用户需要登录时的重定向页面
#： 如果键值为空，则默认重定向到login_view下的地址
self.blueprint_login_views = {}

#： 这条消息将flash在重定向页面上
self.login_message = LOGIN_MESSAGE

#: login_message的类型，默认LOGIN_MESSAGE_CATEGORY，可自定义
self.login_message_category = LOGIN_MESSAGE_CATEGORY

#： 如果需要一个活跃的登录，使用户重定向到其他界面，重新验证登录
self.refresh_view = None

#： 这条消息将flash到用户重新验证的界面上
self.needs_refresh_message = REFRESH_MESSAGE

#: needs_refresh_message的类型，默认REFRESH_MESSAGE_CATEGORY，可自定义
self.needs_refresh_message_category = REFRESH_MESSAGE_CATEGORY

#： 缓存(Session)的保护等级
#： 有三种等级，分别为： 'basic'(默认),'strong','None'(关闭缓存保护功能)
self.session_protection = 'basic'

#： 如果存在，则用来转换使用login_message和needs_refresh_message
self.localize_callback = None

#： 检索用户对象回调
self.user_callback = None

#： 未经授权的用户回调（未登录状态）
self.unauthorized_callback = None

#： 未经授权的用户回调（需要活跃登录状态）
self.needs_refresh_callback = None

#： 默认属性以检索用户的Unicode标识(源码注释在flask_login.config文件下)
self.id_attribute = ID_ATTRIBUTE

#： 用于回调检索用户对象。（设置令牌状态）
self.header_callback = None

#： 用于回调检索用户对象。（设置Flask请求对象状态）
self.request_callback = None

#： 如果应用程序(app)为空，则默认创建一个空的LoginManager实例
if app is not None:
    self.init_app(app, add_context_processor)

API：init_app()

init_app(self, app, add_context_processor=True)

配置的应用程序。这将注册一个'after_request`调用，并附加这个`LoginManager`把它作为'app.login_manager`。

这里渗透一下，三个flask架构自带的装饰器。

before_request :在请求收到之前绑定一个函数做一些事情。

after_request: 每一个请求之后绑定一个函数，如果请求没有异常。

teardown_request: 每一个请求之后绑定一个函数，即使遇到了异常。

• 重新定制你的用户类

在之前的章节中，分别定义了不同的用户类，flask-login包控制登入登出需要如下属性。

① is_authenticated

当用户通过验证时，返回有效凭证True。

② is_active

一个活动用具有1)通过验证 2)账户也已激活 3)未被停用 4)也不符合任何的应用拒绝登入条件，返回True。不活动的账号无法登入。

③ is_anonyous

如果是一个匿名用户，返回True，如果是登录用户则返回False

④ get_id()

返回一个能唯一识别用户的，并能用于从user_loader回调中加载用户的ID，这个ID必须是Unicode。

如果你对你的新定制的用户类没有其他的要求，你可以继承flask_login.mixins下定义的UserMixin作为你的用户类的父类。

• flask-login下的API详解

①　配置登录

API：@user_loader

解析：这个API设置一个回调，用于从缓存中加载用户登录信息。你构造的函数需要设置一个user ID并且返回一个用户实体。如果用户不存在则返回None。

使用举例（简单实现了一个加载用户的操作，并没有对入口变量做判断）：

'''
Editor: Alima | cnblog
'''

@login_manager.user_loader
def load_user(id):
    user = User.query.filter_by(id=id).first()
    return user

API：@request_loader（@header_loader）

解析：设置一个从flask请求加载用户的回调。你需要给函数一个Flask请求，函数返回用户实体，用户不存在则返回None。

使用实例：（来自官方文档的一段代码，很有启迪，这段代码欢迎探讨，博主理解不是很好。

'''
Blog: www.cnblogs.com/alima/
From: Offical Doc
'''

@login_manager.request_loader
def load_user_from_request(request):

    # first, try to login using the api_key url arg
    api_key = request.args.get('api_key')
    if api_key:
        user = User.query.filter_by(api_key=api_key).first()
        if user:
            return user

    # next, try to login using Basic Auth
    api_key = request.headers.get('Authorization')
    if api_key:
        api_key = api_key.replace('Basic ', '', 1)
        try:
            api_key = base64.b64decode(api_key)
        except TypeError:
            pass
        user = User.query.filter_by(api_key=api_key).first()
        if user:
            return user

    # finally, return None if both methods did not login the user
    return None

API：anonymous_user

解析：提供了一个游客用户，该用户是在没有登录状态下时使用

使用实例：（你可以判断当前用户的is_anonymous属性，是不是True来看是不是随机用户）

if current_user.is_anonymous == True

②　未经授权的配置

API: flask_login.login_view

解析：当用户需要登录时，将用户重定向到的界面。

使用举例（将非法登录强制重定向到登录界面）：

login_manager.login_view = 'login'

API: flask_login.login_message

解析：当用户重定向时，flash出的消息。

使用举例：

login_manager.login_message = 'Please enter your account'

API：@unauthorized_handler

解析：如果你不想用默认的重定向定制你的登录，你可以在代码视图实体中显示的写出一个函数体，将@unauthorized_handler装饰器添加到函数体之上。这样做之后，当你用@login_required阻止用户非法登录，将执行我们新定义的函数体中的内容。

使用举例（将非法登录强制重定向到登录界面）：

'''
Editor: Alima | cnblog
'''

@login_manager.unauthorized_handler
def unauthorized_handler():
    return redirect('/login')

③需要活跃登录的配置

API: flask_login.refresh_view

解析：当用户需要活跃登录时，将用户重定向到的界面。

使用举例（将非法登录强制重定向到登录界面）：

login_manager.refresh_view = 'login'

 API: flask_login.needs_refresh_message

解析：当需要活跃登录的用户重定向时，flash出的消息。

使用举例：

login_manager.needs_refresh_message = 'You need a fresh log in.Please enter your account' 

API：@needs_refresh_handler

解析：作用和unauthorized_handler类似，当你需要登录的用户是输入用户名密码登录时，而你又不想使用默认的重定向方法，那么，你可以显示的定义你自己处理函数。

使用举例（将非活跃登录强制重定向到登录界面，并flash出消息）：

'''
Editor: Alima | cnblog
'''

@login_manager.needs_refresh_handler
def refresh():
    flash('You should log in!')
    return logout()

 ④登录机制

API：flask_login.current_user

解析：获取当前缓存中保存的用户帐户信息（一个当前用户的代理）

API：flask_login.login_fresh()

如果当前用户是活跃登录，则返回True。

API：flask_login.login_user(user, remember=False, force=False,fresh=True)

解析Ⅰ：登录用户。你需要向函数中传进一个用户对象。如果用户'is_active'属性为'Flase'，只有当'force'是'True'时才会允许登录。当登录成功后返回'True'，当失败时返回'False'。

           这里特别提一下函数参数'fresh'，当设置为'False'时，将登陆用户的缓存(Session)中标志为不是活跃登录。默认值为'True'

举例：

@app.route('/post')
@login_required
def post():
    pass

解析Ⅱ：如果只有当前时刻你需要要求你的用户登录，你可以这样做：

if not current_user.is_authenticated:
    return current_app.login_manager.unauthorized()

          实际上，将上边的代码添加到你的视图中去就可以达到要求了。

          当单体测试的时候它可以很方便的全局关闭认证。将'LOGIN_DISABLED'设置为True，装饰器就会被忽略了。

API：flask_login.logout_user()

解析：用户登出（你不需要通过实际用户）。这个函数同时会清除remember me中的cookie（如果存在的话）。

        作用就是清除一系列的cookie信息。

API：flask_login.confirm_login()

解析：函数将会将当前Sesslion设置为活跃。当从cookie加载之后，Sesson会变成不活跃状态。

⑤保护视图

API：flask_login.login_required

解析：如果你将这个装饰器放在视图上，它会保证你的当前用户是登录状态，并且在调用实际视图之前进行认证。

        如果当前用户不是系统认证的登录状态，它将调用LoginManager.unauthorized回调。

API：flask_login.fresh_login_required

解析：如果用这个装饰器放在视图上，它将确保当前用户是活跃登录的。用户的Session不是从'remember me'的cookie中加载的。

        敏感的操作，例如修改密码或者邮箱，应该用这个装饰器保护，来阻止cookie被盗取。

        如果用户没有认证，通常调用'LoginManager.unauthorized'。

        如果用户被认证了，但是缓存不是活跃登陆，它将会'LoginManager.needs_refresh'代替，而且你需要提供一个'LoginManager.refresh_view'。

几乎所有的flask-login下的API都在本文介绍了一下，其中@request_loader装饰器，博主理解不是很好，一旦有进展，会更新在文章中。如果你知道@request_loader装饰器的用法，欢迎私信评论给博主。

以上就是API的介绍，我们下面来看实例。

四.应用实例

本次在前一篇博文的基础上,我们来展开本篇博文。

首先，我们要介绍model.py类，以便匹配本次的flask-login。

'''
File name: model.py
Editor: Alima | cnblogs
Blog:   www.cnblogs.com/alima/
'''

from wtf import db
from flask_login import UserMixin

class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True)
    password = db.Column(db.String(80), unique=True)
    
    def __init__(self, username, password):
        self.username = username
        self.password = password
        
    def __repr__(self):
        return '<User %r>' % self.username

根据我们讲到的，使用flask-login验证用户登录时需要如下属性。

① is_authenticated

② is_active

③ is_anonyous

④ get_id()

User继承了UserMixin类的属性，方法。下面附加上flask-login包中的UseMixin类的源码。

'''
From Github: maxcountryman/flask-login
'''

class UserMixin(object):
    '''
    This provides default implementations for the methods that Flask-Login
    expects user objects to have.
    '''

    if not PY2:  # pragma: no cover
        # Python 3 implicitly set __hash__ to None if we override __eq__
        # We set it back to its default implementation
        __hash__ = object.__hash__

    @property
    def is_active(self):
        return True

    @property
    def is_authenticated(self):
        return True

    @property
    def is_anonymous(self):
        return False

    def get_id(self):
        try:
            return text_type(self.id)
        except AttributeError:
            raise NotImplementedError('No `id` attribute - override `get_id`')

    def __eq__(self, other):
        '''
        Checks the equality of two `UserMixin` objects using `get_id`.
        '''
        if isinstance(other, UserMixin):
            return self.get_id() == other.get_id()
        return NotImplemented

    def __ne__(self, other):
        '''
        Checks the inequality of two `UserMixin` objects using `get_id`.
        '''
        equal = self.__eq__(other)
        if equal is NotImplemented:
            return NotImplemented
        return not equal

附加属性一目了然，如果你想重新定制你的用户类，那么请重新类中的方法重写这个方法，如果仍想调用父类UserMixin中的方法，请使用super()语句。

这下，就解释了之前没有提到的UserMixin的作用。

下面来解释上次有很多有疑点的view.py，并在其中加入本文介绍的一些API的使用。

 1 '''
 2 File Name: view.py
 3 Editor: Alima | cnblogs
 4 Blog: www.cnblogs.com/alima/
 5 '''
 6 
 7 from flask import render_template, flash, redirect, session, url_for, request, g
 8 from flask_login import login_user, logout_user, current_user, login_required, AnonymousUserMixin, fresh_login_required, login_fresh
 9 from wtf import app, db, lm, User
10 from form import LoginForm, UploadForm
11 
12 @app.before_request
13 def before_request():
14     g.user = current_user
15  
16 @lm.user_loader
17 def load_user(id):
18     user = User.query.filter_by(id=id).first()
19     return user
20 
21 @app.route('/login', methods=['GET', 'POST'])
22 def login():
23     if g.user is not None and g.user.is_authenticated:
24         #login_fresh()
25         session['_fresh'] = False
26         return redirect(url_for('index'))
27     if g.user.is_active == True:
28         flash('active is True')
29     else:
30         flash('active is False')
31     form = LoginForm()
32     if form.validate_on_submit():
33         user = User.query.filter_by(username=form.username.data, password=form.password.data).first()
34         if(user is not None):
35             login_user(user,remember=form.remember_me.data)
36             return redirect(request.args.get("next") or url_for('index'))
37     return render_template('login.html', form=form)
38     
39 @app.route('/', methods = ['GET', 'POST'])
40 @app.route('/index', methods=['GET', 'POST'])
41 @login_required
42 def index():
43     form = UploadForm()
44 
45     if form.validate_on_submit():
46         filename = secure_filename(form.file.data.filename)
47         form.file.data.save('uploads/' + filename)
48         return redirect(url_for('upload'))
49 
50     return render_template('upload.html', form=form)
51     
52 @app.route('/logout')
53 @login_required
54 def logout():
55     logout_user()
56     return redirect(url_for('login'))

解释：

①第14行，current_user是在当前缓存中取出的用户实体，如果存在用户登录的缓存则返回实体，如果Session不存在则返回None。

②第16行，@lm.user_loader，这个装饰器表示，每次有请求时，都会调用它所装饰的函数。

Q: user_loader的运行机制是什么呢?

A: 答案在stackoverflow上有一个最好的解释，附上连接：flask-login: can't understand how it works

    解释一下答案中的最后几个点，

    1）你需要由你自己写出这段代码。,检查用户名和密码是否匹配（非请求到数据库的情况下）。

    也就是说，用户的cookie中可以存在非法的登录信息，你需要自己写出代码校验是否符合你所用数据库的格式。

    2）如果认证成功，取得用户ID，然后将用户实体它传递给login_user()。

③第35行，login_user()博主准备放在左后写，这是flask-Login的精髓，也是很多人不了解的。

④第41行，@login_required装饰器将验证所装饰的函数是否是在用户登录状态下访问的。

   我们在配置文件(wtf.py)中配置如下信息，指定了当用户非法登录时重定向的界面和flash出的消息。

lm.login_view = 'login'
lm.login_message = 'Please log in!'
lm.login_message_category = 'info'

 ⑤第25行，session['_fresh'] = False没看懂，请Ctrl+F在本文中搜索，下面有解释。

让我们之间访问http://127.0.0.1:5000/index会发生什么。

看到红色框之内的信息了么，就是定义的login_message中的信息。同时页面跳转到了http://127.0.0.1:5000/login，也就是定义的login_view。

 同时，上文还讲到使用unauthorized_handler装饰器，可以定制你自己的非法登陆处理过程。这里我们做一个简单的使用过程，非法登录时，页面将显示You have not logged in，你可以自己体验其中的妙处。

@lm.unauthorized_handler
def unauthorized_handler():
    return 'You have not logged in!'

 下面，让我们新加入一个需要活跃登录的界面。

Q：什么是活跃登录(fresh login)?

A：活跃登录是指当用户通过键入账户，并点击登录按钮后的登录状态。

     而当用户通过缓存(Session)登录时，被认为是非活跃登录状态。

Q：为什么区分活跃登录和非活跃登录？

A:当用户需要修改用户信息，密码或是其他隐私信息的时候，防止你的PC被别人登录并恶意修改，或是其它人盗用你的缓存达到你不期望的一些恶意操作。

在view.py中添加如下代码段。

@app.route('/info', methods = ['GET', 'POST'])
@fresh_login_required
def info():
    return 'Edit your infomation'

在wtf.py中配置如下信息。

lm.refresh_view = 'login'
lm.needs_refresh_message = 'Please enter your info'
lm.needs_refresh_message_category = "refresh_info" 

如果想将页面重定向到login界面，需要做点小的改善，就是修改flask-login源码

文件在flaskr\Lib\site-packages\flask_login.py。

修改源码中的needs_refresh()函数。

 1 def needs_refresh(self):
 2     '''
 3     This is called when the user is logged in, but they need to be
 4     reauthenticated because their session is stale. If you register a
 5     callback with `needs_refresh_handler`, then it will be called.
 6     Otherwise, it will take the following actions:
 7 
 8     - Flash :attr:`LoginManager.needs_refresh_message` to the user.
 9 
10     - Redirect the user to :attr:`LoginManager.refresh_view`. (The page
11       they were attempting to access will be passed in the ``next``
12       query string variable, so you can redirect there if present
13       instead of the homepage.)
14 
15     If :attr:`LoginManager.refresh_view` is not defined, then it will
16     simply raise a HTTP 401 (Unauthorized) error instead.
17 
18     This should be returned from a view or before/after_request function,
19     otherwise the redirect will have no effect.
20     '''
21     user_needs_refresh.send(current_app._get_current_object())
22 
23     if self.needs_refresh_callback:
24        return self.needs_refresh_callback()
25 
26     if not self.refresh_view:
27         abort(401)
28 
29     if self.localize_callback is not None:
30        flash(self.localize_callback(self.needs_refresh_message),
31            category=self.needs_refresh_message_category)
32     else:
33            flash(self.needs_refresh_message,
34                   category=self.needs_refresh_message_category)
35     
36     logout_user() #Edit by Alima | cnblogs
37     return redirect(login_url(self.refresh_view, request.url))

View Code

Q：为什么要更改needs_refresh（）函数？

A:试想当你进入info界面，info界面重定向到login界面，由于浏览器保留了用户的登录缓存，又由login界面跳转到index界面。

    最后当你进入info界面的时候，现在不是活跃登录，你预想的结果是让用户登录，其实不然，你发现你的浏览器进入了index界面。

    所以你需要重新定制一下needs_refresh()函数，先将当前用户退出登录，这样就会跳转到login界面了，一个小小的思维陷阱。

    在源码中没有实现我们想要的效果，那么就修改源码。

Q:当我看到view.py中，login函数时，有一个session['_fresh'] = False语句看不懂。

A:flask-login包，并没有在用户非活跃登录状态，将session['_fresh']设置为Flase的地方，所以我们在那里显示的设置为Flase。

分别用两种方式访问http://127.0.0.1:5000/info

①在键入用户账户并登录成功的情况下，在浏览器中直接输入127.0.0.1:5000/index和127.0.0.1:5000/info

②关闭浏览器界面，打开一个新的浏览器界面再次分别访问127.0.0.1:5000/index和127.0.0.1:5000/info

结果：

①在键入用户账户并登录成功的情况下，两个界面都能够正常显示。

②关闭浏览器界面，打开一个新的浏览器界面。可以访问127.0.0.1:5000/index，但当访问127.0.0.1:5000/info会跳转到登录界面，如下图所示。

看到红色的方框中，正是我们定义的needs_refresh_message信息，并且重定向到login界面。

相信读到这里，你已经能够使用：

①login_fresh()判断当前是否是活跃登录，是则返回True。

②confirm_login()将当前状态强制转换为活跃登录。

最后的最后，我们解释login_user()函数。

login_user()函数是flask-login的最核心的函数，附上源代码。

 1 def login_user(user, remember=False, force=False, fresh=True):
 2     '''
 3     Logs a user in. You should pass the actual user object to this. If the
 4     user's `is_active` property is ``False``, they will not be logged in
 5     unless `force` is ``True``.
 6 
 7     This will return ``True`` if the log in attempt succeeds, and ``False`` if
 8     it fails (i.e. because the user is inactive).
 9 
10     :param user: The user object to log in.
11     :type user: object
12     :param remember: Whether to remember the user after their session expires.
13         Defaults to ``False``.
14     :type remember: bool
15     :param force: If the user is inactive, setting this to ``True`` will log
16         them in regardless. Defaults to ``False``.
17     :type force: bool
18     :param fresh: setting this to ``False`` will log in the user with a session
19     marked as not "fresh". Defaults to ``True``.
20     :type fresh: bool
21     '''
22     if not force and not user.is_active:
23         return False
24 
25     user_id = getattr(user, current_app.login_manager.id_attribute)()
26     session['user_id'] = user_id
27     session['_fresh'] = fresh
28     session['_id'] = _create_identifier()
29 
30     if remember:
31         session['remember'] = 'set'
32 
33     _request_ctx_stack.top.user = user
34     user_logged_in.send(current_app._get_current_object(), user=_get_user())
35     return True

View Code

Top One: 不关闭浏览器情况下的Remember me功能

Operation: 读者可以尝试一下，当我们运行本次实例时。

①当你登录用户，但不使用Remember me功能。

②不关闭浏览器，打开一个新的页面，并将刚刚登录过的界面关闭。

③在新的界面输入127.0.0.1:5000/login

Explanation:

你会发现，你并没有进入login界面，而是进入了index界面，你会想我不是没有使用Remember me功能么？

其实，经常做Web程序的人会有直觉，问题出现在Session上，的确，确实发生在Session上。

以Chrome浏览器为例，打开Chrome菜单->设置->显示高级设置->内容设置（隐私内容）->所有Cookie和数据库数据（博主将截图部分cookie和日期做了模糊处理，请见谅）

我们看到这个session的过期时间是在关闭浏览器之后，这样就解释了上面的现象。

当然，你可以设置cookie失效时间，下面表格是cookie的一些设置。

TOP Two: 关闭浏览器后的Remember me功能。

Operation: 读者可以尝试一下，使用Remember me功能登录。

①进入本次实例的登录界面，输入模拟用户，勾选Remember me，点击登录按钮登录。

②关闭浏览器，重新进入本次实例系统

③你会发现你没有进入预想的index界面，而是重新进入了login界面。

为什么？让我们好好回忆一下，提示跟login_user()函数和类的初始化有关系。

对，你可以想到，LoginManager类的初始化是在一切操作之前，那么我们的当前用户设置成了AnonymousUserMixin（游客），那我们不是做了login_user()操作了么。

让我们回去看一下代码。

 1 @app.route('/login', methods=['GET', 'POST'])
 2 def login():
 3     '''
 4     Alima | cnblogs
 5     '''
 6     api_key = request.args.get('api_key')
 7     if g.user is not None and g.user.is_authenticated:
 8         session['_fresh'] = False
 9         flash(current_app.login_manager._login_disabled)
10         flash(current_user.is_authenticated)
11         return redirect(url_for('index'))
12     form = LoginForm()
13     if form.validate_on_submit():
14         flash(form.remember_me.data)
15         user = User.query.filter_by(username=form.username.data, password=form.password.data).first()
16         if(user is not None):
17             login_user(user, form.remember_me.data)
18             return redirect(request.args.get("next") or url_for('index'))
19         else:
20             print(form.errors)
21     return render_template('login.html', form=form)

发现问题了么，这是因为博主之前了解flask-login包不是很深刻，以为@user_loader会使用户自动load进LoginManager函数，其实不然。

将第8行改为：

login_user(load_user(g.user.id), True, False, False)

Q：为什么不传入g.user或者current_user？

A：传入g.user或者current_user，会发出一个maximum recursion depth exceeded in comparison的错误信息。

     current_user不是一个纯正的用户类，它的返回值是一个Thread Local 对象。（解析：Flask的Context机制）

current_user = LocalProxy(lambda: _get_user())

Topic Three：logout_user()函数功能。

logout_user()函数功能就是将缓存的用户信息清楚，将Remember me标记位设置为清空状态。

 1 def logout_user():
 2     '''
 3     Logs a user out. (You do not need to pass the actual user.) This will
 4     also clean up the remember me cookie if it exists.
 5     '''
 6 
 7     user = _get_user()
 8 
 9     if 'user_id' in session:
10         session.pop('user_id')
11 
12     if '_fresh' in session:
13         session.pop('_fresh')
14 
15     cookie_name = current_app.config.get('REMEMBER_COOKIE_NAME', COOKIE_NAME)
16     if cookie_name in request.cookies:
17         session['remember'] = 'clear'
18 
19     user_logged_out.send(current_app._get_current_object(), user=user)
20 
21     current_app.login_manager.reload_user()
22     return True

View Code

至此，本篇介绍基本结束，更深入的flask-login包的使用，博主将在以后为大家开设专题深入讲解。

如果你对博文中某些观点，某些思考角度不一样的，欢迎在Alima的cnblogs下面留言私信，你们的互动是我的动力。

Posted by Alima | cnblogs。

If there is some question Obsession about this blog，welcome to enter www.cnblogs.com/alima/ and seed message to me.

参考：

[1] flask-login Github maxcountryman https://github.com/maxcountryman/flask-login

[2] flask-login Doc maxcountryman https://flask-login.readthedocs.io/en/latest/

PS:

本篇博文撰写时间比之前的已发表的几篇博文相比，时间较长。但内容相比之前更充实，解析并修改源码是一种新的尝试。

学习新知识本应如此，追求一些细致的东西，会让一些未知的问题迎刃而解。

如果你喜欢Alima的博文，欢迎Follow Alima的cnblogs的最新动态。

另外，Alima在谋求一个进取的平台发展，一份安心的Offer，欢迎投来橄榄枝，欢迎提出职位需求，请您联系我。

----------------------------------

| Alima的联系方式

| QQ Chat: 995816845

| E-mail：xoxo2191@163.com

----------------------------------

*本文为Alima原创，转载注明格式[转载][博客园][Alima][关于flask-login中各种API使用实例]，并在文首注明本文链接，多谢合作。

*非法转载及非法抄袭博文将依照网络著作权流程办理，请尊重作者劳动成果，最终解释权归Alima与博客园共同所有，感谢合作。

*关于恶意爬虫与删除关于博主信息的原文进行转载，请您高抬贵手，分享无价，别让新博主对这一行失去兴趣，营造良好的互联网环境。

Power by Alima | cnblogs。