从零搭建一个在线聊天室
整体技术栈
flask 框架
flask_login 的使用
WebSocket 简单应用
Redis 应用
flask_socketio 的使用
搭建权限框架
还是使用 Flask 来搭建后台应用
从零搭建一个在线聊天室
整体技术栈
-
flask 框架
-
flask_login 的使用
-
WebSocket 简单应用
-
Redis 应用
-
flask_socketio 的使用
搭建权限框架
还是使用 Flask 来搭建后台应用，使用 flask-login 扩展来处理用户登陆鉴权逻辑。 首先定义登陆表单
class LoginForm(FlaskForm):
username = StringField('Username', validators=[DataRequired(), ])
password = PasswordField('Password', validators=[DataRequired()])
remember_me = BooleanField('Keep me logged in')
submit = SubmitField('Log in')
接下来定义数据库结构
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, index=True)
password = db.Column(db.String(64))
当前，我们只需要一个 user 用户表，只包含三个字段的简单表。用户密码也只是简单的保存了明文，后面再处理用户密码的 hash 问题。
下面就可以定义用户登陆表单
```
from flask_login import LoginManager
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'login'
app = Flask(
name
)
login_manager.init_app(app)
app.config['SECRET_KEY'] = 'hardtohard'
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
@app.route('/login', methods=['GET', 'POST'])
def login():
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user:
login_user(user)
return redirect(url_for('chat'))
return render_template('login.html', form=form)
```
这里定义了，只检查用户名是否存在，如果存在，就执行 login_user() 函数，登陆。用户密码的使用，也留到后面再做处理。
其中 load_user，是回调函数，将获取到的 user 对象存储到浏览器的 session 中，然后在调用 login_user 函数时，就会调用 load_user 来把真正需要登陆的用户设置到 session 中。当登陆成功后，就会跳转到 chat 函数所对应的页面。
chat 函数比较简单，只是展示一个网页
@app.route('/chat', methods=['GET', 'POST'])
@login_required
def chat():
return render_template('chat.html')
使用 login_required 装饰器，保证该函数只允许登陆的用户访问。
增加些初始化函数
```
@app.route('/adddb', methods=['GET', 'POST'])
def addbd():
db.create_all()
return "OK"
@app.route('/deldb', methods=['GET', 'POST'])
def delbd():
db.drop_all()
return "OK"
@app.route('/adduser/
', methods=['GET', 'POST'])
def adduser(user):
user = User(username=user, password='admin')
db.session.add(user)
db.session.commit()
return "OK"
```
增加了初始化数据库和新增用户的函数。
构建前端页面
首先处理登陆页面，在 login.html 中添加
```
{% extends "bootstrap/base.html" %}
{% import "bootstrap/wtf.html" as wtf %}
{% block title %}Flasky{% endblock %}
{% block navbar %}
{% if current_user.is_authenticated %}
-
Logout
{% else %}
-
Login
{% endif %}
{% endblock %}
{% block content %}
{{ wtf.quick_form(form) }}
{% endblock %}
```
使用扩展库 flask_bootstrap 来快速构建页面。
下面重点来看看 chat 页面。 首先来看看主体页面，在 chat.html 中填入代码
```
{% extends 'bootstrap/base.html' %}
{% import "bootstrap/wtf.html" as wtf %}
{% block title %}Kung Fu Realm{%endblock %}
{% block head %}
Hi Hi 聊天室
{% endblock %}
{% block content %}
{% if current_user.is_authenticated %}
{% else %}
{% endif %}
小HI
{% if current_user.is_authenticated %}
-
退出登陆
{% else %}
-
登录
{% endif %}
{% if current_user.is_authenticated %}
Welcome to Hihi Chat Room. 欢迎来到 Hihi 聊天室。
小黄鸭
{% else %}
{% endif %}
{% if current_user.is_authenticated %}
{% else %}
{% endif %}
群聊
{% if current_user.is_authenticated %}
{% else %}
{% endif %}
```
整体效果如下，是不是挺少女系的。
当用户在点击“提交”按钮后，调用 JS 函数
```
/*用户登陆的用户点击提交按钮发送消息按钮*/
$('#sub_but_login').click(function(event){
sendMessageLogin(event, fromname, to_uid, to_uname);
});
```
为了后面便于扩展，将未登录的用户特别区分开来，后面也许同样允许未登陆用户访问该页面，但是只能同机器人小黄鸭聊天
```
/*用户未登陆的用户点击提交按钮发送消息按钮*/
$('#sub_but').click(function(event){
sendMessage(event, fromname, to_uid, to_uname);
});
```
在来看函数 sendMessageLogin
```
function sendMessageLogin(event, from_name, to_uid, to_uname){
var msg = $("#message").val();
var myDate = new Date();
var myTime = myDate.toLocaleTimeString();
var itTime = myDate.toLocaleString();
//var iTime = myDate.toDateString();
var htmlData = '
'
+ '
{% if current_user.is_authenticated %}
 }})
{% endif %}
'
+ '
'
+ '
' + msg + '
'
+ '
' + from_name + ' · ' + itTime +'
'
+ '
'
+ '
';
$("#message_box").append(htmlData);
$('#message_box').scrollTop($("#message_box")[0].scrollHeight + 20);
$("#message").val('');
setTimeout(function(){sendToServer(from_name, msg)}, 1000); //延时调用
}
```
> 接收几个参数，然后将当前会话消息追加到 HTML 页面中，并且调用真正的后台 API 函数 sendToServer
```
function sendToServer(name, msg){
var xmlhttp = new XMLHttpRequest();
var myDate = new Date();
//var myTime = myDate.toLocaleTimeString();
var myTime = myDate.toLocaleString();
xmlhttp.onreadystatechange=function() {
if (xmlhttp.readyState == 4 && xmlhttp.status == 200) {
myObj = xmlhttp.responseText;
var htmlData2 = '
'
+ '
'
+ '
'
+ '
' + myObj + '
'
+ '
' + '小黄鸭' + ' · ' + myTime +'
'
+ '
'
+ '
';
$("#message_box").append(htmlData2);
$('#message_box').scrollTop($("#message_box")[0].scrollHeight + 20);
}
}
xmlhttp.open("GET", "/api/sendchat/" + msg, true);
xmlhttp.send();
};
```
> sendToServer 函数调用后台 API，并把返回接收到的消息回写到 HTML 页面中。
而目前的后台 API 也比较简单，直接返回用户输入的消息
```
@app.route('/api/sendchat/
', methods=['GET', 'POST'])
@login_required
def send_chat(info):
return info
```
这样，一个整体的聊天室架子就搭建好了，接下来我们再接入 Redis，来实现聊天功能。
### 应用 Redis
我这里使用 Redis 来作为后端数据存储工具。大家如果有自己的 Redis 服务器当然是最好了，如果没有的话，推荐下在线的 Redis 免费应用 redislabs，大家可以自行体验下，[redislabs.com/](https://link.juejin.cn?target=https%3A%2F%2Fredislabs.com%2F)
下面连接到 Redis 服务器并打开连接池
```
pool = redis.ConnectionPool(host='redis-12143.c8.us-east-1-3.ec2.cloud.redislabs.com', port=12143,
decode_responses=True, password='pkAWNdYWfbLLfNOfxTJinm9SO1')
r = redis.Redis(connection_pool=pool)
```
Redis 中数据结构及用法如下： chat-{ChatRoomName}，聊天室及加入的用户，zset 类型 msg-{ChatRoomName}，每个聊天室对应的消息，zset 类型
当前结构比较简单，暂时只定义了两个域，分别用来存储聊天室和消息。
### 完善 chat 视图功能
在前面的代码中，chat 视图函数仅仅是返回了一个 HTML 页面，并没有任何功能逻辑，现在要完善下。最新的代码如下：
```
@app.route('/chat', methods=['GET', 'POST'])
@login_required
def chat():
rname = request.args.get('rname', "")
ulist = r.zrange("chat-" + rname, 0, -1)
messages = r.zrange("msg-" + rname, 0, -1, withscores=True)
msg_list = []
for i in messages:
msg_list.append([json.loads(i[0]), time.strftime("%Y/%m/%d %p%H:%M:%S", time.localtime(i[1]))])
return render_template('chat.html', rname=rname, user_list=ulist, msg_list=msg_list)
```
> 其中 rname 是其他函数传值过来的，我们后面再说。 r.zrange() 函数就是从 Redis 中取出对应聊天室的用户列表和历史聊天记录，最后就是把相关的信息返回到模板中。
### 创建及加入聊天室
在 chat 视图中，我们传入了一个 rname 字段，这个字段就是当创建或者加入聊天室时，需要传递过来的。
#### 创建聊天室
```
@app.route('/createroom', methods=["GET", 'POST'])
@login_required
def create_room():
rname = request.form.get('chatroomname', '')
if r.exists("chat-" + rname) is False:
r.zadd("chat-" + rname, current_user.username, 1)
return redirect(url_for('chat', rname=rname))
else:
return redirect(url_for('chat_room_list'))
```
> 判断聊天室名称是否存在，如果不存在，则将当前用户在 Redis 中创建并跳转至 chat 函数；否则跳转至聊天室列表页面。
#### 加入聊天室
```
@app.route('/joinroom', methods=["GET", 'POST'])
@login_required
def join_chat_room():
rname = request.args.get('rname', '')
if rname is None:
return redirect(url_for('chat_room_list'))
r.zadd("chat-" + rname, current_user.username, time.time())
return redirect(url_for('chat', rname=rname))
```
> 这里是从前端获取到聊天室名称（rname），并将当前用户名加入到对应的聊天室中。
到这里，Redis 中的聊天室就处理完成了，下面再来看看其他的一些辅助功能。
### 一些辅助功能
#### 一、聊天室列表
既然有加入聊天室的功能，那么就要提供一个列表供用户选择聊天室。
后台逻辑代码：
```
@app.route('/roomlist', methods=["GET", 'POST'])
@login_required
def chat_room_list():
roomlist_tmp = r.keys(pattern='chat-*')
roomlist = []
for i in roomlist_tmp:
i_str = str(i, encoding='utf-8')
istr_list = i_str.split('-', 1)
roomlist.append(istr_list[1])
return render_template('chatroomlist.html', roomlist=roomlist)
```
> 比较简单，到 Redis 中拿到所有以“chat-”开头的 key 值，然后处理成列表返回到前端即可。
前台页面代码：
```
{% extends "bootstrap/base.html" %}
{% import "bootstrap/wtf.html" as wtf %}
{% block title %}Flasky{% endblock %}
{% block navbar %}
{% if current_user.is_authenticated %}
-
Logout
{% else %}
-
Login
{% endif %}
{% endblock %}
{% block content %}
{% endblock %}
```
> 就是循环渲染列表数据，和一个创建聊天室的表单。
#### 二、退出操作
当用户退出登陆时，我们当前也希望该用户同时退出聊天室，所以修改 logout 函数如下：
```
@app.route('/logout')
@login_required
def logout():
rname = request.args.get("rname", "")
r.zrem("chat-" + rname, current_user.username)
logout_user()
return redirect(url_for('login'))
```
> 从前端拿到聊天室的名字，并在 Redis 的对应 zset 中删除当前用户。
#### 三、用户头像
为了聊天室的美观，不同用户需要拥有不同的头像，这里还是使用 gravatar 这个免费的头像服务。 在 User 模型中添加代码：
```
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, index=True)
password = db.Column(db.String(64))
avatar_hash = db.Column(db.String(32))
def gravatar(self, name=None, size=100, default='identicon', rating='g'):
if request.is_secure:
url = 'https://secure.gravatar.com/avatar'
else:
url = 'http://www.gravatar.com/avatar'
if name is not None:
email = name + "@hihichat.com"
else:
email = self.username + "@hihichat.com"
myhash = self.avatar_hash or hashlib.md5(email.encode('utf-8')).hexdigest()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(url=url, hash=myhash, size=size,
default=default, rating=rating)
```
> gravatar 函数，对于登陆的用户，使用其注册的邮箱来生成头像，对于未登录用户，这里就使用一个固定的邮箱来处理。
### 消息推送逻辑
下面就开始编写最主要的消息推送逻辑。 我采用的技术是 WebSocket，这样节省了使用 AJAX 轮询带来的额外开销。而且 flask 框架也有很好的 WebSocket 相关的扩展库供我们使用，即 flask-sokcetio。
首先安装好 flask_socketio 模块，然后引入并初始化
```
from flask_socketio import SocketIO, emit
socketio = SocketIO()
app = Flask(__name__)
socketio.init_app(app)
```
编写一个 socket 发送消息的函数
```
def socket_send(data, user):
emit("response", {"code": '200', "msg": data, "username": user}, broadcast=True, namespace='/testnamespace')
socketio.on_event('request_for_response', socket_send, namespace='/testnamespace')
```
> 其中 request_for_response，response 和 testnamespace 都需要和前端代码相对应。request_for_response 是用来接收前端传递到后端的消息，response 是后端传递消息到前端时的标识，而 namespace 则类似于作用域的概念，相互传递的消息都仅仅作用在 testnamespace 这个 namespace 中。
前端 JavaScript 代码：
```
//websocket
var websocket_url = 'ws://' + document.domain + ':' + location.port + '/testnamespace';
var socket = io.connect(websocket_url);
//发送消息到后端
socket.emit('request_for_response',{'param':'{{rname}}'});
//监听回复的消息
socket.on('response',function(data){
var myDate = new Date();
var myTime = myDate.toLocaleString();
var msg = data.msg;
var username = data.username;
var currentuser = '{{ current_user.username }}';
console.log(currentuser);
if ( currentuser == username )
{
username = '你';
};
var hash = md5(username + "@hihichat.com");
var htmlData2 =
'
'
+ '
'
+ '
'
+ '
' + msg + '
'
+ '
' + username + ' · ' + myTime +'
'
+ '
'
+ '
{% if current_user.is_authenticated %}
-
Logout
{% else %}
-
Login
{% endif %}
{% endblock %}
{% block content %}
{{ wtf.quick_form(form) }}
{% endblock %}
```
至此，一个简单的新增用户功能就好了。当然，我们还可以增加删除用户，重置密码等功能，这些的具体实现，都可以在 GitHub 的代码中看到，就不再赘述了。
#### 2. 权限控制
我们其实并不希望所有人都能够创建聊天室，那么就要做一个简单的控制功能。 首先定义一个 permission 表，用来存储创建聊天室等权限，再定义一个用户和权限的关联关系表
```
class Permission(db.Model):
id = db.Column(db.Integer, primary_key=True)
permission_name = db.Column(db.String(64), unique=True, index=True)
class RelUserPermission(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer)
permission_id = db.Column(db.Integer)
```
然后我们还需要一个增加权限的表，以及一个用户列表页面 在 forms.py 中添加
```
class EditUserForm(FlaskForm):
permission = SelectMultipleField('Permission', coerce=int)
submit = SubmitField('Submit')
def __init__(self, user, *args, **kwargs):
super(EditUserForm, self).__init__(*args, **kwargs)
self.permission.choices = [(per.id, per.permission_name)
for per in Permission.query.order_by(Permission.permission_name).all()]
self.user = user
```
> 定义了一个初始化函数，会获取到 Permission 表中的 name，id 等信息
接下来编写视图函数
```
@main.route('/listuser/', methods=['GET', 'POST'])
@login_required
def listuser():
user_list = User.query.all()
return render_template('listuser.html', user_list=user_list)
@main.route('/addper/', methods=['GET', 'POST'])
@login_required
def addper():
form = CreatePerForm()
if form.validate_on_submit():
per = Permission(permission_name=form.permissionname.data)
db.session.add(per)
db.session.commit()
return redirect(url_for('main.index'))
return render_template('addper.html', form=form)
@main.route('/edituser/
/', methods=['GET', 'POST'])
@login_required
def edituser(id):
user = User.query.filter_by(id=id).first()
form = EditUserForm(user=user)
if form.validate_on_submit():
for p in form.permission.data:
rup = RelUserPermission(user_id=id, permission_id=p)
db.session.add(rup)
db.session.commit()
return redirect(url_for('main.index'))
return render_template('edituser.html', form=form)
```
> 三个函数，分别是展示用户列表，增加权限，以及为用户添加权限。
然后再修改下 chat_room_list 函数，使得没有权限的用户不能展示创建聊天室的表单。
```
@main.route('/roomlist/', methods=["GET", 'POST'])
@login_required
def chat_room_list():
roomlist_tmp = r.keys(pattern='chat-*')
roomlist = []
can_create = False
create_room_id = Permission.query.filter_by(permission_name='createroom').first().id
rel_user_id = RelUserPermission.query.filter_by(user_id=current_user.id).first()
rel_permission = RelUserPermission.query.filter_by(user_id=current_user.id).first()
if rel_permission and rel_user_id and create_room_id:
rel_permission_id = rel_permission.permission_id
if rel_permission_id == create_room_id:
can_create = True
for i in roomlist_tmp:
i_str = str(i)
istr_list = i_str.split('-', 1)
roomlist.append(istr_list[1])
return render_template('chatroomlist.html', roomlist=roomlist, can_create=can_create)
```
> 这里主要是判断用户是否拥有 createroom 权限，其实还有一种更加简便，但是稍微有些绕的鉴权方式，可以在文末的链接中找到，大家也可以尝试下。
最后处理 HTML 表单
对于聊天室列表页面：
```
{% if can_create %}
{% endif %}
```
对于用户列表页面：
```
{% extends "bootstrap/base.html" %}
{% import "bootstrap/wtf.html" as wtf %}
{% block title %}Flasky{% endblock %}
{% block navbar %}
{% if current_user.is_authenticated %}
-
Logout
{% else %}
-
Login
{% endif %}
{% endblock %}
{% block content %}
{% endblock %}
```
> 这里为了方便起见，当点击用户时，就会跳转至编辑用户权限的页面。
现在，没有权限的用户，就不能看到创建聊天室的表单喽！
#### 3. 登陆优化
当前的登陆，只要用户名是正确的，不会验证密码，直接登陆成功，现在来处理下密码校验功能。其实也简单，我们在 User 模型中新增了一个函数 verify_password，只要登陆的时候，调用该函数来验证密码即可。
```
@main.route('/login/', methods=['GET', 'POST'])
def login():
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user)
return redirect(url_for('main.index'))
return render_template('login.html', form=form)
```
ok，密码错误的你，已经没法再登陆了。
#### 4. 放开非登陆也可进入聊天室
1.去掉 chat_room_list，join_chat_room，send_chat 和 chat 视图函数的登陆装饰器 @login_required 2.修改 chat_room_list，判断当前用户是否已经登陆
```
@main.route('/roomlist/', methods=["GET", 'POST'])
def chat_room_list():
roomlist_tmp = r.keys(pattern='chat-*')
roomlist = []
can_create = False
create_room = Permission.query.filter_by(permission_name='createroom').first()
if current_user.is_authenticated: # 判断用户是否登陆
rel_user_id = RelUserPermission.query.filter_by(user_id=current_user.id).first()
rel_permission = RelUserPermission.query.filter_by(user_id=current_user.id).first()
if rel_permission and rel_user_id and create_room:
rel_permission_id = rel_permission.permission_id
create_room_id = create_room.id
if rel_permission_id == create_room_id:
can_create = True
for i in roomlist_tmp:
i_str = str(i)
istr_list = i_str.split('-', 1)
roomlist.append(istr_list[1])
return render_template('chatroomlist.html', roomlist=roomlist, can_create=can_create)
```
3.导航栏增加 room list 入口
```
```
4.chat 视图函数增加判断逻辑
```
@main.route('/chat/', methods=['GET', 'POST'])
def chat():
rname = request.args.get('rname', "")
ulist = r.zrange("chat-" + rname, 0, -1)
messages = r.zrange("msg-" + rname, 0, -1, withscores=True)
msg_list = []
for i in messages:
msg_list.append([json.loads(i[0]), time.strftime("%Y/%m/%d %p%H:%M:%S", time.localtime(i[1]))])
if current_user.is_authenticated:
return render_template('chat.html', rname=rname, user_list=ulist, msg_list=msg_list)
else:
email = "youke" + "@hihichat.com"
hash = hashlib.md5(email.encode('utf-8')).hexdigest()
gravatar_url = 'http://www.gravatar.com/avatar/' + hash + '?s=40&d=identicon&r=g'
return render_template('chat.html', rname=rname, user_list=ulist,
msg_list=msg_list, g=gravatar_url)
```
5.修改 send_chat 视图
```
@main.route('/api/sendchat/
', methods=['GET', 'POST'])
def send_chat(info):
if current_user.is_authenticated:
rname = request.form.get("rname", "")
body = {"username": current_user.username, "msg": info}
r.zadd("msg-" + rname, json.dumps(body), time.time())
socket_send(info, current_user.username)
return info
else:
return info
```
> 当前对于未登陆的用户（游客），直接回复游客发送的消息。
### 清理过期消息
由于我们需要定时清理 Redis 中保存的聊天记录，那么就需要一个定时任务。flask 有一个完善的插件 flask-apscheduler，但是简单实验了下，限制还是挺多的，所以，我这里选择自己实现一个简单的定时器功能。 创建一个 tasks.py 文件 首先定义定时器类
```
from threading import Timer
class Scheduler(object):
def __init__(self, sleep_time, func, mytime=None):
self.sleep_time = sleep_time
self.func = func
self._t = None
self.mytime = mytime
def start(self):
if self._t is None:
self._t = Timer(self.sleep_time, self._run)
self._t.start()
else:
raise Exception("this timer is already running")
def _run(self):
if self.mytime is not None:
self.func(self.mytime)
else:
self.func()
self._t = Timer(self.sleep_time, self._run)
self._t.start()
def stop(self):
if self._t is not None:
self._t.cancel()
self._t = None
@staticmethod
def init_app(app):
pass
```
> 使用线程中的 Timer 来调用真正的函数，通过 sleep time 的方式达到定时调用的效果。
然后编写需要定时调用的函数，即清理数据的函数。
```
def keep_msg(mytime=None):
if mytime is not None:
expare_time = mytime
else:
expare_time = 604800
msg_list = r.keys("msg-*")
for msg in msg_list:
_ = r.zrange(msg, 0, 0)
for i in _:
score = r.zscore(msg, i)
if time.time() - score > expare_time:
r.zrem(msg, i)
```
> 比较简单，判断 Redis 中的 score 是否处于过期时间，是，则删除。
接下来注册函数到我们的 flask 应用当中。 在 _*init*_.py 中填入如下代码：
```
from .tasks import Scheduler, keep_msg
sch = Scheduler(86400, keep_msg) # 每间隔一天执行
def create_app(config_name):
...
sch.init_app(app)
...
return app
```
最后还要注意的是，由于我们前面是使用 socketio 来启动的应用，因为 socketio 是异步 io，而我们的 scheduler 是阻塞运行的，所以需要在 socketio 中创建子线程来启动。 修改 manage.py 如下：
```
import os
from app import create_app, socketio, sch
app = create_app(os.getenv('FLASK_CONFIG') or 'default')
if __name__ == '__main__':
my = sch.start
socketio.start_background_task(target=my) # 启动一个子线程
socketio.run(app, debug=True)
```
这样，一个简单的定时任务就做好了。
### 禁言功能
正所谓“林子大了，什么鸟都有”，当聊天室人数很多的时候，经常会出现一些不和谐的话语和人，那么禁言功能就很有必要了。
首先在 views 中创建一个新的函数
```
@main.route('/chat/block/roomuser/', methods=['GET', 'POST'])
@login_required
def block_roomuser():
rname = request.args.get('rname', "")
new_b_user = request.args.get('b_user', "")
b_time = request.args.get('b_time', "")
if b_time is "":
r.set('b_user-' + new_b_user, new_b_user, ex=None)
else:
r.set('b_user-' + new_b_user, new_b_user, ex=b_time)
return redirect(url_for('main.room_user_list', rname=rname))
```
> 从前端获取到对应的聊天室名字、需要禁言的用户和禁言时间，然后根据禁言时间，把用户添加到 Redis 中。
再来看看禁言功能的入口函数
```
@main.route('/chat/roomuser/list', methods=['GET', 'POST'])
@login_required
def room_user_list():
rname = request.args.get('rname', "")
ulist = r.zrange("chat-" + rname, 0, -1)
b_user = r.keys('b_user-*')
b_user_list = []
for b in b_user:
b_user_list.append(r.get(b))
return render_template('roomuser_list.html', ulist=ulist, rname=rname, b_user=b_user_list)
```
> 从 Redis 对应的有序集合中取出正处于禁言状态的用户，把这些用户传递到模板供渲染使用。
对应的 roomuser_list.html 代码为：
```
{% for user in ulist %}
{% if user in b_user %}
禁言中。。。
{% endif %}
解禁
踢出
{% endfor %}
'
+ '
'
+ '
'
+ '
' + "自动回复: " + jsondata.msg + '
'
+ '
' + '小黄鸭' + ' · ' + myTime +'
'
+ '
'
+ '
参考文献
- 网上论坛系统设计与实现（西安电子科技大学·胡秉玺）
- 手机软酷网即时通讯软件的设计与实现（电子科技大学·齐迎旭）
- 企业内部即时通讯系统的设计与实现（内蒙古大学·王慧平）
- 基于移动平台的SNS系统的设计与实现（电子科技大学·高原）
- 一个通用论坛系统的设计与实现（山东大学·张正）
- 基于Web的在线交流平台的开发技术研究与应用（燕山大学·卢仕伟）
- 基于Hadoop的分布式数据存储设计与实现（吉林大学·毛剑）
- 基于Web的信息发布与信息交流平台的设计与实现（吉林大学·许昭霞）
- 企业级即时通讯系统设计与实现（华南理工大学·余春贵）
- 一个通用论坛系统的设计与实现（山东大学·张正）
- 基于B/S架构的酷跑社区系统的设计与实现（内蒙古大学·张晓乐）
- 基于Web的企业即时通讯系统的设计与实现（河北科技大学·张艳芳）
- 基于Web的在线交流平台的开发技术研究与应用（燕山大学·卢仕伟）
- 基于SSH的大学生联谊交友管理系统设计与实现（华中科技大学·王海波）
- 基于redis的分布式自动化爬虫的设计与实现（华中科技大学·曾胜）
本文内容包括但不限于文字、数据、图表及超链接等）均来源于该信息及资料的相关主题。发布者：源码港湾
，原文地址：https://bishedaima.com/yuanma/35929.html
}}){kind=small}
}}){kind=small}
}})
'
+ '
