405-Redis发布订阅消息队列在项目上的代码和项目测试

本是古典何须时尚 2022-09-03 15:12 73阅读 0赞

## redis发布-订阅的客户端编程 ##

redis支持多种不同的客户端编程语言，例如Java对应jedis、php对应phpredis、C++对应的则是hiredis。下面是安装hiredis的步骤：

1. git clone https://github.com/redis/hiredis 从github上下载hiredis客户端，进行源码编译安装

2、`cd hiredis`  
3、`make`  
4、`sudo make install`  
拷贝生成的动态库到/usr/local/lib目录下！  
**5、sudo ldconfig /usr/local/lib**

## Redis发布订阅消息队列在项目上的代码实现 ##

**我们在include下的server下创建文件夹：redis  
我们在include的server的redis下创建文件：redis.hpp**

#ifndef REDIS_H
    #define REDIS_H
    
    #include <hiredis/hiredis.h>
    #include <thread>
    #include <functional>
    using namespace std;
    
    
    class Redis
    {
        
    public:
        Redis();
        ~Redis();
    
        //连接redis服务器 
        bool connect();
    
        //向redis指定的通道channel发布消息
        bool publish(int channel, string message);
    
        //向redis指定的通道subscribe订阅消息
        bool subscribe(int channel);
    
        //向redis指定的通道unsubscribe取消订阅消息
        bool unsubscribe(int channel);
    
        //在独立线程中接收订阅通道中的消息
        void observer_channel_message();
    
        //初始化向业务层上报通道消息的回调对象
        void init_notify_handler(function<void(int, string)> fn);
    
    private:
        //hiredis同步上下文对象，负责publish消息，相当于客户端一个redis-client 
        redisContext *_publish_context;
    
        //hiredis同步上下文对象，负责subscribe消息，相当于客户端一个redis-client ，
    	// _publish和_subcribe不能在一个上下文处理 ,会阻塞 
        redisContext *_subcribe_context;
    
        //回调操作，收到订阅的消息，给service层上报
        function<void(int, string)> _notify_message_handler;
    };
    
    #endif

**我们完善一下项目工程chatserver下的CMakeLists.txt**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70]

**我们在src下的server下创建文件夹：redis  
在src下的server下的redis下创建文件：redis.cpp**

#include "redis.hpp"
    #include <iostream>
    using namespace std;
    
    Redis::Redis() 
        : _publish_context(nullptr), _subcribe_context(nullptr)//两个上下文指针 
    {
        
    }
    
    Redis::~Redis()
    {
        
        if (_publish_context != nullptr)
        {
        
            redisFree(_publish_context);
        }
    
        if (_subcribe_context != nullptr)
        {
        
            redisFree(_subcribe_context);
        }
    }
    
    bool Redis::connect()
    {
        
        //负责publish发布消息的上下文连接
        _publish_context = redisConnect("127.0.0.1", 6379);
        if (nullptr == _publish_context)
        {
        
            cerr << "connect redis failed!" << endl;
            return false;
        }
    
        //负责subscribe订阅消息的上下文连接
        _subcribe_context = redisConnect("127.0.0.1", 6379);
        if (nullptr == _subcribe_context)
        {
        
            cerr << "connect redis failed!" << endl;
            return false;
        }
    
        //在单独的线程中，监听通道上的事件，有消息给业务层进行上报
        thread t([&]() {
        
            observer_channel_message();
        });
        t.detach();
    
        cout << "connect redis-server success!" << endl;
    
        return true;
    }
    
    //向redis指定的通道channel发布消息
    //redisCommand先把命令缓存在本地，然后把命令发送到redis-server，然后阻塞等待命令的执行结果 
    bool Redis::publish(int channel, string message)
    {
        
        redisReply *reply = (redisReply *)redisCommand(_publish_context, "PUBLISH %d %s", channel, message.c_str());
        if (nullptr == reply)
        {
        
            cerr << "publish command failed!" << endl;
            return false;
        }
        freeReplyObject(reply);
        return true;
    }
    
    //向redis指定的通道subscribe订阅消息
    bool Redis::subscribe(int channel)
    {
        
        //SUBSCRIBE命令本身会造成线程阻塞等待通道里面发生消息，这里只做订阅通道，不接收通道消息
        //通道消息的接收专门在observer_channel_message函数中的独立线程中进行
        //只负责发送命令，不阻塞接收redis server响应消息，否则和notifyMsg线程抢占响应资源
        if (REDIS_ERR == redisAppendCommand(this->_subcribe_context, "SUBSCRIBE %d", channel))
        {
        
            cerr << "subscribe command failed!" << endl;
            return false;
        }
        //redisBufferWrite可以循环发送缓冲区，直到缓冲区数据发送完毕（done被置为1）
        int done = 0;
        while (!done)
        {
        
            if (REDIS_ERR == redisBufferWrite(this->_subcribe_context, &done))
            {
        
                cerr << "subscribe command failed!" << endl;
                return false;
            }
        }
        //redisGetReply
    
        return true;
    }
    
    //向redis指定的通道unsubscribe取消订阅消息
    bool Redis::unsubscribe(int channel)
    {
        
        if (REDIS_ERR == redisAppendCommand(this->_subcribe_context, "UNSUBSCRIBE %d", channel))
        {
        
            cerr << "unsubscribe command failed!" << endl;
            return false;
        }
        //redisBufferWrite可以循环发送缓冲区，直到缓冲区数据发送完毕（done被置为1）
        int done = 0;
        while (!done)
        {
        
            if (REDIS_ERR == redisBufferWrite(this->_subcribe_context, &done))
            {
        
                cerr << "unsubscribe command failed!" << endl;
                return false;
            }
        }
        return true;
    }
    
    //在独立线程中接收订阅通道中的消息
    void Redis::observer_channel_message()
    {
        
        redisReply *reply = nullptr;
        while (REDIS_OK == redisGetReply(this->_subcribe_context, (void **)&reply))
        {
        
            //订阅收到的消息是一个带三元素的数组
            if (reply != nullptr && reply->element[2] != nullptr && reply->element[2]->str != nullptr)
            {
        
                //给业务层上报通道上发生的消息
                _notify_message_handler(atoi(reply->element[1]->str) , reply->element[2]->str);
            }
    
            freeReplyObject(reply);
        }
    
        cerr << ">>>>>>>>>>>>> observer_channel_message quit <<<<<<<<<<<<<" << endl;
    }
    
    void Redis::init_notify_handler(function<void(int,string)> fn)
    {
        
        this->_notify_message_handler = fn;
    }

**我们完善src下的server下的CMakeLists.txt**  
![在这里插入图片描述][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 2]

## redis在项目代码中的添加 ##

**我们完善chatservice.hpp**

#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 "redis.hpp"
    #include "groupmodel.hpp"
    #include "usermodel.hpp"
    #include "offlinemessagemodel.hpp"
    #include "friendmodel.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 loginout(const TcpConnectionPtr &conn, json &js, Timestamp time);
        //处理客户端异常退出
        void clientCloseException(const TcpConnectionPtr &conn);
        //服务器异常，业务重置方法
        void reset();
        //获取消息对应的处理器
        MsgHandler getHandler(int msgid);
        //从redis消息队列中获取订阅的消息
        void handleRedisSubscribeMessage(int, string);
    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;
    
        //redis操作对象
        Redis _redis;
        
    };
    
    #endif

**我们完善chatservice.cpp**

#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({
        LOGINOUT_MSG, std::bind(&ChatService::loginout, 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)});
    
        //连接redis服务器
        if (_redis.connect())
        {
        
            //设置上报消息的回调
            _redis.init_notify_handler(std::bind(&ChatService::handleRedisSubscribeMessage, this, _1, _2));
        }
    
    }
    
    //服务器异常，业务重置方法
    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});
                }//加个作用域，出了这个右括号就自动解锁
                
                //id用户登录成功后，向redis订阅channel(id)
                _redis.subscribe(id); 
    
                //登录成功，更新用户状态信息 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::loginout(const TcpConnectionPtr &conn, json &js, Timestamp time)
    {
        
        int userid = js["id"].get<int>();
    
        {
        
            lock_guard<mutex> lock(_connMutex);
            auto it = _userConnMap.find(userid);
            if (it != _userConnMap.end())
            {
        
                _userConnMap.erase(it);
            }
        }
        //用户注销，相当于就是下线，在redis中取消订阅通道
        _redis.unsubscribe(userid); 
    
        //更新用户的状态信息
        User user(userid, "", "", "offline");
        _userModel.updateState(user);
    }
    
    //处理客户端异常退出
    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;
                }
            }
        }
    
        //用户注销，相当于就是下线，在redis中取消订阅通道
        _redis.unsubscribe(user.getId()); 
    
        //更新用户的状态信息
        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是否在线 
        User user = _userModel.query(toid);
        if (user.getState() == "online")
        {
        
            _redis.publish(toid, 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
            {
        
                //查询toid是否在线 
                User user = _userModel.query(id);
                if (user.getState() == "online")
                {
        
                    _redis.publish(id, js.dump());
                }
                else
                {
        
                    //存储离线群消息
                    _offlineMsgModel.insert(id, js.dump());
                }
            }
        }
    }
    
    //从redis消息队列中获取订阅的消息
    void ChatService::handleRedisSubscribeMessage(int userid, string msg)
    {
        
        lock_guard<mutex> lock(_connMutex);
        auto it = _userConnMap.find(userid);
        if (it != _userConnMap.end())
        {
        
            it->second->send(msg);
            return;
        }
    
        //存储该用户的离线消息
        _offlineMsgModel.insert(userid, msg);
    }

## 编译成功 ##

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

## 测试 ##

**我们启动2个服务器**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 4]  
**我们再打开1个客户端，分别登录linzeyu**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 5]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 6]

**我们再打开一个终端，登录zhangsan**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 10]  
**测试成功！！！**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70]: /images/20220829/dd4fc3cf2cda46288b7740ec65f82789.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 1]: /images/20220829/6cc70a34a55b4201a9d3d335c57f8e6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 2]: /images/20220829/1146f9cdf11344738b57bc93bc7e750e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 3]: /images/20220829/873fabd93ebf4d40aa219e0dc76f3e30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 4]: /images/20220829/ba32f0bc1cdd4c2cb26cf2126ec81bc2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/b4391fb120fb4e59bbbb92ac74c07f3b.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 6]: /images/20220829/ed0e1f9cd0ed46efa8c5c02d88da9b5a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 7]: /images/20220829/30f17c8d80ee4388bf333441522432e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 8]: /images/20220829/005bf5cb72a44d0a95a34854f4d16114.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 9]: /images/20220829/ac38c30d96ac4b30a518ded5dc59e564.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 10]: /images/20220829/269a8eca14c2433f92940deb687664b3.png