Flask Session 登录认证模块

Flask 框架提供了强大的 Session 模块组件，为 Web 应用实现用户注册与登录系统提供了方便的机制。结合 Flask-WTF 表单组件，我们能够轻松地设计出用户友好且具备美观界面的注册和登录页面，使这一功能能够直接应用到我们的项目中。本文将深入探讨如何通过 Flask 和 Flask-WTF 构建一个完整的用户注册与登录系统，以及如何对页面进行优化美化，提高用户体验。通过这一系统，用户能够方便注册账户、安全登录，并且我们能够有效管理用户的会话信息，为 Web 应用的用户管理提供一种高效的解决方案。
什么是Session机制？
Session 是一种在 Web 应用中用于存储用户特定信息的机制。它允许在用户访问网站时存储和检索信息，以便在用户的不同请求之间保持状态。Session 机制在用户登录、购物网站、个性化设置等场景中得到广泛应用，它为用户提供了更加连贯和个性化的体验。在 Flask 中，通过 Flask Session 模块可以方便地使用 Session ，实现用户状态的维护和管理。
在 Web 开发中，HTTP 协议是无状态的，即每个请求都是独立的，服务器不会记住之前的请求信息。为了解决这个问题，引入了 Session 机制。基本思想是在用户访问网站时，服务器生成一个唯一的 Session ID，并将这个 ID 存储在用户的浏览器中（通常通过 Cookie）。同时，服务器端会保存一个映射，将 Session ID 与用户的相关信息关联起来，这样在用户的后续请求中，服务器就能根据 Session ID 找到相应的用户信息，从而实现状态的保持。
Session 的认证流程通常包括以下步骤：

• 用户登录： 用户通过提供用户名和密码进行登录。在登录验证成功后，服务器为该用户创建一个唯一的 Session ID，并将这个 ID 存储在用户浏览器的 Cookie 中。
  
• Session 存储： 服务器端将用户的相关信息（如用户 ID、权限等）与 Session ID 关联起来，并将这些信息存储在服务器端的 Session 存储中。Session 存储可以是内存、数据库或其他持久化存储方式。
  
• Session ID 传递： 服务器将生成的 Session ID 发送给用户浏览器，通常是通过 Set-Cookie 头部。这个 Cookie 会在用户的每次请求中被包含在 HTTP 头中。
  
• 后续请求： 用户在后续的请求中会携带包含 Session ID 的 Cookie。服务器通过解析请求中的 Session ID，从 Session 存储中检索用户的信息，以恢复用户的状态。
  
• 认证检查： 服务器在每次请求中检查 Session ID 的有效性，并验证用户的身份。如果 Session ID 无效或过期，用户可能需要重新登录。
  
• 用户登出： 当用户主动注销或 Session 过期时，服务器将删除与 Session ID 关联的用户信息，用户需要重新登录。
  

总体而言，Session 的认证流程通过在客户端和服务器端之间传递唯一的 Session ID，实现了用户状态的持久化和管理。这种机制使得用户可以在多个请求之间保持登录状态，提供了一种有效的用户认证方式。在 Flask 中，开发者可以方便地使用 Flask 提供的 Session 模块来实现这一流程。
Session 认证基础

默认情况下，直接使用Session模块即可实现Session登录会话保持，该方式是将Session存储到内存中，程序重启后即释放，Session的设置一般可以通过使用session["username"]赋值的方式进行，如需验证该Session的可靠性，则只需要调用session.get方法即可一得到特定字段，通过对字段的判断即可实现认证机制。
如下是一个Flask后端代码，运行后通过访问http://127.0.0.1:5000进入到登录这页面。

1. from flask import Flask,session,render_template,request,Response,redirect,url_for
2. from functools import wraps
3. import os
5. app = Flask(__name__, static_folder="./template",template_folder="./template")
6. app.config['SECRET_KEY'] = os.urandom(24)
8. # 登录认证装饰器
9. def login_required(func):
10.     @wraps(func)
11.     def wrapper(*args, **kwargs):
12.         if session.get("username") != None and session.get("is_login") ==True:
13.             print("登陆过则继续执行原函数")
14.             return func(*args, **kwargs)
15.         else:
16.             print("没有登录则跳转到登录页面")
17.             resp = Response()
18.             resp.status_code=200
19.             resp.data = ""
20.             return resp
21.     return wrapper
23. @app.route("/login",methods=["GET","POST"])
24. def login():
25.     if request.method == "GET":
26.         html = """
27.                 <form action="/login" method="post">
28.                     <p>账号: <input type="text" name="username"></p>
29.                     <p>密码: <input type="password" name="password"></p>
30.                     <input type="submit" value="登录">
31.                 </form>
32.                 """
33.         return html
35.     if request.method == "POST":
36.         get_dict = request.form.to_dict()
38.         get_username = get_dict['username']
39.         get_password = get_dict['password']
41.         if (get_username == "lyshark" or get_username == "admin") and get_password == "123123":
42.             session["username"] = get_username
43.             session["is_login"] = True
45.             print("登录完成直接跳到主页")
46.             resp = Response()
47.             resp.status_code=200
48.             resp.data = ""
49.             return resp
50.         else:
51.             return "登陆失败"
52.     return "未知错误"
54. # 主页菜单
55. @app.route("/index",methods = ["GET","POST"])
56. @login_required
57. def index():
58.     username = session.get("username")
59.     return "用户 {} 您好,这是主页面".format(username)
61. # 第二个菜单
62. @app.route("/get",methods = ["GET","POST"])
63. @login_required
64. def get():
65.     username = session.get("username")
66.     return "用户 {} 您好,这是子页面".format(username)
68. @app.route("/logout",methods = ["GET","POST"])
69. @login_required
70. def logout():
71.     username = session.get("username")
73.     # 登出操作
74.     session.pop("username")
75.     session.pop("is_login")
76.     session.clear()
77.     return "用户 {} 已注销".format(username)
79. if __name__ == '__main__':
80.     app.run()

复制代码

程序运行后，当用户访问http://127.0.0.1:5000地址则会跳转到login登陆页面，此时如果用户第一次访问则会输出如下所示的登陆信息；

通过输入正确的用户名lyshark和密码123123则可以登录成功，此处登录的用户是lyshark如下图。

通过输入不同的用户登录会出现不同的页面提示信息，如下图则是admin的主页信息。

当我们手动输入logout时则此时会退出登录用户，后台也会清除该用户的Session，在开发中可以自动跳转到登出页面；

Session 使用数据库

通过结合 Session 与 SQLite 数据库，我们可以实现一个更完善的用户注册、登录以及密码修改功能。在这个案例中，首先，用户可以通过注册表单输入用户名、密码等信息，这些信息经过验证后将被存储到 SQLite 数据库中。注册成功后，用户可以使用相同的用户名和密码进行登录。登录成功后，我们使用 Flask 的 Session 机制将用户信息保存在服务器端，确保用户在访问其他页面时仍然处于登录状态。
为了增加更多功能，我们还可以实现密码修改的功能。用户在登录状态下，通过密码修改表单输入新的密码，我们将新密码更新到数据库中，确保用户可以安全地更改密码。这个案例综合运用了 Flask、SQLite 和 Session 等功能，为 Web 应用提供了一套完整的用户管理系统。

1. from flask import Flask,request,render_template,session,Response
2. import sqlite3,os
3. from functools import wraps
5. app = Flask(__name__)
7. app.config['SECRET_KEY'] = os.urandom(24)
9. # 创建数据库
10. def UserDB():
11.     conn = sqlite3.connect("./database.db")
12.     cursor = conn.cursor()
13.     create = "create table UserDB(" \
14.              "uid INTEGER primary key AUTOINCREMENT not null unique," \
15.              "username char(64) not null unique," \
16.              "password char(64) not null," \
17.              "email char(64) not null" \
18.              ")"
19.     cursor.execute(create)
20.     conn.commit()
21.     cursor.close()
22.     conn.close()
24. # 增删改查简单封装
25. def RunSqlite(db,table,action,field,value):
26.     connect = sqlite3.connect(db)
27.     cursor = connect.cursor()
29.     # 执行插入动作
30.     if action == "insert":
31.         insert = f"insert into {table}({field}) values({value});"
32.         if insert == None or len(insert) == 0:
33.             return False
34.         try:
35.             cursor.execute(insert)
36.         except Exception:
37.             return False
39.     # 执行更新操作
40.     elif action == "update":
41.         update = f"update {table} set {value} where {field};"
42.         if update == None or len(update) == 0:
43.             return False
44.         try:
45.             cursor.execute(update)
46.         except Exception:
47.             return False
49.     # 执行查询操作
50.     elif action == "select":
52.         # 查询条件是否为空
53.         if value == "none":
54.             select = f"select {field} from {table};"
55.         else:
56.             select = f"select {field} from {table} where {value};"
58.         try:
59.             ref = cursor.execute(select)
60.             ref_data = ref.fetchall()
61.             connect.commit()
62.             connect.close()
63.             return ref_data
64.         except Exception:
65.             return False
67.     # 执行删除操作
68.     elif action == "delete":
69.         delete = f"delete from {table} where {field};"
70.         if delete == None or len(delete) == 0:
71.             return False
72.         try:
73.             cursor.execute(delete)
74.         except Exception:
75.             return False
76.     try:
77.         connect.commit()
78.         connect.close()
79.         return True
80.     except Exception:
81.         return False
83. # 创建数据库
84. @app.route("/create")
85. def create():
86.     UserDB()
87.     return "create success"
89. # 登录认证装饰器
90. def login_required(func):
91.     @wraps(func)
92.     def wrapper(*args, **kwargs):
93.         if session.get("username") != None and session.get("is_login") ==True:
94.             print("登陆过则继续执行原函数")
95.             return func(*args, **kwargs)
96.         else:
97.             print("没有登录则跳转到登录页面")
98.             resp = Response()
99.             resp.status_code=200
100.             resp.data = ""
101.             return resp
102.     return wrapper
104. # 用户注册页面
105. @app.route("/register",methods=["GET","POST"])
106. def register():
107.     if request.method == "GET":
108.         html = """
109.                 <form action="/register" method="post">
110.                     <p>账号: <input type="text" name="username"></p>
111.                     <p>密码: <input type="password" name="password"></p>
112.                     <p>邮箱: <input type="text", name="email"></p>
113.                     <input type="submit" value="用户注册">
114.                 </form>
115.                 """
116.         return html
118.     if request.method == "POST":
119.         username = request.form.get("username")
120.         password = request.form.get("password")
121.         email = request.form.get("email")
123.         if RunSqlite("database.db","UserDB","select","username",f"username='{username}'") == []:
124.             insert = RunSqlite("database.db","UserDB","insert","username,password,email",f"'{username}','{password}','{email}'")
125.             if insert == True:
126.                 return "创建完成"
127.             else:
128.                 return "创建失败"
129.         else:
130.             return "用户存在"
131.         return "未知错误"
133. # 用户登录模块
134. @app.route("/login",methods=["GET","POST"])
135. def login():
136.     if request.method == "GET":
137.         html = """
138.                 <form action="/login" method="post">
139.                     <p>账号: <input type="text" name="username"></p>
140.                     <p>密码: <input type="password" name="password"></p>
141.                     <input type="submit" value="登录">
142.                 </form>
143.                 """
144.         return html
146.     if request.method == "POST":
147.         username = request.form.get("username")
148.         password = request.form.get("password")
150.         select = RunSqlite("database.db","UserDB","select","username,password",f"username='{username}'")
151.         if select != []:
152.             # 继续验证密码
153.             if select[0][1] == password:
154.                 session["username"] = username
155.                 session["is_login"] = True
157.                 print("登录完成直接跳到主页")
158.                 resp = Response()
159.                 resp.status_code = 200
160.                 resp.data = ""
161.                 return resp
162.             else:
163.                 return "密码不正确"
164.         else:
165.             return "用户不存在"
166.     return "未知错误"
168. # 修改密码
169. @app.route("/modify",methods=["GET","POST"])
170. @login_required
171. def modify():
172.     if request.method == "GET":
173.         html = """
174.                 <form action="/modify" method="post">
175.                     <p>新密码: <input type="password" name="new_password"></p>
176.                     <input type="submit" value="修改密码">
177.                 </form>
178.                 """
179.         return html
181.     if request.method == "POST":
182.         username = session.get("username")
183.         new_password = request.form.get("new_password")
184.         update = RunSqlite("database.db","UserDB","update",f"username='{username}'",f"password='{new_password}'")
185.         if update == True:
186.             # 登出操作
187.             session.pop("username")
188.             session.pop("is_login")
189.             session.clear()
191.             print("密码已更新,请重新登录")
192.             resp = Response()
193.             resp.status_code = 200
194.             resp.data = ""
195.             return resp
196.         else:
197.             return "密码更新失败"
198.     return "未知错误"
200. # 主页菜单
201. @app.route("/index",methods = ["GET","POST"])
202. @login_required
203. def index():
204.     username = session.get("username")
205.     return "用户 {} 您好,这是主页面".format(username)
207. # 第二个菜单
208. @app.route("/get",methods = ["GET","POST"])
209. @login_required
210. def get():
211.     username = session.get("username")
212.     return "用户 {} 您好,这是子页面".format(username)
214. @app.route("/logout",methods = ["GET","POST"])
215. @login_required
216. def logout():
217.     username = session.get("username")
219.     # 登出操作
220.     session.pop("username")
221.     session.pop("is_login")
222.     session.clear()
223.     return "用户 {} 已注销".format(username)
225. if __name__ == '__main__':
226.     app.run(debug=True)

复制代码

案例被运行后首先通过调用http://127.0.0.1:5000/create创建database.db数据库，接着我们可以通过访问/register路径实现账号注册功能，如下我们注册lyshark密码是123123，输出效果如下所示；

通过访问/modify可实现对用户密码的修改，但在修改之前需要先通过/login页面登录后进行，否则会默认跳转到用户登录页面中；
使用WTForms登录模板

在如上代码基础上，我们着重增加一个美化登录模板，以提升用户在注册登录流程中的整体体验。通过引入WTF表单组件和Flask-WTF扩展，在前端实现了一个更友好的登录页面。
此登录模板的设计考虑了页面布局、颜色搭配、表单样式等因素，以确保用户在输入用户名和密码时感到轻松自然。同时，我们利用Flask-WTF的验证器功能，对用户输入的数据进行有效性检查，保障了用户信息的安全性。
首先，我们需要在template目录下，创建register.html前端文件，用于用户注册，并写入以下代码。

1. <html>
2. <head>
3.     <link rel="stylesheet" href="https://www.lyshark.com/javascript/bootstrap/3.3.7/css/bootstrap.min.css">
4.     <link href="https://www.lyshark.com/javascript/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" type="text/css" />
5.     <link href="https://www.lyshark.com/javascript/other/my_login.css" rel="stylesheet" type="text/css" />
6. </head>
7. <body>
8.    
9.         
10.             
11.                 <form action="/register" method="post" >
12.                     {{ form.csrf_token }}
14.                     用 户 注 册
15.                     
16.                         {{ form.username }}
17.                         <i ></i>
18.                         <a target="_blank" href="https://www.cnblogs.com/login" ></a>
19.                     
20.                     
21.                         {{ form.email }}
22.                         <i ></i>
23.                     
24.                     
25.                         {{ form.password }}
26.                         <i ></i>
27.                     
28.                     
29.                         {{ form.RepeatPassword }}
30.                         <i ></i>
31.                     
32.                     {{ form.submit }}
33.                 </form>
34.             
35.         
36.    
37. </body>
38. </html>

复制代码

接着，继续创建login.html前端文件，用于登录账号时使用，并写入以下代码。

1. <html>
2. <head>
3.     <link rel="stylesheet" href="https://www.lyshark.com/javascript/bootstrap/3.3.7/css/bootstrap.min.css">
4.     <link href="https://www.lyshark.com/javascript/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" type="text/css" />
5.     <link href="https://www.lyshark.com/javascript/other/my_login.css" rel="stylesheet" type="text/css" />
6. </head>
7.     <body>
8.         
9.             
10.                
11.                     <form action="/login" method="post" >
12.                         {{ form.csrf_token }}
14.                         用 户 登 录
15.                         
16.                             {{ form.username }}
17.                             <i ></i>
18.                         
19.                         
20.                             {{ form.password }}
21.                             <i ></i>
22.                             <a target="_blank" href="https://www.cnblogs.com/#" ></a>
23.                         
24.                         
25.                             <button type="submit" >登 录 后 台</button>
26.                         
27.                     </form>
28.                
29.             
30.         
31.     </body>
32. </html>

复制代码

后台代码部分，我们需要在原代码的基础之上，增加对前端注册和登录页面的渲染类，此处使用flask_wtf组件实现渲染生成，具体代码如下。

1. from flask import Flask,request,render_template,session,Response
2. from functools import wraps
3. import sqlite3,os
5. from flask_wtf import FlaskForm
6. from wtforms import widgets,validators
7. from wtforms.validators import DataRequired,Regexp,DataRequired, Length, Email, EqualTo, NumberRange
8. from wtforms.fields import (StringField, PasswordField, DateField, BooleanField,DateTimeField,TimeField,
9.                             SelectField, SelectMultipleField, TextAreaField,FloatField,HiddenField,
10.                             RadioField, IntegerField, DecimalField, SubmitField, IntegerRangeField)
12. # app = Flask(__name__, static_folder="./template",template_folder="./template")
13. app = Flask(__name__)
15. app.config["SECRET_KEY"] = "d3d3Lmx5c2hhcmsuY29t"
17. # -----------------------------------------------------------------------------
18. # 创建数据库
19. def UserDB():
20.     conn = sqlite3.connect("database.db")
21.     cursor = conn.cursor()
22.     create = "create table UserDB(" \
23.              "uid INTEGER primary key AUTOINCREMENT not null unique," \
24.              "username char(64) not null unique," \
25.              "password char(64) not null," \
26.              "email char(64) not null" \
27.              ")"
28.     cursor.execute(create)
29.     conn.commit()
30.     cursor.close()
31.     conn.close()
33. # 增删改查简单封装
34. def RunSqlite(db,table,action,field,value):
35.     connect = sqlite3.connect(db)
36.     cursor = connect.cursor()
38.     # 执行插入动作
39.     if action == "insert":
40.         insert = f"insert into {table}({field}) values({value});"
41.         if insert == None or len(insert) == 0:
42.             return False
43.         try:
44.             cursor.execute(insert)
45.         except Exception:
46.             return False
48.     # 执行更新操作
49.     elif action == "update":
50.         update = f"update {table} set {value} where {field};"
51.         if update == None or len(update) == 0:
52.             return False
53.         try:
54.             cursor.execute(update)
55.         except Exception:
56.             return False
58.     # 执行查询操作
59.     elif action == "select":
61.         # 查询条件是否为空
62.         if value == "none":
63.             select = f"select {field} from {table};"
64.         else:
65.             select = f"select {field} from {table} where {value};"
67.         try:
68.             ref = cursor.execute(select)
69.             ref_data = ref.fetchall()
70.             connect.commit()
71.             connect.close()
72.             return ref_data
73.         except Exception:
74.             return False
76.     # 执行删除操作
77.     elif action == "delete":
78.         delete = f"delete from {table} where {field};"
79.         if delete == None or len(delete) == 0:
80.             return False
81.         try:
82.             cursor.execute(delete)
83.         except Exception:
84.             return False
85.     try:
86.         connect.commit()
87.         connect.close()
88.         return True
89.     except Exception:
90.         return False
92. # -----------------------------------------------------------------------------
93. # 生成用户注册表单
94. class RegisterForm(FlaskForm):
95.     username = StringField(
96.         validators=[
97.             DataRequired(message='用户名不能为空'),
98.             Length(min=1, max=15, message='用户名长度必须大于%(min)d且小于%(max)d')
99.         ],
100.         widget=widgets.TextInput(),
101.         render_kw={'class': 'form-control', "placeholder":"输入注册用户名"}
102.     )
103.     email = StringField(
104.         validators=[validators.DataRequired(message='邮箱不能为空'),validators.Email(message="邮箱格式输入有误")],
105.         render_kw={'class':'form-control', "placeholder":"输入Email邮箱"}
106.     )
107.     password = PasswordField(
108.         validators=[
109.             validators.DataRequired(message='密码不能为空'),
110.             validators.Length(min=5, message='用户名长度必须大于%(min)d'),
111.             validators.Regexp(regex="[0-9a-zA-Z]{5,}",message='密码不允许使用特殊字符')
112.         ],
113.         widget=widgets.PasswordInput(),
114.         render_kw={'class': 'form-control', "placeholder":"输入用户密码"}
115.     )
116.     RepeatPassword = PasswordField(
117.         validators=[
118.             validators.DataRequired(message='密码不能为空'),
119.             validators.Length(min=5, message='密码长度必须大于%(min)d'),
120.             validators.Regexp(regex="[0-9a-zA-Z]{5,}",message='密码不允许使用特殊字符'),
121.             validators.EqualTo("password",message="两次密码输入必须一致")
122.         ],
123.         widget=widgets.PasswordInput(),
124.         render_kw={'class': 'form-control', "placeholder":"再次输入密码"}
125.     )
126.     submit = SubmitField(
127.         label="用 户 注 册", render_kw={ "class":"btn btn-success" }
128.     )
130. # 生成用户登录表单
131. class LoginForm(FlaskForm):
132.     username = StringField(
133.         validators=[
134.             validators.DataRequired(message=''),
135.             validators.Length(min=4, max=15, message=''),
136.             validators.Regexp(regex="[0-9a-zA-Z]{4,15}", message='')
137.         ],
138.         widget=widgets.TextInput(),
139.         render_kw={"class":"form-control", "placeholder":"请输入用户名或电子邮件"}
140.     )
141.     password = PasswordField(
142.         validators=[
143.             validators.DataRequired(message=''),
144.             validators.Length(min=5, max=15,message=''),
145.             validators.Regexp(regex="[0-9a-zA-Z]{5,15}",message='')
146.         ],
147.         widget=widgets.PasswordInput(),
148.         render_kw={"class":"form-control", "placeholder":"请输入密码"}
149.     )
151. # -----------------------------------------------------------------------------
152. # 创建数据库
153. @app.route("/create")
154. def create():
155.     UserDB()
156.     return "create success"
158. # 登录认证装饰器
159. def login_required(func):
160.     @wraps(func)
161.     def wrapper(*args, **kwargs):
162.         if session.get("username") != None and session.get("is_login") ==True:
163.             print("登陆过则继续执行原函数")
164.             return func(*args, **kwargs)
165.         else:
166.             print("没有登录则跳转到登录页面")
167.             resp = Response()
168.             resp.status_code=200
169.             resp.data = ""
170.             return resp
171.     return wrapper
173. # 用户注册页面
174. @app.route("/register",methods=["GET","POST"])
175. def register():
176.     form = RegisterForm(csrf_enabled = True)
178.     if request.method == "POST":
179.         if form.validate_on_submit():
180.             username = form.username.data
181.             password = form.RepeatPassword.data
182.             email = form.email.data
183.             print("用户: {} 邮箱: {}".format(username,email))
185.             if RunSqlite("database.db", "UserDB", "select", "username", f"username='{username}'") == []:
186.                 insert = RunSqlite("database.db", "UserDB", "insert", "username,password,email",
187.                                    f"'{username}','{password}','{email}'")
188.                 if insert == True:
189.                     return "创建完成"
190.                 else:
191.                     return "创建失败"
192.             else:
193.                 return "用户存在"
195.     return render_template("register.html", form=form)
197. # 用户登录页面
198. @app.route("/login",methods=["GET","POST"])
199. def login():
200.     form = LoginForm(csrf_enabled = True)
202.     if request.method == "POST":
203.         username = form.username.data
204.         password = form.password.data
206.         select = RunSqlite("database.db","UserDB","select","username,password",f"username='{username}'")
207.         if select != []:
208.             # 继续验证密码
209.             if select[0][1] == password:
210.                 session["username"] = username
211.                 session["is_login"] = True
213.                 print("登录完成直接跳到主页")
214.                 resp = Response()
215.                 resp.status_code = 200
216.                 resp.data = ""
217.                 return resp
218.             else:
219.                 return "密码不正确"
220.         else:
221.             return "用户不存在"
223.     return render_template("login.html", form=form)
225. # 修改密码
226. @app.route("/modify",methods=["GET","POST"])
227. @login_required
228. def modify():
229.     if request.method == "GET":
230.         html = """
231.                 <form action="/modify" method="post">
232.                     <p>新密码: <input type="password" name="new_password"></p>
233.                     <input type="submit" value="修改密码">
234.                 </form>
235.                 """
236.         return html
238.     if request.method == "POST":
239.         username = session.get("username")
240.         new_password = request.form.get("new_password")
241.         update = RunSqlite("database.db","UserDB","update",f"username='{username}'",f"password='{new_password}'")
242.         if update == True:
243.             # 登出操作
244.             session.pop("username")
245.             session.pop("is_login")
246.             session.clear()
248.             print("密码已更新,请重新登录")
249.             resp = Response()
250.             resp.status_code = 200
251.             resp.data = ""
252.             return resp
253.         else:
254.             return "密码更新失败"
255.     return "未知错误"
257. # 主页菜单
258. @app.route("/index",methods = ["GET","POST"])
259. @login_required
260. def index():
261.     username = session.get("username")
262.     return "用户 {} 您好,这是主页面".format(username)
264. # 第二个菜单
265. @app.route("/get",methods = ["GET","POST"])
266. @login_required
267. def get():
268.     username = session.get("username")
269.     return "用户 {} 您好,这是子页面".format(username)
271. @app.route("/logout",methods = ["GET","POST"])
272. @login_required
273. def logout():
274.     username = session.get("username")
276.     # 登出操作
277.     session.pop("username")
278.     session.pop("is_login")
279.     session.clear()
280.     return "用户 {} 已注销".format(username)
282. if __name__ == '__main__':
283.     app.run(debug=True)

复制代码

目录结果如下图所示；

当用户访问/register时，则可以看到通过flask_wtf渲染后的用户注册页面，如下图所示；

用户访问/login时，则是用户登录页面，如下图所示；


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！