Example: cpp_redis_client.cpp 代码片段

    1. //创建redis client， 连接redis服务器
    2. cpp_redis::client client;
    4. client.connect("127.0.0.1", 6739,
    5.                [](const std::string &host, std::size_t port, cpp_redis::connect_state status){
    6.                    if(status == cpp_redis::connect_state::dropped) {
    7.                            std::cout << "client disconnected from" << host << ":" << port << std::endl;
    8.                    }
    9.                    });

    cpp_redis_client.cpp

    1. //cpp_redis::client是一个类，它提供类和Redis Server的通信：
    2. //将commend发送到远端的server，并接收server端的回复
    3. //提供类异步请求和同步请求的方式，同时，也支持管道
    5. namespace cpp_redis {
    6.     class client {
    7.     public:
    8.         ...
    9.         //定义显式调用的constructor，用以特定的tcp_client
    10.         //@param tcp_client 用以网络通信的tcp client
    11.         explicit client(const std::shared_ptr<network::tcp_client_iface> &tcp_client);
    13.         ~client();
    15.         //阻止使用copy构造函数和copy assignment
    16.         client(const client &) = delete;
    17.         client &operator=(const client &) = delete;
    19.     public:
    20.         /**
    21.          * Connect to redis server
    22.          *
    23.          * @param host host to be connected to
    24.          * @param port port to be connected to
    25.          * @param connect_callback connect handler to be called on connect events (may be null)
    26.          * @param timeout_ms maximum time to connect
    27.          * @param max_reconnects maximum attempts of reconnection if connection dropped
    28.          * @param reconnect_interval_ms time between two attempts of reconnection
    29.          *
    30.          */
    31.          void connect(const std::string &host = "127.0.0.1",
    32.                       std::size_t port = 6739,
    33.                       const connect_callback_t &connect_callback = nullptr,
    34.                       std::uint32_t timeout_ms = 0,
    35.                       std::int32_t max_reconnects = 0,
    36.                       std::uint32_t reconnect_interval_ms = 0) 
    37.          {
    38.              __CPP_REDIS_LOG(debug, "cpp_redis::client attempts to connect");
    39.                //Save for auto reconnects
    40.              m_redis_server = host;
    41.              m_redis_port = port;
    42.              m_connect_callback = connect_callback;
    43.              m_max_reconnects = max_reconnects;
    44.              m_reconnect_interval_ms = reconnect_interval_ms;
    46.              //notify start
    47.              if(m_connect_callback) {
    48.                  m_connect_callback(host, port, connect_state::start);
    49.              }
    51.              auto disconnection_handler = std::bind(&client::connection_disconnection_handler,
    52.                                                        this, std::placeholder::_1);
    53.              auto receive_handler = std::bind(&client::connection_receive_handler,
    54.                                               this, std::placeholder::_1, std::placeholder::_2);
    55.              m_client.connect(host, port, disconnection_handler, receive_handler, timeout_ms);
    57.              __CPP_REDIS_LOG(info, "cpp_redis::client connected");
    59.              //notify end
    60.              if(m_connect_callback) {
    61.                  m_connect_callback(m_redis_server, m_redis_port, connect_state::ok);
    62.              }
    64.          }
    66.         /**
    67.          * Connect to redis server
    68.          *
    69.          * @param name sentinel name (哨兵的name)
    70.          * @param connect_callback connect handler to be called on connect events (may be null)
    71.          * @param timeout_ms maximum time to connect
    72.          * @param max_reconnects maximum attempts of reconnection if connection dropped
    73.          * @param reconnect_interval_ms time between two attempts of reconnection
    74.          *
    75.          */
    76.          void connect(
    77.                  const std::string &name,
    78.                  const connect_callback_t &connect_callback = nullptr,
    79.                  std::uint32_t timeout_ms = 0,
    80.                  std::int32_t max_reconnects = 0,
    81.                  std::uint32_t reconnect_interval_ms = 0)
    82.           {
    83.               //save for auto reconnect
    84.               m_master_name = name;
    85.               //依靠sentinel来告知我们哪一个redis server当前是master
    86.               if(m_sentinel.get_master_addr_by_name(name, m_redis_server, m_redis_port, true)) {
    87.                   connect(m_redis_server, m_redis_port, connect_callback, timeout_ms, max_reconnects, reconnect_interval_ms);
    88.               } else {
    89.                   throw redis_error("cpp_redis::client::connect() could not find master for m_name" + name);
    90.               }
    91.           }
    94.      private:
    95.         //redis sentinel(redis哨兵)
    96.         cpp_redis::sentinel m_sentinel;
    98.     }
    99. }