RedisTemplate方法详解

 

 maven依赖

org.springframework.boot spring-boot-starter-data-redis org.apache.commons commons-pool2 com.alibaba fastjson 1.2.68

 

redis序列化方式配置

@Configurationpublic class RedisConfig { /** * 设置Redis序列化方式，默认使用的JDKSerializer的序列化方式，效率低，这里我们使用 FastJsonRedisSerializer * @param redisConnectionFactory * @return */ @Bean public RedisTemplate redisTemplate(LettuceConnectionFactory redisConnectionFactory) { RedisTemplate redisTemplate = new RedisTemplate(); // key序列化 redisTemplate.setKeySerializer(new StringRedisSerializer()); // value序列化 redisTemplate.setValueSerializer(new FastJsonRedisSerializer(Object.class)); // Hash key序列化 redisTemplate.setHashKeySerializer(new StringRedisSerializer()); // Hash value序列化 redisTemplate.setHashValueSerializer(new StringRedisSerializer()); redisTemplate.setConnectionFactory(redisConnectionFactory); return redisTemplate; }}

 

1：Redis的String数据结构 

设置当前的key以及value值

redisTemplate.opsForValue().set(key, value)redisTemplate.opsForValue().set("num","123");

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

redisTemplate.opsForValue().set(key, value, timeout, unit)redisTemplate.opsForValue().set("num","123",10, TimeUnit.SECONDS);

TimeUnit.DAYS //天TimeUnit.HOURS //小时TimeUnit.MINUTES //分钟TimeUnit.SECONDS //秒TimeUnit.MILLISECONDS //毫秒

将旧的key设置为value，并且返回旧的key（设置key的字符串value并返回其旧值）

redisTemplate.opsForValue().getAndSet(key, value);

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

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

获取字符串的长度

redisTemplate.opsForValue().size(key)

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

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

设置map集合到redis

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

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

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

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

redisTemplate.opsForValue().increment(key, increment);

批量获取值

public List multiGet(Collection keys) { return redisTemplate.opsForValue().multiGet(keys); }

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

redisTemplate.type(key);

修改redis中key的名称

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

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

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

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

redisTemplate.hasKey(key)

删除单个key值

redisTemplate.delete(key)

批量删除key

redisTemplate.delete(keys) //其中keys:Collection keys

设置过期时间

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

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

redisTemplate.getExpire(key);

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

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

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

public Set getPatternKey(String pattern) { return redisTemplate.keys(pattern);}

将key持久化保存

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

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

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

 

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

 

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

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

获取变量中的键值对

public Map hGetAll(String key) { return redisTemplate.opsForHash().entries(key);}

新增hashMap值

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

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

public void hPutAll(String key, Map maps) { redisTemplate.opsForHash().putAll(key, maps);}

仅当hashKey不存在时才设置

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

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

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

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

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

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

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

获取所有hash表中字段

redisTemplate.opsForHash().keys(key)

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

public List hValues(String key) { return redisTemplate.opsForHash().values(key);}

获取hash表中字段的数量

redisTemplate.opsForHash().size(key)

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

public Cursor hashScan(String key, ScanOptions options) { return redisTemplate.opsForHash().scan(key, options);}

 

3、List类型

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

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

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

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

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

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

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

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

List存在的时候再加入

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

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

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

设置指定索引处元素的值

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

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

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

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

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

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

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

删除集合中值等于value的元素(index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素; index 0) { redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS); } else { set(key, value); } return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 设置一个已经存在的key的值，并返回旧值 * * @param key * @param value * @return */ public Object getAndSet(String key, Object value) { try { Object andSet = redisTemplate.opsForValue().getAndSet(key, value); return andSet; } catch (Exception e) { log.error(e.getMessage()); return null; } } /** * 如果不存在则设置值value，返回true。 否则返回false * * @param key * @param value * @return */ public boolean setIfAbsent(String key, String value) { try { return redisTemplate.opsForValue().setIfAbsent(key, value); } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 批量设置 k->v 到 redis * * @param valueMap * @return */ public boolean multiSet(HashMap valueMap) { try { redisTemplate.opsForValue().multiSet(valueMap); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 如果不存在对应的Map，则批量设置 k->v 到 redis * * @param valueMap * @return */ public boolean multiSetIfAbsent(HashMap valueMap) { try { redisTemplate.opsForValue().multiSetIfAbsent(valueMap); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 在原有的值基础上新增字符串到末尾 * * @param key * @param value * @return */ public boolean append(String key, String value) { try { redisTemplate.opsForValue().append(key, value); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 获取value * * @param key * @return */ public Object get(String key) { return key == null ? null : redisTemplate.opsForValue().get(key); } /** * 批量获取值 * * @param keys * @return */ public List multiGet(Collection keys) { if (CollectionUtils.isEmpty(keys)) { return null; } return redisTemplate.opsForValue().multiGet(keys); } /** * 删除缓存，支持批量删除 * * @param key */ public void del(String... key) { if (key != null && key.length > 0) { if (key.length == 1) { redisTemplate.delete(key[0]); } else { redisTemplate.delete(Arrays.asList(key)); } } } /** * 判断key是否存在 * * @param key 键 * @return true 存在 false不存在 */ public boolean hasKey(String key) { try { return redisTemplate.hasKey(key); } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 根据key 获取key的过期时间 * * @param key 键 不能为null * @return 时间(秒) 返回-1, 代表为永久有效 */ public long getKeyExpire(String key) { return redisTemplate.getExpire(key, TimeUnit.SECONDS); } /** * 指定缓存失效时间 * * @param key 键 * @param time 时间(秒) * @return */ public boolean expireKey(String key, long time) { try { if (time > 0) { redisTemplate.expire(key, time, TimeUnit.SECONDS); } return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 通过increment(K key, long increment)方法以增量方式存储long值（正值则自增，负值则自减） * * @param key * @param increment * @return */ public void increment(String key, long increment) { redisTemplate.opsForValue().increment(key, increment); } /** * 通过increment(K key, double increment)方法以增量方式存储double值（正值则自增，负值则自减） * * @param key * @param increment * @return */ public void increment(String key, double increment) { redisTemplate.opsForValue().increment(key, increment); } /** * 修改redis中key的名称 * * @param oldKey * @param newKey */ public void renameKey(String oldKey, String newKey) { redisTemplate.rename(oldKey, newKey); } /** * 如果旧值key存在时，将旧值改为新值 * * @param oldKey * @param newKey * @return */ public Boolean renameOldKeyIfAbsent(String oldKey, String newKey) { return redisTemplate.renameIfAbsent(oldKey, newKey); } // ##########################【操作Hash类型】##################################################### /** * 批量添加Map中的键值对 * * @param mapName map名字 * @param maps */ public boolean hashPutAll(String mapName, Map maps) { try { redisTemplate.opsForHash().putAll(mapName, maps); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 添加一个键值对 * * @param mapName * @param key * @param value */ public boolean hashPutOne(String mapName, String key, String value) { try { redisTemplate.opsForHash().put(mapName, key, value); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 添加一个键值对,仅当hashKey不存在时才设置 * * @param mapName * @param hashKey * @param value */ public boolean hashPutOneIfAbsent(String mapName, String hashKey, String value) { try { redisTemplate.opsForHash().putIfAbsent(mapName, hashKey, value); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 获取mapName中的所有的键值对 * * @param mapName Map名字 * @return */ public Object hashGetOne(String mapName, Object hashKey) { return redisTemplate.opsForHash().get(mapName, hashKey); } /** * 获取mapName中的所有的键值对 * * @param mapName Map名字 * @return */ public Map hashGetAll(String mapName) { return redisTemplate.opsForHash().entries(mapName); } /** * 删除一个或者多个hash表字段 * * @param key * @param fields * @return */ public Long hashDelete(String key, Object... fields) { return redisTemplate.opsForHash().delete(key, fields); } /** * 查看hash表中指定字段是否存在 * * @param key * @param field * @return */ public boolean hashExists(String key, String field) { return redisTemplate.opsForHash().hasKey(key, field); } /** * 给哈希表key中的指定字段的整数值加上增量increment * * @param key * @param field * @param increment * @return */ public Long hashIncrementByLong(String key, Object field, long increment) { return redisTemplate.opsForHash().increment(key, field, increment); } /** * 给哈希表key中的指定字段的double加上增量increment * * @param key * @param field * @param delta * @return */ public Double hashIncrementByDouble(String key, Object field, double delta) { return redisTemplate.opsForHash().increment(key, field, delta); } /** * 获取hash表中存在的所有的key * * @param mapName map名字 * @return */ public Set hashKeys(String mapName) { return redisTemplate.opsForHash().keys(mapName); } /** * 获取hash表中存在的所有的Value * * @param mapName map名字 * @return */ public List hashValues(String mapName) { return redisTemplate.opsForHash().values(mapName); } /** * 获取hash表的大小 * * @param mapName * @return */ public Long hashSize(String mapName) { return redisTemplate.opsForHash().size(mapName); } // ##########################【操作List类型】##################################################### /** * 设置值到List中的头部 * * @param key * @param value * @return */ public Boolean listAddInHead(String key, Object value) { try { redisTemplate.opsForList().leftPush(key, value); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 批量设置值到List中的头部 * * @param key List名字 * @param values * @return */ public Boolean listAddAllInHead(String key, Collection values) { try { redisTemplate.opsForList().leftPushAll(key, values); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 如果存在List->key, 则设置值到List中的头部 * * @param key List名字 * @param value * @return */ public Boolean listAddIfPresent(String key, Object value) { try { redisTemplate.opsForList().leftPushIfPresent(key, value); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 设置值到List中的尾部 * * @param key List名字 * @param value * @return */ public Boolean listAddInEnd(String key, Object value) { try { redisTemplate.opsForList().rightPush(key, value); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 批量设置值到List中的尾部 * * @param key List名字 * @param values * @return */ public Boolean listAddAllInEnd(String key, Collection values) { try { redisTemplate.opsForList().rightPushAll(key, values); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 通过索引去设置List->key中的值 * * @param key * @param index * @param value * @return */ public Boolean listAddByIndex(String key, long index, Object value) { try { redisTemplate.opsForList().set(key, index, value); return true; } catch (Exception e) { log.error(e.getMessage()); return false; } } /** * 根据索引获取list中的值 * * @param key list名字 * @param index * @return */ public Object listGetByIndex(String key, long index) { return redisTemplate.opsForList().index(key, index); } /** * 根据索引范围获取list中的值 * * @param key list名字 * @param start * @param end * @return */ public List listGetByRange(String key, long start, long end) { return redisTemplate.opsForList().range(key, start, end); } /** * 移除并获取列表中第一个元素(如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止) * * @param key list名字 * @return */ public Object listLeftPop(String key) { return redisTemplate.opsForList().leftPop(key); } /** * 移除并获取列表中最后一个元素(如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止) * * @param key list名字 * @return */ public Object listRightPop(String key) { return redisTemplate.opsForList().rightPop(key); } /** * 删除集合中值等于value的元素( * index=0, 删除所有值等于value的元素; * index>0, 从头部开始删除第一个值等于value的元素; * index 0 则最多返回count个坐标， 否则返回所有 * @return */ public GeoResults geoGetCoordinatesWithinRange(String key, double longitude, double latitude, Integer distance, Integer count) { //以当前坐标为中心画圆，标识当前坐标覆盖的distance的范围， Point(经度, 纬度) Distance(距离量, 距离单位) Circle circle = new Circle(new Point(longitude, latitude), new Distance(distance, RedisGeoCommands.DistanceUnit.METERS)); // 从redis获取的信息包含：距离中心坐标的距离、当前的坐标、并且升序排序，如果count > 0 则只取count个坐标，否则返回所有 RedisGeoCommands.GeoRadiusCommandArgs args = RedisGeoCommands.GeoRadiusCommandArgs .newGeoRadiusArgs().includeDistance().includeCoordinates().sortAscending(); if (count > 0) { args.limit(count); } GeoResults radius = redisTemplate.opsForGeo().radius(key, circle, args); return radius; } /*** * 【获取指定范围内的坐标】 * 以给定的键（key）中的坐标名字（标识）name为中心画圆， 返回键包含的位置元素当中， * 与中心的距离不超过给定最大距离的所有位置元素，并给出所有位置元素与中心的平均距离。 * @param key redis的key * @param name 坐标名称(标识) * @param distance 距离 * @param count 如果 count > 0 则最多返回count个坐标， 否则返回所有 * @return */ public GeoResults geoGetCoordinatesWithinRange(String key, String name, Integer distance, Integer count) { // 创建距离对象 Distance distances = new Distance(distance, RedisGeoCommands.DistanceUnit.METERS); // 需要从redis获取的参数 RedisGeoCommands.GeoRadiusCommandArgs args = RedisGeoCommands.GeoRadiusCommandArgs .newGeoRadiusArgs().includeDistance().includeCoordinates().sortAscending(); if (count > 0) { args.limit(count); } GeoResults radius = redisTemplate.opsForGeo() .radius(key, name, distances, args); return radius; }}