399-群组业务代码

Bertha 。 2022-09-03 13:12 149阅读 0赞

**群组业务包含：管理员创建群，组员加入群，群聊**  
**群组里面包含组员，一个组员可以在多个群组，一个群组可以有多个组员**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70]  
**分为管理员，普通成员**

## 群组业务代码 ##

**我们在include下的server下的model下创建文件：group.hpp**

#ifndef GROUP_H
    #define GROUP_H
    
    #include "groupuser.hpp"
    #include <string>
    #include <vector>
    using namespace std;
    
    //User表的ORM类
    class Group
    {
        
    public:
        Group(int id = -1, string name = "", string desc = "")
        {
        
            this->id = id;
            this->name = name;
            this->desc = desc;
        }
    
        void setId(int id) {
         this->id = id; }
        void setName(string name) {
         this->name = name; }
        void setDesc(string desc) {
         this->desc = desc; }
    
        int getId() {
         return this->id; }
        string getName() {
         return this->name; }
        string getDesc() {
         return this->desc; }
        vector<GroupUser> &getUsers() {
         return this->users; }
    
    private:
        int id;
        string name;
        string desc;//组的功能描述
        vector<GroupUser> users;//组的成员 
    };
    
    #endif

**我们在include下的server下的model下创建文件：groupuser.hpp**

#ifndef GROUPUSER_H
    #define GROUPUSER_H
    
    #include "user.hpp"
    
    //群组用户，多了一个role角色信息（创建者还是成员），从User类直接继承，复用User的其它信息
    class GroupUser : public User
    {
        
    public:
        void setRole(string role) {
         this->role = role; }
        string getRole() {
         return this->role; }
    
    private:
        string role;
    };
    
    #endif

**我们在include下的server下的model下创建文件：groupmodel.hpp**

#ifndef GROUPMODEL_H
    #define GROUPMODEL_H
    
    #include "group.hpp"
    #include <string>
    #include <vector>
    using namespace std;
    
    //维护群组信息的操作接口方法
    class GroupModel
    {
        
    public:
        //创建群组
        bool createGroup(Group &group);
        //加入群组
        void addGroup(int userid, int groupid, string role);
        //查询用户所在群组信息  在客户端呈现 
        vector<Group> queryGroups(int userid);
        //群聊。根据指定的groupid查询群组用户id列表，除userid自己，主要用户群聊业务给群组其它成员群发消息
        vector<int> queryGroupUsers(int userid, int groupid);
    };
    
    #endif

**我们在src下的server下的model下创建文件：groupmodel.cpp**

#include "groupmodel.hpp"
    #include "db.hpp"
    
    //创建群组
    bool GroupModel::createGroup(Group &group)
    {
        
        // 1.组装sql语句
        char sql[1024] = {
        0};
        sprintf(sql, "insert into allgroup(groupname, groupdesc) values('%s', '%s')",
                group.getName().c_str(), group.getDesc().c_str());
    
        MySQL mysql;
        if (mysql.connect())
        {
        
            if (mysql.update(sql))
            {
        
                group.setId(mysql_insert_id(mysql.getConnection()));
                return true;
            }
        }
    
        return false;
    }
    
    //加入群组
    void GroupModel::addGroup(int userid, int groupid, string role)
    {
        
        // 1.组装sql语句
        char sql[1024] = {
        0};
        sprintf(sql, "insert into groupuser values(%d, %d, '%s')",
                groupid, userid, role.c_str());
    
        MySQL mysql;
        if (mysql.connect())
        {
        
            mysql.update(sql);
        }
    }
    
    //查询用户所在群组信息
    vector<Group> GroupModel::queryGroups(int userid)
    {
        
        /*
        1. 先根据userid在groupuser表中查询出该用户所属的群组信息
        2. 在根据群组信息，查询属于该群组的所有用户的userid，并且和user表进行多表联合查询，查出用户的详细信息
        */
        char sql[1024] = {
        0};
        sprintf(sql, "select a.id,a.groupname,a.groupdesc from allgroup a inner join \
             groupuser b on a.id = b.groupid where b.userid=%d",
                userid);
        //把指定用户的所在的群组信息全部描述出来
    	 
        vector<Group> groupVec;
    
        MySQL mysql;
        if (mysql.connect())
        {
        
            MYSQL_RES *res = mysql.query(sql);
            if (res != nullptr)
            {
        
                MYSQL_ROW row;
                //查出userid所有的群组的信息
                while ((row = mysql_fetch_row(res)) != nullptr)
                {
        
                    Group group;
                    group.setId(atoi(row[0]));
                    group.setName(row[1]);
                    group.setDesc(row[2]);
                    groupVec.push_back(group);
                }
                mysql_free_result(res);
            }
        }
    
        //查询群组的用户信息
        for (Group &group : groupVec)
        {
        
            sprintf(sql, "select a.id,a.name,a.state,b.grouprole from user a \
                inner join groupuser b on b.userid = a.id where b.groupid=%d",
                    group.getId());
    
            MYSQL_RES *res = mysql.query(sql);
            if (res != nullptr)
            {
        
                MYSQL_ROW row;
                while ((row = mysql_fetch_row(res)) != nullptr)
                {
        
                    GroupUser user;
                    user.setId(atoi(row[0]));
                    user.setName(row[1]);
                    user.setState(row[2]);
                    user.setRole(row[3]);
                    group.getUsers().push_back(user);
                }
                mysql_free_result(res);
            }
        }
        return groupVec;//这个东西存着用户的所有群组和所有群组里的用户信息 
    }
    
    //根据指定的groupid查询群组用户id列表，除userid自己，主要用户群聊业务给群组其它成员群发消息
    vector<int> GroupModel::queryGroupUsers(int userid, int groupid)
    {
        
        char sql[1024] = {
        0};
        sprintf(sql, "select userid from groupuser where groupid = %d and userid != %d", groupid, userid);
    
        vector<int> idVec;
        MySQL mysql;
        if (mysql.connect())
        {
        
            MYSQL_RES *res = mysql.query(sql);
            if (res != nullptr)
            {
        
                MYSQL_ROW row;
                while ((row = mysql_fetch_row(res)) != nullptr)
                {
        
                    idVec.push_back(atoi(row[0]));
                }
                mysql_free_result(res);
            }
        }
        return idVec;
    }

**我们完善public.hpp**

#ifndef PUBLIC_H
    #define PUBLIC_H
    
    /*
    server和client的公共文件
    */
    enum EnMsgType
    {
        
        LOGIN_MSG = 1,//登录消息
        LOGIN_MSG_ACK,//登录响应消息
        REG_MSG,//注册消息
        REG_MSG_ACK,//注册响应消息
        ONE_CHAT_MSG,//聊天消息
        ADD_FRIEND_MSG,//添加好友消息
    
        CREATE_GROUP_MSG,//创建群组
        ADD_GROUP_MSG,//加入群组
        GROUP_CHAT_MSG,//群聊天
    };
    
    #endif

**我们完善chatservice.hpp**  
新增代码

#include "groupmodel.hpp"
    //创建群组业务
    void createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time);
    //加入群组业务
    void addGroup(const TcpConnectionPtr &conn, json &js, Timestamp time);
    //群组聊天业务
    void groupChat(const TcpConnectionPtr &conn, json &js, Timestamp time);
    
    GroupModel _groupModel;

完整代码

#ifndef CHATSERVICE_H
    #define CHATSERVICE_H
    
    #include <muduo/net/TcpConnection.h>
    #include <unordered_map>//一个消息ID映射一个事件处理 
    #include <functional>
    #include <mutex>
    using namespace std;
    using namespace muduo;
    using namespace muduo::net;
    
    #include "usermodel.hpp"
    #include "offlinemessagemodel.hpp"
    #include "friendmodel.hpp"
    #include "groupmodel.hpp"
    #include "json.hpp"
    using json = nlohmann::json;
    
    //表示处理消息的事件回调方法类型，事件处理器，派发3个东西 
    using MsgHandler = std::function<void(const TcpConnectionPtr &conn, json &js, Timestamp)>;
    
    //聊天服务器业务类
    class ChatService
    {
        
    public:
        //获取单例对象的接口函数
        static ChatService *instance();
        //处理登录业务
        void login(const TcpConnectionPtr &conn, json &js, Timestamp time);
        //处理注册业务
        void reg(const TcpConnectionPtr &conn, json &js, Timestamp time);
        //一对一聊天业务
        void oneChat(const TcpConnectionPtr &conn, json &js, Timestamp time);
        //添加好友业务
        void addFriend(const TcpConnectionPtr &conn, json &js, Timestamp time);
        //创建群组业务
        void createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time);
        //加入群组业务
        void addGroup(const TcpConnectionPtr &conn, json &js, Timestamp time);
        //群组聊天业务
        void groupChat(const TcpConnectionPtr &conn, json &js, Timestamp time);
        //处理客户端异常退出
        void clientCloseException(const TcpConnectionPtr &conn);
        //服务器异常，业务重置方法
        void reset();
        //获取消息对应的处理器
        MsgHandler getHandler(int msgid);
    private:
        ChatService();//单例 
    
        //存储消息id和其对应的业务处理方法，消息处理器的一个表，写消息id对应的处理操作 
        unordered_map<int, MsgHandler> _msgHandlerMap;
        //存储在线用户的通信连接，用户的id， TcpConnectionPtr
        unordered_map<int, TcpConnectionPtr> _userConnMap;
        //定义互斥锁，保证_userConnMap的线程安全
        mutex _connMutex;
        //数据操作类对象
        UserModel _userModel;
        OfflineMsgModel _offlineMsgModel;   
        FriendModel _friendModel;
        GroupModel _groupModel;
        
    };
    
    #endif

**我们完善chatservice.cpp**  
新增代码

//群组业务管理相关事件处理回调注册
    _msgHandlerMap.insert({
        CREATE_GROUP_MSG, std::bind(&ChatService::createGroup, this, _1, _2, _3)});
    _msgHandlerMap.insert({
        ADD_GROUP_MSG, std::bind(&ChatService::addGroup, this, _1, _2, _3)});
    _msgHandlerMap.insert({
        GROUP_CHAT_MSG, std::bind(&ChatService::groupChat, this, _1, _2, _3)});
    //创建群组业务
    void ChatService::createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int userid = js["id"].get<int>();//创建群的用户的id 
        string name = js["groupname"];
        string desc = js["groupdesc"];
    
        //存储新创建的群组信息
        Group group(-1, name, desc);
        if (_groupModel.createGroup(group))
        {
        
            //存储群组创建人信息
            _groupModel.addGroup(userid, group.getId(), "creator");
        }
    }
    //加入群组业务
    void ChatService::addGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int userid = js["id"].get<int>();
        int groupid = js["groupid"].get<int>();
        _groupModel.addGroup(userid, groupid, "normal");
    }
    //群组聊天业务
    void ChatService::groupChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int userid = js["id"].get<int>();
        int groupid = js["groupid"].get<int>();
        vector<int> useridVec = _groupModel.queryGroupUsers(userid, groupid);//查询这个用户所在群组的其他用户id 
    
        lock_guard<mutex> lock(_connMutex);//不允许其他人在map里面增删改查 
        for (int id : useridVec)
        {
        
            auto it = _userConnMap.find(id);
            if (it != _userConnMap.end())//证明在线，直接转发 
            {
        
                //转发群消息
                it->second->send(js.dump());
            }
            else//离线 
            {
        
                //存储离线群消息
                _offlineMsgModel.insert(id, js.dump());
            }
        }
    }
    
    //处理登录业务  id  pwd   检测pwd
    void ChatService::login(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int id = js["id"].get<int>();//获取id号 
        string pwd = js["password"];//获取密码 
    
        User user = _userModel.query(id);//查找 
        if (user.getId() == id && user.getPwd() == pwd)//查出来了，登录成功 
        {
        
            if (user.getState() == "online")
    		//该用户已经登录，不允许重复登录
            {
        
                json response;
                response["msgid"] = LOGIN_MSG_ACK;
                response["errno"] = 2;
                response["errmsg"] = "this account is using, input another!";
                conn->send(response.dump());
            }
            else
            {
        
                //登录成功，记录用户连接信息，要考虑线程安全，因为多线程访问 
                {
        
                    lock_guard<mutex> lock(_connMutex);
                    _userConnMap.insert({
        id, conn});
                }//加个作用域，出了这个右括号就自动解锁
                
                //登录成功，更新用户状态信息 state offline=>online
                user.setState("online");
                _userModel.updateState(user);
    
                json response;
                response["msgid"] = LOGIN_MSG_ACK;
                response["errno"] = 0;
                response["id"] = user.getId();
                response["name"] = user.getName();
                //查询该用户是否有离线消息
                vector<string> vec = _offlineMsgModel.query(id);//查当用户id 
                if (!vec.empty())//不为空 
                {
        
                    response["offlinemsg"] = vec;//json库可以和容器之间序列化和反序列化 
                    //读取该用户的离线消息后，把该用户的所有离线消息删除掉
                    _offlineMsgModel.remove(id);
                }
                //查询该用户的好友信息并返回
                vector<User> userVec = _friendModel.query(id);
                if (!userVec.empty())
                {
        
                    vector<string> vec2;
                    for (User &user : userVec)
                    {
        
                        json js;
                        js["id"] = user.getId();
                        js["name"] = user.getName();
                        js["state"] = user.getState();
                        vec2.push_back(js.dump());
                    }
                    response["friends"] = vec2;
                }
                //查询用户的群组信息
                vector<Group> groupuserVec = _groupModel.queryGroups(id);
                if (!groupuserVec.empty())
                {
        
                    //group:[{groupid:[xxx, xxx, xxx, xxx]}]
                    vector<string> groupV;
                    for (Group &group : groupuserVec)
                    {
        
                        json grpjson;
                        grpjson["id"] = group.getId();
                        grpjson["groupname"] = group.getName();
                        grpjson["groupdesc"] = group.getDesc();
                        vector<string> userV;
                        for (GroupUser &user : group.getUsers())
                        {
        
                            json js;
                            js["id"] = user.getId();
                            js["name"] = user.getName();
                            js["state"] = user.getState();
                            js["role"] = user.getRole();
                            userV.push_back(js.dump());
                        }
                        grpjson["users"] = userV;
                        groupV.push_back(grpjson.dump());
                    }
                    response["groups"] = groupV;
                }
                conn->send(response.dump());            
            }
        }
        else
        {
        
            //该用户不存在，用户存在但是密码错误，登录失败
            json response;
            response["msgid"] = LOGIN_MSG_ACK;
            response["errno"] = 1;
            response["errmsg"] = "id or password is invalid!";
            conn->send(response.dump());
        }
    }

完整代码

#include "chatservice.hpp"
    #include "public.hpp"
    #include <muduo/base/Logging.h>//muduo的日志 
    #include <vector>
    using namespace std;
    using namespace muduo;
    
    //获取单例对象的接口函数
    ChatService *ChatService::instance()
    {
        
        static ChatService service;
        return &service;
    }
    
    //构造方法，注册消息以及对应的Handler回调操作
    ChatService::ChatService()
    {
        
        //用户基本业务管理相关事件处理回调注册
        _msgHandlerMap.insert({
        LOGIN_MSG, std::bind(&ChatService::login, this, _1, _2, _3)});
        _msgHandlerMap.insert({
        REG_MSG, std::bind(&ChatService::reg, this, _1, _2, _3)});
        _msgHandlerMap.insert({
        ONE_CHAT_MSG, std::bind(&ChatService::oneChat, this, _1, _2, _3)});   
        _msgHandlerMap.insert({
        ADD_FRIEND_MSG, std::bind(&ChatService::addFriend, this, _1, _2, _3)});
    
        //群组业务管理相关事件处理回调注册
        _msgHandlerMap.insert({
        CREATE_GROUP_MSG, std::bind(&ChatService::createGroup, this, _1, _2, _3)});
        _msgHandlerMap.insert({
        ADD_GROUP_MSG, std::bind(&ChatService::addGroup, this, _1, _2, _3)});
        _msgHandlerMap.insert({
        GROUP_CHAT_MSG, std::bind(&ChatService::groupChat, this, _1, _2, _3)});
    
    }
    
    //服务器异常，业务重置方法
    void ChatService::reset()
    {
        
        //把online状态的用户，设置成offline
        _userModel.resetState();
    }
    
    //获取消息对应的处理器
    MsgHandler ChatService::getHandler(int msgid)
    {
        
        //记录错误日志，msgid没有对应的事件处理回调
        auto it = _msgHandlerMap.find(msgid);
        if (it == _msgHandlerMap.end())//找不到 
        {
        
            //返回一个默认的处理器，空操作，=按值获取 
            return [=](const TcpConnectionPtr &conn, json &js, Timestamp) {
        
                LOG_ERROR << "msgid:" << msgid << " can not find handler!";//muduo日志会自动输出endl 
            };
        }
        else//成功的话 
        {
        
            return _msgHandlerMap[msgid];//返回这个处理器 
        }
    }
    
    //处理登录业务  id  pwd   检测pwd
    void ChatService::login(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int id = js["id"].get<int>();//获取id号 
        string pwd = js["password"];//获取密码 
    
        User user = _userModel.query(id);//查找 
        if (user.getId() == id && user.getPwd() == pwd)//查出来了，登录成功 
        {
        
            if (user.getState() == "online")
    		//该用户已经登录，不允许重复登录
            {
        
                json response;
                response["msgid"] = LOGIN_MSG_ACK;
                response["errno"] = 2;
                response["errmsg"] = "this account is using, input another!";
                conn->send(response.dump());
            }
            else
            {
        
                //登录成功，记录用户连接信息，要考虑线程安全，因为多线程访问 
                {
        
                    lock_guard<mutex> lock(_connMutex);
                    _userConnMap.insert({
        id, conn});
                }//加个作用域，出了这个右括号就自动解锁
                
                //登录成功，更新用户状态信息 state offline=>online
                user.setState("online");
                _userModel.updateState(user);
    
                json response;
                response["msgid"] = LOGIN_MSG_ACK;
                response["errno"] = 0;
                response["id"] = user.getId();
                response["name"] = user.getName();
                //查询该用户是否有离线消息
                vector<string> vec = _offlineMsgModel.query(id);//查当用户id 
                if (!vec.empty())//不为空 
                {
        
                    response["offlinemsg"] = vec;//json库可以和容器之间序列化和反序列化 
                    //读取该用户的离线消息后，把该用户的所有离线消息删除掉
                    _offlineMsgModel.remove(id);
                }
                //查询该用户的好友信息并返回
                vector<User> userVec = _friendModel.query(id);
                if (!userVec.empty())
                {
        
                    vector<string> vec2;
                    for (User &user : userVec)
                    {
        
                        json js;
                        js["id"] = user.getId();
                        js["name"] = user.getName();
                        js["state"] = user.getState();
                        vec2.push_back(js.dump());
                    }
                    response["friends"] = vec2;
                }
                //查询用户的群组信息
                vector<Group> groupuserVec = _groupModel.queryGroups(id);
                if (!groupuserVec.empty())
                {
        
                    //group:[{groupid:[xxx, xxx, xxx, xxx]}]
                    vector<string> groupV;
                    for (Group &group : groupuserVec)
                    {
        
                        json grpjson;
                        grpjson["id"] = group.getId();
                        grpjson["groupname"] = group.getName();
                        grpjson["groupdesc"] = group.getDesc();
                        vector<string> userV;
                        for (GroupUser &user : group.getUsers())
                        {
        
                            json js;
                            js["id"] = user.getId();
                            js["name"] = user.getName();
                            js["state"] = user.getState();
                            js["role"] = user.getRole();
                            userV.push_back(js.dump());
                        }
                        grpjson["users"] = userV;
                        groupV.push_back(grpjson.dump());
                    }
                    response["groups"] = groupV;
                }
                conn->send(response.dump());            
            }
        }
        else
        {
        
            //该用户不存在，用户存在但是密码错误，登录失败
            json response;
            response["msgid"] = LOGIN_MSG_ACK;
            response["errno"] = 1;
            response["errmsg"] = "id or password is invalid!";
            conn->send(response.dump());
        }
    }
    
    //处理注册业务  name  password
    void ChatService::reg(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        string name = js["name"];//获取名字 
        string pwd = js["password"];//获取密码 
    
        User user;//创建用户对象 
        user.setName(name);
        user.setPwd(pwd);
        bool state = _userModel.insert(user);//新用户的插入 
        if (state)//插入成功 
        {
        
            //注册成功
            json response;
            response["msgid"] = REG_MSG_ACK;
            response["errno"] = 0;
            response["id"] = user.getId();
            conn->send(response.dump());//回调 ，返回json字符串 
        }
        else//插入失败 
        {
        
            //注册失败
            json response;
            response["msgid"] = REG_MSG_ACK;
            response["errno"] = 1;
            conn->send(response.dump());//回调 ，返回json字符串 
        }
    }
    
    //处理客户端异常退出
    void ChatService::clientCloseException(const TcpConnectionPtr &conn)
    {
        
        User user;
        {
        
            lock_guard<mutex> lock(_connMutex);
            for (auto it = _userConnMap.begin(); it != _userConnMap.end(); ++it)//用迭代器 
            {
        
                if (it->second == conn)
                {
        
                    //从map表删除用户的链接信息
                    user.setId(it->first);
                    _userConnMap.erase(it);
                    break;
                }
            }
        }
        //更新用户的状态信息
        if (user.getId() != -1)
        {
        
            user.setState("offline");
            _userModel.updateState(user);
        }
    }
    
    //一对一聊天业务
    void ChatService::oneChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int toid = js["toid"].get<int>();//获取对方的id号 
    
        {
        
            lock_guard<mutex> lock(_connMutex);//访问连接信息表，要保证线程安全 
            auto it = _userConnMap.find(toid);//查找对方id号 
            if (it != _userConnMap.end())//找到了 
            {
        
                //toid在线，转发消息  服务器主动推送消息给toid用户
                it->second->send(js.dump());
                return;
            }
        }
    
        //toid不在线，存储离线消息
        _offlineMsgModel.insert(toid, js.dump());
    }
    
    //添加好友业务 格式： msgid id friendid
    void ChatService::addFriend(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int userid = js["id"].get<int>();//当前用户的id 
        int friendid = js["friendid"].get<int>();//添加好友的id 
    
        //存储好友信息
        _friendModel.insert(userid, friendid);
    }
    
    //创建群组业务
    void ChatService::createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int userid = js["id"].get<int>();//创建群的用户的id 
        string name = js["groupname"];
        string desc = js["groupdesc"];
    
        //存储新创建的群组信息
        Group group(-1, name, desc);
        if (_groupModel.createGroup(group))
        {
        
            //存储群组创建人信息
            _groupModel.addGroup(userid, group.getId(), "creator");
        }
    }
    //加入群组业务
    void ChatService::addGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int userid = js["id"].get<int>();
        int groupid = js["groupid"].get<int>();
        _groupModel.addGroup(userid, groupid, "normal");
    }
    //群组聊天业务
    void ChatService::groupChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int userid = js["id"].get<int>();
        int groupid = js["groupid"].get<int>();
        vector<int> useridVec = _groupModel.queryGroupUsers(userid, groupid);//查询这个用户所在群组的其他用户id 
    
        lock_guard<mutex> lock(_connMutex);//不允许其他人在map里面增删改查 
        for (int id : useridVec)
        {
        
            auto it = _userConnMap.find(id);
            if (it != _userConnMap.end())//证明在线，直接转发 
            {
        
                //转发群消息
                it->second->send(js.dump());
            }
            else//离线 
            {
        
                //存储离线群消息
                _offlineMsgModel.insert(id, js.dump());
            }
        }
    }

**编译成功。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70]: /images/20220829/7122d81f44e34e62b256ce15c3b574c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 1]: /images/20220829/99f5ff7c90024c02a059d3c5e49ac7bc.png