Redis——redispluspls库通用命令以及String类型相关接口使用

通用命令

get，set

void get_set_test(sw::redis::Redis& redis){
    //bool set(const sw::redis::StringView &key,   这里的StringView类型是只读版本的字符串
    //const sw::redis::StringView &val, 
    //bool keepttl, 
    //sw::redis::UpdateType type = sw::redis::UpdateType::ALWAYS
    redis.flushall();
    redis.set("k1","111");
    redis.set("k2","222");
    redis.set("k3","333");
    //返回值是optional类型
    auto value1 = redis.get("k1");
    std::cout<<"value="<<value1.value()<<std::endl;

    auto value2 = redis.get("k2");
    std::cout<<"value="<<value2.value()<<std::endl;

    auto value3 = redis.get("k3");
    std::cout<<"value="<<value3.value()<<std::endl;

    auto value4 = redis.get("k4");
    std::cout<<"value="<<value4.value()<<std::endl;
    //对于非法状态的optional的非法状态,进行取值操作，就会抛出异常
    //对于这个返回值可以做出判定（会隐式转换为布尔类型）
    //if(value) std::cout<<"value="<<value4.value()<<std::endl;
}

进行单元测试的时候，清除数据是放到开始，还是结束呢？答案是放在开始更好点

如果放在结束，一旦执行的程序中间出现了异常，就可能导致 清理代码 没有执行到

如果代码中间的位置出现了抛异常，那么末尾的flashall就不会被执行，jj这和释放指针一个道理，

在这种场景下就会造成指针未释放而造成的内存泄漏

keys

    redis.flushall();
    redis.set("k1","111");
    redis.set("k2","222");
    redis.set("k3","333");
    redis.set("k4","444");
    redis.set("k5","555");
    redis.set("k6","666");
    
    //key的第二个参数是一个“插入迭代器”，咱们需要先准备好一个保存结果的容器
    //接下来再创建一个插入迭代器指向容器的位置，就可以把keys获取到的结果依次通过刚才的插入迭代器插入到容器的指定位置中
    //void keys<Output>(const sw::redis::StringView &pattern, Output output)
    vector<string> result;
    auto it = std::back_inserter(result);
    redis.keys("*",it);
    //printContainer(result);
	for(const auto& elem:result{
        std::cout<<elem<<std::endl;
    }

插入迭代器

在STL中有五种迭代器类型

1. 输入迭代器
2. 输出迭代器
3. 前向迭代器
4. 双向迭代器
5. 随机访问迭代器

例如在写算法题的时候经常会用到的sort,这里面传参的迭代器 就是随机访问迭代器

插入迭代器，本质上是一种输出迭代器，通常，一个迭代器主要表示的是一个“位置”，插入迭代器则是，“位置”+“动作”

• front_insert_iterator 区间的开头，往前面插入
• back_insert_iterator 区间的末尾，往后面插入
• insert_iterator 区间的任意位置，往该位置之前插入

expire和ttl

void expire_test(sw::redis::Redis& redis){
    using namespace std::chrono_literals;//使用字面值常量 3s
    std::cout<<"expire and ttl"<<std::endl;
    redis.flushall();

    redis.set("key","111");
    //bool expire(const sw::redis::StringView &key, const std::chrono::seconds &timeout)
    redis.expire("key",std::chrono::seconds(10));//设置过期时间
    //long long ttl(const sw::redis::StringView &key)
    std::this_thread::sleep_for(3s);

    auto time =  redis.ttl("key");
    std::cout<<time<<std::endl;
}

type

void type_test(sw::redis::Redis& redis){
    std::cout<<"type"<<std::endl;
    redis.flushall();
    redis.set("key1","111");
    auto type1 =  redis.type("key");
    std::cout<<type1<<std::endl;

     redis.lpush("key2","1,2,3,4");
    auto type2 =  redis.type("key2");
    std::cout<<type2<<std::endl;

     redis.hset("key3","aaa","111");
    auto type3 =  redis.type("key3");
    std::cout<<type3<<std::endl;

    redis.sadd("key4","aaa");
    auto type4 =  redis.type("key4");
    std::cout<<type4<<std::endl;

     redis.zadd("key5","吕布",99);
    auto type5 =  redis.type("key5");
    std::cout<<type5<<std::endl;

}

string 类型接口

set和get

set带有超时时间

  redis.flushall();
    std::cout<<"set 带有超时时间"<<std::endl;
    // using namespace std::chrono_literals;
    redis.set("key1","111",std::chrono::seconds(10));

    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout<<redis.ttl("key1")<<std::endl;

set NX和XX

 using namespace std::chrono_literals;
    redis.flushall();
    std::cout<<"set NX 和 XX"<<std::endl;
    //set的重载版本中，没有单独提供NX和XX的版本，必须搭配过期时间的版本使用

    redis.set("key","111",0s,sw::redis::UpdateType::NOT_EXIST);//NX
    auto value = redis.get("key");
    std::cout<<"NX 不存在则设置——value:"<<value.value()<<std::endl;
    redis.set("key","222",0s,sw::redis::UpdateType::EXIST);//XX
    value = redis.get("key");
    std::cout<<"XX 存在则设置——value:"<<value.value()<<std::endl;

mset 和 mget

 using namespace std::chrono_literals;
    redis.flushall();
    std::cout<<"mset 和 mget"<<std::endl;
    //第一种写法，使用初始化列表描述多个键值对
    // redis.mset({std::make_pair("key1","111"),std::make_pair("key2","222"),std::make_pair("key3","333")});
    //第二种写法，可以吧多个键值对提前组织到容器中，以迭代器的形式告诉mset
    vector<std::pair<string,string>> keys = {
        {"key1","111"},
        {"key2","222"},
        {"key3","333"}
    };
    redis.mset(keys.begin(),keys.end());

    vector<sw::redis::OptionalString> result;
    auto it  = std::back_inserter(result);
    redis.mget({"key1","key2","key3"},it);
    
    for(const auto& elem:result){
        if(elem) std::cout<<elem.value()<<std::endl;
        else std::cout<<"元素无效"<<std::endl;
    }

getrange 和 setrange

 std::cout<<"getrange 和 setrange"<<std::endl;
    redis.flushall();
    redis.set("key","abcdefghijk");

    string result = redis.getrange("key",2,5);
    std::cout<<"result:"<<result<<std::endl;

    redis.setrange("key",2,"xyz");
    auto value = redis.get("key");
    std::cout<<"value:"<<value.value()<<std::endl;

incr 和 decr

 std::cout<<"incr 和 decr"<<std::endl;
    redis.flushall();

    redis.set("key","100");
    
    //incr和decr得到的是long long 类型[使用这个更多一些]
    long long result = redis.incr("key");
    std::cout<<"result:"<<result<<std::endl;

    auto value = redis.get("key");
    std::cout<<"value:"<<value.value()<<std::endl;

    result = redis.decr("key");
    std::cout<<"result:"<<result<<std::endl;

    value = redis.get("key");
    std::cout<<"value:"<<value.value()<<std::endl;