String类型 使用场景 单点登录 ，共享session ，做缓存

判断是否有key所对应的值，有则返回true，没有则返回false

1
redisTemplate.hasKey(key)

有则取出key值所对应的值

1
redisTemplate.opsForValue().get(key)

删除单个key值

1
redisTemplate.delete(key)

批量删除key

1
redisTemplate.delete(keys) //其中keys:Collection<K> keys

将当前传入的key值序列化为byte[]类型

1
redisTemplate.dump(key)

设置过期时间

1
2
3
public Boolean expire(String key, long timeout, TimeUnit unit) {
    return redisTemplate.expire(key, timeout, unit);
 }
1
2
3
public Boolean expireAt(String key, Date date) {
   return redisTemplate.expireAt(key, date);
 }

查找匹配的key值，返回一个Set集合类型

1
2
3
public Set<String> getPatternKey(String pattern) {
    return redisTemplate.keys(pattern);
}

修改redis中key的名称

1
2
3
public void renameKey(String oldKey, String newKey) {
    redisTemplate.rename(oldKey, newKey);
}

返回传入key所存储的值的类型

1
2
3
public DataType getKeyType(String key) {
    return redisTemplate.type(key);
}

如果旧值存在时，将旧值改为新值

1
2
3
public Boolean renameOldKeyIfAbsent(String oldKey, String newKey) {
    return redisTemplate.renameIfAbsent(oldKey, newKey);
}

从redis中随机取出一个key

1
redisTemplate.randomKey()

返回当前key所对应的剩余过期时间

1
2
3
public Long getExpire(String key) {
    return redisTemplate.getExpire(key);
}

返回剩余过期时间并且指定时间单位

1
2
3
public Long getExpire(String key, TimeUnit unit) {
    return redisTemplate.getExpire(key, unit);
}

将key持久化保存

1
2
3
public Boolean persistKey(String key) {
    return redisTemplate.persist(key);
}

将当前数据库的key移动到指定redis中数据库当中

1
2
3
public Boolean moveToDbIndex(String key, int dbIndex) {
    return redisTemplate.move(key, dbIndex);
}

设置当前的key以及value值

1
redisTemplate.opsForValue().set(key, value)

设置当前的key以及value值并且设置过期时间

1
redisTemplate.opsForValue().set(key, value, timeout, unit)

返回key中字符串的子字符

1
2
3
public String getCharacterRange(String key, long start, long end) {
    return redisTemplate.opsForValue().get(key, start, end);
}

将旧的key设置为value，并且返回旧的key

1
2
3
public String setKeyAsValue(String key, String value) {
    return redisTemplate.opsForValue().getAndSet(key, value);
}

批量获取值

1
2
3
public List<String> multiGet(Collection<String> keys) {
   return redisTemplate.opsForValue().multiGet(keys);
}

在原有的值基础上新增字符串到末尾

1
redisTemplate.opsForValue().append(key, value)

以增量的方式将double值存储在变量中

1
2
3
public Double incrByDouble(String key, double increment) {
   return redisTemplate.opsForValue().increment(key, increment);
}

通过increment(K key, long delta)方法以增量方式存储long值（正值则自增，负值则自减）

1
2
3
public Long incrBy(String key, long increment) {
    return redisTemplate.opsForValue().increment(key, increment);
}

如果对应的map集合名称不存在，则添加否则不做修改

1
2
3
4
5
Map valueMap = new HashMap(); 
valueMap.put("valueMap1","map1"); 
valueMap.put("valueMap2","map2"); 
valueMap.put("valueMap3","map3"); 
redisTemplate.opsForValue().multiSetIfAbsent(valueMap);

设置map集合到redis

1
2
3
4
5
Map valueMap = new HashMap(); 
valueMap.put("valueMap1","map1"); 
valueMap.put("valueMap2","map2"); 
valueMap.put("valueMap3","map3"); 
redisTemplate.opsForValue().multiSet(valueMap);

获取字符串的长度

1
redisTemplate.opsForValue().size(key)

用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始

1
redisTemplate.opsForValue().set(key, value, offset)

重新设置key对应的值，如果存在返回false，否则返回true

1
redisTemplate.opsForValue().setIfAbsent(key, value)

将值 value 关联到 key,并将 key 的过期时间设为 timeout

1
redisTemplate.opsForValue().set(key, value, timeout, unit)

将二进制第offset位值变为value

1
redisTemplate.opsForValue().setBit(key, offset, value)

对key所储存的字符串值，获取指定偏移量上的位(bit)

1
redisTemplate.opsForValue().getBit(key, offset)

Hash类型

Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。
Redis 中每个 hash 可以存储 2^32 - 1 键值对（40多亿）。

获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null。

1
redisTemplate.opsForHash().get(key, field)

获取变量中的键值对

1
2
3
public Map<Object, Object> hGetAll(String key) {
    return redisTemplate.opsForHash().entries(key);
}

新增hashMap值

1
redisTemplate.opsForHash().put(key, hashKey, value)

以map集合的形式添加键值对

1
2
3
public void hPutAll(String key, Map<String, String> maps) {
    redisTemplate.opsForHash().putAll(key, maps);
}

仅当hashKey不存在时才设置

1
2
3
public Boolean hashPutIfAbsent(String key, String hashKey, String value) {
    return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
}

删除一个或者多个hash表字段

1
2
3
public Long hashDelete(String key, Object... fields) {
    return redisTemplate.opsForHash().delete(key, fields);
}

查看hash表中指定字段是否存在

1
2
3
public boolean hashExists(String key, String field) {
    return redisTemplate.opsForHash().hasKey(key, field);
}

给哈希表key中的指定字段的整数值加上增量increment

1
2
3
public Long hashIncrBy(String key, Object field, long increment) {
    return redisTemplate.opsForHash().increment(key, field, increment);
}
1
2
3
public Double hIncrByDouble(String key, Object field, double delta) {
    return redisTemplate.opsForHash().increment(key, field, delta);
}

获取所有hash表中字段

1
redisTemplate.opsForHash().keys(key)

获取hash表中字段的数量

1
redisTemplate.opsForHash().size(key)

获取hash表中存在的所有的值

1
2
3
public List<Object> hValues(String key) {
    return redisTemplate.opsForHash().values(key);
}

匹配获取键值对，ScanOptions.NONE为获取全部键对

1
2
3
public Cursor<Entry<Object, Object>> hashScan(String key, ScanOptions options) {
    return redisTemplate.opsForHash().scan(key, options);
}

List类型  

list就是链表，略有数据结构知识的人都应该能理解其结构。使用Lists结构，我们可以轻松地实现最新消息排行等功能。List的另一个应用就是消息队列，可以利用List的PUSH操作，将任务存在List中，然后工作线程再用POP操作将任务取出进行执行。Redis还提供了操作List中某一段的api，你可以直接查询，删除List中某一段的元素。 
Redis的list是每个子元素都是String类型的双向链表，可以通过push和pop操作从列表的头部或者尾部添加或者删除元素，这样List即可以作为栈，也可以作为队列。

通过索引获取列表中的元素

1
redisTemplate.opsForList().index(key, index)

获取列表指定范围内的元素(start开始位置, 0是开始位置，end 结束位置, -1返回所有)

1
redisTemplate.opsForList().range(key, start, end)

存储在list的头部，即添加一个就把它放在最前面的索引处

 

1
redisTemplate.opsForList().leftPush(key, value)

把多个值存入List中(value可以是多个值，也可以是一个Collection value)

1
redisTemplate.opsForList().leftPushAll(key, value)

List存在的时候再加入

1
redisTemplate.opsForList().leftPushIfPresent(key, value)

如果pivot处值存在则在pivot前面添加

1
redisTemplate.opsForList().leftPush(key, pivot, value)

按照先进先出的顺序来添加(value可以是多个值，或者是Collection var2)

1
2
redisTemplate.opsForList().rightPush(key, value)
redisTemplate.opsForList().rightPushAll(key, value)

在pivot元素的右边添加值

1
redisTemplate.opsForList().rightPush(key, pivot, value)

设置指定索引处元素的值

1
redisTemplate.opsForList().set(key, index, value)

移除并获取列表中第一个元素(如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止)

1
2
redisTemplate.opsForList().leftPop(key)
redisTemplate.opsForList().leftPop(key, timeout, unit)

移除并获取列表最后一个元素

1
2
redisTemplate.opsForList().rightPop(key)
redisTemplate.opsForList().rightPop(key, timeout, unit)

从一个队列的右边弹出一个元素并将这个元素放入另一个指定队列的最左边

1
2
redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey)
redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey, timeout, unit)

删除集合中值等于value的元素(index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素; index<0, 从尾部开始删除第一个值等于value的元素)

1
redisTemplate.opsForList().remove(key, index, value)

将List列表进行剪裁

1
redisTemplate.opsForList().trim(key, start, end)

获取当前key的List列表长度

 
1
redisTemplate.opsForList().size(key)

设置list集合的过期时间                                          

redisTemplate.expire(key,6000,TimeUnit.SECONDS);

Set类型

它是string类型的无序集合。set是通过hash table实现的，可以进行添加、删除和查找。对集合我们可以取并集，交集，差集.

1.集合可以进行 交集、并集 如新浪微博中获取两个用户共同的关注人

    新浪微博使用redis有两种应用场景：

   a. 直接把数据放到redis中进行存储，这些数据是独立的

   b. 有些数据包含表与表之间的逻辑关系，这些数据又访问比较频繁，如果直接从数据库中进行查询性能比较差。先将数据写到redis中，再将数据保存到mysql数据库

2. 随机展示

　通常，app首页的展示区域有限，但是又不能总是展示固定的内容，一种做法是先确定一批需要展示的内容，再从中随机获取。如下图所示，酷狗音乐K歌擂台赛当日的打擂歌曲共29首，首页随机展示5首；昨日打擂金曲共200首，首页随机展示30首。

3. 黑名单/白名单

　　经常有业务出于安全性方面的考虑，需要设置用户黑名单、ip黑名单、设备黑名单等，set类型适合存储这些黑名单数据，sismember命令可用于判断用户、ip、设备是否处于黑名单之中。

 

 

添加元素

1
redisTemplate.opsForSet().add(key, values)

移除元素(单个值、多个值)

1
redisTemplate.opsForSet().remove(key, values)

删除并且返回一个随机的元素

1
redisTemplate.opsForSet().pop(key)

获取集合的大小

1
redisTemplate.opsForSet().size(key)

判断集合是否包含value

1
redisTemplate.opsForSet().isMember(key, value)

获取两个集合的交集(key对应的无序集合与otherKey对应的无序集合求交集)

1
redisTemplate.opsForSet().intersect(key, otherKey)

获取多个集合的交集(Collection var2)

1
redisTemplate.opsForSet().intersect(key, otherKeys)

key集合与otherKey集合的交集存储到destKey集合中(其中otherKey可以为单个值或者集合)

1
redisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey)

key集合与多个集合的交集存储到destKey无序集合中

1
redisTemplate.opsForSet().intersectAndStore(key, otherKeys, destKey)

获取两个或者多个集合的并集(otherKeys可以为单个值或者是集合)

1
redisTemplate.opsForSet().union(key, otherKeys)

key集合与otherKey集合的并集存储到destKey中(otherKeys可以为单个值或者是集合)

1
redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey)

获取两个或者多个集合的差集(otherKeys可以为单个值或者是集合)

1
redisTemplate.opsForSet().difference(key, otherKeys)

差集存储到destKey中(otherKeys可以为单个值或者集合)

1
redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)

随机获取集合中的一个元素

1
redisTemplate.opsForSet().randomMember(key)

获取集合中的所有元素

1
redisTemplate.opsForSet().members(key)

随机获取集合中count个元素

1
redisTemplate.opsForSet().randomMembers(key, count)

获取多个key无序集合中的元素（去重），count表示个数

1
redisTemplate.opsForSet().distinctRandomMembers(key, count)

遍历set类似于Interator(ScanOptions.NONE为显示所有的)

1
redisTemplate.opsForSet().scan(key, options)

zSet类型

ZSetOperations提供了一系列方法对有序集合进行操作
添加元素(有序集合是按照元素的score值由小到大进行排列)

1
redisTemplate.opsForZSet().add(key, value, score)

删除对应的value,value可以为多个值

1
redisTemplate.opsForZSet().remove(key, values)

增加元素的score值，并返回增加后的值

1
redisTemplate.opsForZSet().incrementScore(key, value, delta)

返回元素在集合的排名,有序集合是按照元素的score值由小到大排列

1
redisTemplate.opsForZSet().rank(key, value)

返回元素在集合的排名,按元素的score值由大到小排列

1
redisTemplate.opsForZSet().reverseRank(key, value)

获取集合中给定区间的元素(start 开始位置，end 结束位置, -1查询所有)

1
redisTemplate.opsForZSet().reverseRangeWithScores(key, start,end)

按照Score值查询集合中的元素，结果从小到大排序

1
2
3
4
redisTemplate.opsForZSet().reverseRangeByScore(key, min, max)
  
redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max)
//返回值为:Set<ZSetOperations.TypedTuple<V>>

从高到低的排序集中获取分数在最小和最大值之间的元素

1
redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end)

根据score值获取集合元素数量

1
redisTemplate.opsForZSet().count(key, min, max)

获取集合的大小

1
2
3
redisTemplate.opsForZSet().size(key)
  
redisTemplate.opsForZSet().zCard(key)

获取集合中key、value元素对应的score值

1
redisTemplate.opsForZSet().score(key, value)

移除指定索引位置处的成员

1
redisTemplate.opsForZSet().removeRange(key, start, end)

移除指定score范围的集合成员

1
redisTemplate.opsForZSet().removeRangeByScore(key, min, max)

获取key和otherKey的并集并存储在destKey中（其中otherKeys可以为单个字符串或者字符串集合）

1
redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey)

获取key和otherKey的交集并存储在destKey中（其中otherKeys可以为单个字符串或者字符串集合）

1
redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey)

遍历集合（和iterator一模一样）

1
2
3
4
5
6
Cursor<TypedTuple<Object>> scan = opsForZSet.scan("test3", ScanOptions.NONE);
        while (scan.hasNext()){
            ZSetOperations.TypedTuple<Object> item = scan.next();
            System.out.println(item.getValue() + ":" + item.getScore());
        }