RedisTemplate对象中方法的使用

Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

RedisTemplate的两种使用方式，分别是：

opsFor的方式

bound的方式

Redis中有五种基础数据类型，RedisTemplate对象针对不同的数据类型，进行了不同的封装，将相同类型操作封装为Operation接口，分别如下所示： 

另外，考虑到每次操作都需要指定对应的【key】名称，所以为了简化指定【key】名称的操作，RedisTemplate对象也提供了绑定key的Operations接口，分别如

通过opsFor操作redis

下面就介绍一下通过opsFor的方式操作各种数据类型的方法。

（1）操作string字符串类型

public void demo01() {
    // 操作字符串
    ValueOperations ops = redisTemplate.opsForValue();
    // 设置key-value,等价于redis命令:set
    ops.set("k1", "100");
    // 设置过期时间,等价于redis命令:setex
    ops.set("k2", "200", 2, TimeUnit.SECONDS);
    // key不存在,则设置,等价于redis命令:setnx
    ops.setIfAbsent("k3", "300");
    ops.set("k4", "this is a string.");
    // 追加内容,等价于redis命令:append
    ops.append("k4", "redis string");
    // 获取长度,等价于redis命令:strlen
    Long k4 = ops.size("k4");
    // 自增1,等价于redis命令:incr
    ops.increment("k1");
    // 自增指定步长,等价于redis命令:incrby
    ops.increment("k1", 10);
    // 自减1,等价于redis命令:decr
    ops.decrement("k3");
    // 自减指定步长,等价于redis命令:decrby
    ops.decrement("k3", 20);
    Map<String, String> map = new HashMap<>();
    map.put("kk1", "vv100");
    map.put("kk2", "vv200");
    // 等价于redis命令:mset
    ops.multiSet(map);
    List<String> keys = new ArrayList<>();
    keys.add("kk1");
    keys.add("kk2");
    // 等价于redis命令:mget
    List list = ops.multiGet(keys);
    map = new HashMap<>();
    map.put("kk1", "vv100");
    map.put("kk3", "vv300");
    // 等价于redis命令:msetnx
    Boolean aBoolean = ops.multiSetIfAbsent(map);
    // 等价于redis命令:get
    Object k1 = ops.get("k1");
    // 等价于redis命令:getset
    Object obj = ops.getAndSet("kk1", "bak_vv100");
    // 等价于redis命令:getrange
    String kk2 = ops.get("kk2", 0, 1);
    // 等价于redis命令:del
    Boolean k3 = ops.getOperations().delete("k3");
}

（2）操作List集合类型

public void demo02() {
    ListOperations ops = redisTemplate.opsForList();
    // 左边添加元素,等价于redis命令:lpush
    ops.leftPush("k1", "100");
    ops.leftPushAll("k2", "100", "200", "300");
    List<Integer> addList = new ArrayList<>();
    addList.add(100);
    addList.add(200);
    ops.leftPushAll("k3", addList);
    // 右边添加元素,等价于redis命令:rpush
    ops.rightPush("k11", "100");
    ops.rightPushAll("k22", "100", "200", "300");
    List<Integer> addList2 = new ArrayList<>();
    addList2.add(100);
    addList2.add(200);
    ops.rightPushAll("k33", addList2);
    // 等价于redis命令:lpop
    Object k2 = ops.leftPop("k2");
    // 等价于redis命令:rpop
    Object k22 = ops.rightPop("k22");
    // 等价于redis命令:rpoplpush
    Object push = ops.rightPopAndLeftPush("k22", "k2");
    // 等价于redis命令:lrange
    List k21 = ops.range("k2", 0, -1);
    // 等价于redis命令:lindex
    Object k221 = ops.index("k22", 1);
    // 等价于redis命令:llen
    Long k33 = ops.size("k33");
    // 等价于redis命令:lrem
    Long k3 = ops.remove("k3", 1, "100");
    // 等价于redis命令:lset
    ops.set("k33", 2, "new_200");
}

（3）操作Set集合类型

public void demo03() {
    SetOperations ops = redisTemplate.opsForSet();
    // 等价于redis命令:sadd
    ops.add("k1", "100", "200", "300");
    // 等价于redis命令:smembers
    Set k1 = ops.members("k1");
    // 等价于redis命令:sismember
    Boolean k11 = ops.isMember("k1", "400");
    // 等价于redis命令:sacrd
    Long k12 = ops.size("k1");
    // 等价于redis命令:srem
    Long k13 = ops.remove("k1", "100", "300");
    // 等价于redis命令:spop
    Object k14 = ops.pop("k1");
    List k15 = ops.pop("k1", 2);
    // 等价于redis命令:srandmember
    Object k16 = ops.randomMember("k1");
    List k17 = ops.randomMembers("k1", 2);
    // 等价于redis命令:smove
    Boolean move = ops.move("k1", "v100", "k2");
    // 等价于redis命令:sinter
    List<String> keyLists = new ArrayList<>();
    keyLists.add("k1");
    keyLists.add("k2");
    Set intersect = ops.intersect(keyLists);
    // 求k1和k2的交集,然后将结果保存到k3中
    Long aLong2 = ops.intersectAndStore("k1", "k2", "k3");
    // 等价于redis命令:sunion
    Set union = ops.union(keyLists);
    // 求k1和k2的并集,然后将结果保存到k3中
    Long aLong1 = ops.unionAndStore("k1", "k2", "k3");
    // 等价于redis命令:sdiff
    Set difference = ops.difference(keyLists);
    // 求k1和k2的差集,然后将结果保存到k3中
    Long aLong = ops.differenceAndStore("k1", "k2", "k3");
}

（4）操作Hash类型

public void demo04() {
    HashOperations ops = redisTemplate.opsForHash();
    // 等价于redis命令:hset
    ops.put("k1", "h1", "v100");
    // 等价于redis命令:hget
    Object o = ops.get("k1", "h2");
    // 等价于redis命令:hkeys
    Set k11 = ops.keys("k1");
    // 等价于redis命令:hvals
    List k1 = ops.values("k1");
    // 等价于redis命令:hmset
    Map<String, String> map = new HashMap<>();
    map.put("h1", "v100");
    map.put("h2", "v200");
    ops.putAll("k2", map);
    // 等价于redis命令:hdel
    Long delete = ops.delete("k1", "h1", "h3");
    // 等价于redis命令:hsetnx
    Boolean aBoolean = ops.putIfAbsent("k1", "h2", "v200");
    // 等价于redis命令:hincrby
    Long increment = ops.increment("k1", "h1", 10);
    Long increment1 = ops.increment("k1", "h2", -20);
}

（5）操作ZSet类型

public void demo05() {
    ZSetOperations ops = redisTemplate.opsForZSet();
    // 等价于redis命令:zadd
    Boolean add = ops.add("k1", "v100", 100);
    DefaultTypedTuple<String> dtt1 = new DefaultTypedTuple<>("v100", 100.0);
    DefaultTypedTuple<String> dtt2 = new DefaultTypedTuple<>("v200", 200.0);
    Set<DefaultTypedTuple<String>> set = new HashSet<>();
    set.add(dtt1);
    set.add(dtt2);
    Long k2 = ops.add("k2", set);
    // 等价于redis命令:zrange
    Set k1 = ops.range("k1", 0, -1);
    Set k11 = ops.rangeWithScores("k1", 0, -1);
    // 等价于redis命令:zrangebyscore
    Set k12 = ops.rangeByScore("k1", 10.0, 52.0);
    Set k13 = ops.rangeByScoreWithScores("k1", 10.0, 52.0);
    // 等价于redis命令:zrevrangebyscore
    Set k21 = ops.reverseRangeByScore("k2", 100.0, 30.0);
    Set k22 = ops.reverseRangeByScoreWithScores("k2", 100.0, 30.0);
    // 等价于redis命令:zincrby
    Double aDouble = ops.incrementScore("k1", "v100", 10);
    Double aDouble1 = ops.incrementScore("k1", "v200", -20);
    // 等价于redis命令:zrem
    Long remove = ops.remove("k1", "v100", "v300");
    // 等价于redis命令:zcount
    Long k14 = ops.count("k1", 10.0, 52.0);
    // 等价于redis命令:zrank
    Long rank = ops.rank("k1", "v100");
}

通过Bound操作redis

通过opsFor的方式来操作redis，可以发现有一个缺点，就是每次都需要我们指定要操作哪个【key】的数据，如果项目中，存在很多地方，那么就需要指定多次【key】名称，这就容易导致【key】名称不一致的情况，假设某个地方不小心写错了，也很难发现问题出在哪里，所以，为了解决这个问题，同时简化代码的编写，redisTemplate提供了绑定【key】的方式来操作redis。

opsFor和bound两种方式对比：

从上面可以看出，通过bound方式操作redis，只需要一个地方指定【key】名称即可。bound的操作方式只是简化了opsFor中key名称的，其余的方法都是和opsFor的操作方法名称一致的，这里就不再黏贴多余的代码了。

END

推荐您阅读更多有关于“ map list RedisTemplate set bound ”的文章

猜你喜欢

• 6-29HTTP POST数据和数据接收
• 6-29常用SpringJPA主键生成策略，UUID和自增
• 6-29Apache Commons Jar包下载
• 6-29IIS服务器返回Bad Request (Invalid Hostname)解决办法
• 6-29SpringJPA 慎重 findAll() 切记分页