redis 基于SpringBoot Reids 的工具類
package com.mhy.springredis.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.geo.*;
import org.springframework.data.redis.connection.RedisGeoCommands;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
@Component
public class RedisUtils {
private RedisTemplate<String,Object> redisTemplate;
@Autowired
public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
/**
* redis基本指令 set
* @param key 鍵
* @param val 值
* @return 回傳是否插入成功
*/
public boolean set(String key, Object val){
try {
redisTemplate.opsForValue().set(key,val);
}catch (Exception e){
e.printStackTrace();
return false;
}
return true;
}
/**
* redis基本指令 get
* @param key 鍵值
* @return 回傳值
*/
public Object get(String key){
try {
return redisTemplate.opsForValue().get(key);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* redis基本指令 move
* @param key 移除的鍵
* @param dbIndex 那個資料庫
* @return 移除的結果
*/
public Boolean move(String key,int dbIndex){
try{
return redisTemplate.move(key,dbIndex);
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* redis基本指令 exists
* @param key 需要判斷的鍵
* @return 回傳是否存在這個鍵
*/
public Boolean exists(String key){
try{
return redisTemplate.hasKey(key);
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* redis基本指令 expire
* @param key 鍵
* @param seconds 設定的秒數
* @return 是否設定成功
*/
public Boolean expire(String key,long seconds){
try {
return redisTemplate.expire(key,seconds, TimeUnit.SECONDS);
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* redis基本指令 ttl
* @param key 鍵
* @return 回傳該鍵的剩余時間 -1表示沒有設定時間 -2表示不存在這個鍵 -3表示發生錯誤
*/
public Long ttl(String key){
try {
return redisTemplate.getExpire(key,TimeUnit.SECONDS);
}catch (Exception e){
e.printStackTrace();
return -3L;
}
}
/**
* redis基本指令 type
* @param key 需要查看型別的鍵
* @return 回傳型別
*/
public Object type(String key){
try{
return redisTemplate.type(key);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* redis基本指令 append
* @param key 需要追加字串的鍵
* @param appendStr 需要追加的字串
* @return 追加后的字符數 如果沒有這個字串就新建一個
*/
public Integer append(String key,String appendStr){
try{
return redisTemplate.opsForValue().append(key,appendStr);
}catch (Exception e){
e.printStackTrace();
return -1;
}
}
/**
* redis基本指令 strLen
* @param key 需要查看字串長度的鍵
* @return 字串的長度 0表示不存在 -1表示發生錯誤
*/
public Long strLen(String key){
try{
return redisTemplate.opsForValue().size(key);
}catch (Exception e){
e.printStackTrace();
return -1L;
}
}
/**
* redis基本指令 getRange
* @param key 需要查詢的鍵
* @param start 開始位置
* @param end 結束位置
* @return 回傳查詢的字串
*/
public String getRange(String key,long start,long end){
try{
return redisTemplate.opsForValue().get(key,start,end);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* redis基本指令 incr
* @param key 需要+1的鍵
* @return 回傳+1后的值
*/
public Long incr(String key){
return redisTemplate.opsForValue().increment(key);
}
/**
* redis基本指令 decr
* @param key 需要-1的鍵
* @return 回傳-1后的值
*/
public Long decr(String key){
return redisTemplate.opsForValue().decrement(key);
}
/**
* redis基本指令 incrBy
* @param key 需要的鍵
* @param val 加的值
* @return 加后的值
*/
public Long incrBy(String key,Long val){
return redisTemplate.opsForValue().increment(key,val);
}
/**
* redis基本指令 decrBy
* @param key 需要的鍵
* @param val 減的值
* @return 減后的值
*/
public Long decrBy(String key,Long val){
return redisTemplate.opsForValue().decrement(key,val);
}
/**
* redis基本指令 setRange
* @param key 需要修改的鍵
* @param index 下標
* @param val 修改的值
* @return 回傳是否修改成功
*/
public Boolean setRange(String key,Long index,String val){
try{
redisTemplate.opsForValue().set(key,val,index);
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* redis基本指令 setEx
* @param key 設定的鍵
* @param val 設定的值
* @param time 設定是時間 單位秒
* @return 回傳是否設定成功
*/
public Boolean setEx(String key,String val,Long time){
try{
redisTemplate.opsForValue().set(key,val,time,TimeUnit.SECONDS);
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* redis基本指令 存在這個鍵就失敗 setNx
* @param key 需要設定的鍵
* @param val 需要設定的值
* @return 回傳是否設定成功
*/
public Boolean setNx(String key,Object val){
try{
return redisTemplate.opsForValue().setIfAbsent(key,val);
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* redis基本指令 mSet
* @param map 需要批量增加的map集合
* @return 回傳是否成功
*/
public Boolean mSet(Map<String,Object> map){
try{
redisTemplate.opsForValue().multiSet(map);
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* redis基本指令 mGet
* @param list 批量查詢的鍵集合
* @return 回傳值的集合
*/
public List<Object> mGet(List<String> list){
try{
return redisTemplate.opsForValue().multiGet(list);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* redis基本指令 getSet
* @param key 獲取（修改）的鍵
* @param val 修改的值
* @return 回傳修改之前的值
*/
public Object getSet(String key,String val){
try{
return redisTemplate.opsForValue().getAndSet(key,val);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* List命令 lPush 采用的頭插入
* @param key 存入的鍵
* @param val 存入的值
* @return 存入后集合的個數
*/
public Long lPush(String key,Object val){
try{
return redisTemplate.opsForList().leftPush(key,val);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* List命令 rPush 采用的尾插入
* @param key 存入的鍵
* @param val 存入的值
* @return 存入后集合的個數
*/
public Long rPush(String key,Object val){
try{
return redisTemplate.opsForList().rightPush(key,val);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* List命令 lRange
* @param key 獲取集合的鍵
* @param start 開始的位置從0開始
* @param end 結束的位置
* @return 回傳list的集合資料
*/
public List<Object> lRange(String key,long start,long end){
try{
return redisTemplate.opsForList().range(key,start,end);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* List命令 lPop
* @param key 需要彈出的鍵
* @return 回傳頭部元素
*/
public Object lPop(String key){
try {
return redisTemplate.opsForList().leftPop(key);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* List命令 lPop
* @param key 需要彈出的鍵
* @return 回傳尾部元素
*/
public Object rPop(String key){
try {
return redisTemplate.opsForList().rightPop(key);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* List命令 lIndex
* @param key 需要查詢集合的鍵
* @param index 查詢集合的下標
* @return 這個下標的值
*/
public Object lIndex(String key,long index){
try {
return redisTemplate.opsForList().index(key,index);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* List命令 lLen
* @param key 需要查看長度的鍵
* @return 回傳這個集合的長度
*/
public Long lLen(String key){
try{
return redisTemplate.opsForList().size(key);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* List命令 lRem
* @param key 需要移除集合的鍵
* @param index 填一個數
* @param val 移除的值
* @return 回傳移除的個數
*/
public Long lRem(String key,Long index,Object val){
try{
return redisTemplate.opsForList().remove(key,index,val);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* List命令 lRem
* @param key 需要截取的集合的鍵
* @param start 開始位置，0最小
* @param end 結束位置
* @return 回傳是否截取成功
*/
public Boolean lTrim(String key,Long start,Long end){
try{
redisTemplate.opsForList().trim(key,start,end);
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* List命令 lSet
* @param key 需要修改的集合的鍵
* @param index 需要修改的下標
* @param val 修改的值
* @return 回傳是否修改成功
*/
public Boolean lSet(String key,long index,Object val){
if(lLen(key) <= index){
return false;
}
try{
redisTemplate.opsForList().set(key,index,val);
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* List基本指令 lInsert 鍵 after 那個值 需要插入的值
* @param key 需要插入的鍵
* @param pivot 需要插入到那個值
* @param val 需要插入的值
* @return 插入后的總數 回傳-1表示插入失敗
*/
public Long lInsertAfter(String key,Object pivot,Object val){
try {
return redisTemplate.opsForList().rightPush(key,pivot,val);
}catch (Exception e){
e.printStackTrace();
return -1L;
}
}
/**
* List基本指令 lInsert 鍵 before 那個值 需要插入的值
* @param key 需要插入的鍵
* @param pivot 需要插入到那個值
* @param val 需要插入的值
* @return 插入后的總數 回傳-1表示插入失敗
*/
public Long lInsertBefore(String key,Object pivot,Object val){
try {
return redisTemplate.opsForList().leftPush(key,pivot,val);
}catch (Exception e){
e.printStackTrace();
return -1L;
}
}
/**
* List基本指令 rPopLPush list1 list2
* @param key1 需要移除的最后元素的鍵
* @param key2 需要增加元素的鍵
* @return 移除的元素
*/
public Object rPopLPush(String key1,String key2){
try {
return redisTemplate.opsForList().rightPopAndLeftPush(key1,key2);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sAdd
* @param key 需要添加的鍵
* @param val 需要添加的值
* @return 回傳插入的元素個數
*/
public Long sAdd(String key,Object... val){
try {
return redisTemplate.opsForSet().add(key,val);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* set基本指令 sMembers
* @param key 查詢的set集合的鍵
* @return set集合的所有元素
*/
public Set<Object> sMembers(String key){
try {
return redisTemplate.opsForSet().members(key);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sisMember
* @param key 需要判斷的鍵
* @param val 需要判斷段的值
* @return 回傳是否存在
*/
public Boolean sisMember(String key,Object val){
try{
return redisTemplate.opsForSet().isMember(key,val);
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* set基本指令 sCard
* @param key 需要查詢元素集合的個數的鍵
* @return set集合的個數
*/
public Long sCard(String key){
try{
return redisTemplate.opsForSet().size(key);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* set基本指令 sRem 移除元素
* @param key 需要移除的set集合的鍵
* @param val 需要移除的值，可以是多個
* @return 回傳移除的個數
*/
public Long sRem(String key,Object... val){
try {
return redisTemplate.opsForSet().remove(key,val);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* set基本指令 sRandMember 隨機回傳元素的個數
* @param key 需要操作的det集合的鍵
* @param count 需要回傳元素的個數
* @return 回傳隨機元素的set集合
*/
public Set<Object> sRandMember(String key, long count){
try {
return redisTemplate.opsForSet().distinctRandomMembers(key,count);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sPop 隨機彈出一個元素
* @param key 需要操的set集合的鍵
* @return 彈出的元素
*/
public Object sPop(String key){
try {
return redisTemplate.opsForSet().pop(key);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sMove 把一個元素從一個集合移動到另一個集合
* @param oldSet 需要移動的集合
* @param newSet 需要到的集合
* @param val 移動的元素
* @return 回傳是否移動成功
*/
public Boolean sMove(String oldSet,String newSet,Object val){
try {
return redisTemplate.opsForSet().move(oldSet,val,newSet);
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* set基本指令 sDiff 兩個集合的差集 key1 - key2
* @param key1 第一個集合
* @param key2 第二個集合
* @return 回傳差集的集合
*/
public Set<Object> sDiff(String key1,String key2){
try {
return redisTemplate.opsForSet().difference(key1,key2);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sDiff 一個集合和多個集合的差集 key1 - key2 - key3 - ....
* @param key1 第一個集合
* @param otherKeys 其他集合
* @return 回傳差集的集合
*/
public Set<Object> sDiff(String key1, Collection<String> otherKeys){
try {
return redisTemplate.opsForSet().difference(key1,otherKeys);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sInter 一個集合和多個集合的交集
* @param key1
* @param key2
* @return
*/
public Set<Object> sInter(String key1,String key2){
try {
return redisTemplate.opsForSet().intersect(key1,key2);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sInter 一個集合和多個集合的交集
* @param key1 需要交的集合
* @param otherKeys 與它交的其他集合
* @return 回傳集合的交集
*/
public Set<Object> sInter(String key1,Collection<String> otherKeys){
try {
return redisTemplate.opsForSet().intersect(key1,otherKeys);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sInter 多個集合的交集
* @param keys 多個集合
* @return 回傳集合的交集
*/
public Set<Object> sInter(Collection<String> keys){
try {
return redisTemplate.opsForSet().intersect(keys);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sUnion 一個集合和多個集合的并集
* @param key 一個集合鍵
* @param otherKeys 多個集合鍵的集合
* @return 并集合
*/
public Set<Object> sUnion(String key,Collection<String> otherKeys){
try {
return redisTemplate.opsForSet().union(key,otherKeys);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sUnion 多個集合的并集
* @param otherKeys 多個集合鍵的集合
* @return 并集合
*/
public Set<Object> sUnion(Collection<String> otherKeys){
try {
return redisTemplate.opsForSet().union(otherKeys);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* set基本指令 sUnion 兩個個集合的并集
* @param key1 第一集合
* @param key2 第二個集合
* @return 并集合
*/
public Set<Object> sUnion(String key1,String key2){
try {
return redisTemplate.opsForSet().union(key1,key2);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* Hash基本指令 hSet 往hash存入一個map 鍵為k1 值v1
* @param key 需要存入的鍵
* @param hKey map中的一個鍵
* @param hValue map中該鍵對應的值
* @return 是否存盤成功
*/
public Boolean hSet(String key,Object hKey,Object hValue){
try {
redisTemplate.opsForHash().put(key,hKey,hValue);
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* Hash基本指令 hGet 取出hash存入一個map的鍵為k1的值
* @param key 需要取出的鍵
* @param hKey 需要取出該鍵對應map的那個鍵的值
* @return 回傳該map中這個鍵的值
*/
public Object hGet(String key,String hKey){
try {
return redisTemplate.opsForHash().get(key,hKey);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* Hash基本指令 hMSet 批量存盤map值
* @param key 存在的鍵
* @param map 存盤的map
* @return 存盤的map中的個數
*/
public Integer hMSet(String key,Map<String,Object> map){
try{
redisTemplate.opsForHash().putAll(key,map);
return map.size();
}catch (Exception e){
e.printStackTrace();
return 0;
}
}
/**
* Hash基本指令 hMSet 批量取出map值
* @param key 需要操作的鍵
* @param hKeys 需要取出map中鍵的集合
* @return 這些鍵的值
*/
public List<Object> hMGet(String key,List<String> hKeys){
try{
Collection<Object> collections = new CopyOnWriteArrayList<>(hKeys);
return redisTemplate.opsForHash().multiGet(key,collections);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* Hash基本指令 hKeys 獲取map中的全部鍵
* @param key 需要獲取map的鍵
* @return 回傳鍵的集合
*/
public Set<Object> hKeys(String key){
try{
return redisTemplate.opsForHash().keys(key);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* Hash基本指令 hValS 獲取map中的全部值
* @param key 需要獲取map的鍵
* @return 回傳值的集合
*/
public List<Object> hValS(String key){
try{
return redisTemplate.opsForHash().values(key);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* Hash基本指令 hDel 洗掉hash中指定hash的指定的鍵
* @param key 指定hash的鍵
* @param hKey 之間hash之中的鍵 為可變長引數
* @return 回傳洗掉的個數
*/
public Long hDel(String key,Object ... hKey){
try{
return redisTemplate.opsForHash().delete(key, hKey);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* Hash基本指令 hLen 獲取hash中的個數
* @param key hash的鍵
* @return 回傳個數
*/
public Long hLen(String key){
try {
return redisTemplate.opsForHash().size(key);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* Hash基本指令 hExists 判斷hash中指定的值是否存在
* @param key 需要判斷的hash的鍵
* @param hKey 需要判斷hash中的鍵
* @return 是否存在
*/
public Boolean hExists(String key,Object hKey){
try {
return redisTemplate.opsForHash().hasKey(key,hKey);
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* Hash基本指令 hGetAll 獲取map中的全部鍵值對
* @param key 需要獲取map的鍵
* @return 回傳所有鍵和值的map
*/
public Map<Object, Object> hGetAll(String key){
try {
return redisTemplate.opsForHash().entries(key);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* Hash基本指令 hIncrBy hash中鍵的值 + addNum
* @param key hash的鍵
* @param hKey 需要操作hash中的鍵
* @param addNum 增加的數，Long型別
* @return 回傳增加后的結果
*/
public Long hIncrBy(String key,Object hKey,Long addNum){
try{
return redisTemplate.opsForHash().increment(key,hKey,addNum);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* Hash基本指令 hIncrBy hash中鍵的值 + addNum
* @param key hash的鍵
* @param hKey 需要操作hash中的鍵
* @param addNum 增加的數，Double型別
* @return 回傳增加后的結果
*/
public Double hIncrBy(String key,Object hKey,Double addNum){
try{
return redisTemplate.opsForHash().increment(key,hKey,addNum);
}catch (Exception e){
e.printStackTrace();
return 0.0;
}
}
/**
* Hash基本指令 hSetNx hash中鍵如果存在就存盤失敗，反之
* @param key 需要存盤的hash的鍵
* @param hKey 存盤hash中的鍵
* @param val 存盤hash中的鍵對應的值
* @return 回傳是否存盤成功
*/
public Boolean hSetNx(String key,Object hKey,Object val){
try{
return redisTemplate.opsForHash().putIfAbsent(key, hKey, val);
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* zSet基本指令 zAdd 向有序集合中添加一個元素
* @param key 有序集合的鍵
* @param val 存入有序集合的值
* @param score 該值對應的序號，用來排序用的
* @return 回傳是否存盤成功
*/
public Boolean zAdd(String key,Object val,double score){
try {
return redisTemplate.opsForZSet().add(key,val,score);
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* zSet基本指令 zRange 獲取指定位置的資料
* @param key 需要獲取的有序集合的鍵
* @param start 開始的位置從0開始
* @param end 結束的位置
* @return 回傳獲取的集合
*/
public Set<Object> zRange(String key,long start,long end){
try {
return redisTemplate.opsForZSet().range(key,start,end);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* zSet基本指令 zRangeByScore 獲取指定位置的排好序的資料
* @param key 有序集合的鍵
* @param min 最小的值
* @param max 最大的值
* @return 回傳這個范圍排好序的集合
*/
public Set<Object> zRangeByScore(String key,double min,double max){
try {
return redisTemplate.opsForZSet().rangeByScore(key, min, max);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* zSet基本指令 zRangeByScore 獲取指定位置的排好序的資料帶上排序的值Score
* @param key 有序集合的鍵
* @param min 最小的值
* @param max 最大的值
* @return 回傳這個范圍排好序的集合帶有Score
*/
public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max){
try {
return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* zSet基本指令 zRem 移除有序集合中指定的元素
* @param key 有序集合的鍵
* @param val 需要移除的元素
* @return 回傳移除的個數
*/
public Long zRem(String key,Object ... val){
try {
return redisTemplate.opsForZSet().remove(key, val);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* zSet基本指令 zCard 獲取有序集合的個數
* @param key 有序集合的鍵
* @return 有序集合的個數
*/
public Long zCard(String key){
try{
return redisTemplate.opsForZSet().size(key);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* zSet基本指令 zCount 獲取有序集合指定范圍內的個數
* @param key 有序集合的鍵
* @param min 最小值范圍
* @param max 最大值范圍
* @return 回傳指定范圍有序集合的個數
*/
public Long zCount(String key,double min,double max){
try{
return redisTemplate.opsForZSet().count(key,min,max);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* Hyperloglog基本指令 pFAdd 儲存資料
* @param key 需要存盤的鍵
* @param val 需要存盤的值，可變引數
* @return 回傳1表示成功，0表示失敗
*/
public Long pFAdd(String key,Object ... val){
try {
return redisTemplate.opsForHyperLogLog().add(key,val);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* Hyperloglog基本指令 pFCount 獲取個數
* @param key 需要獲取鍵，可變長引數
* @return 當前這個Hyperloglog的個數
*/
public Long pFCount(String ... key){
try{
return redisTemplate.opsForHyperLogLog().size(key);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* Hyperloglog基本指令 pFMerge 把其他log的資料去重后合并到一個log中
* @param key 等待合并后的新log的鍵
* @param keys 需要合并的一些log的鍵，可變長引數
* @return 回傳合并后的個數
*/
public Long pFMerge(String key,String ... keys){
try {
return redisTemplate.opsForHyperLogLog().union(key,keys);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* geospatial 地理位置 基本指令 geoAdd 增加一個位置的坐標 經緯度
* @param key 需要操作地理位置的集合的key
* @param point 地理位置的物件，x表示經度，y表示維度
* @param member 存盤地理位置的名稱
* @return 回傳存盤的個數
*/
public Long geoAdd(String key, Point point, Object member){
try {
return redisTemplate.opsForGeo().add(key,point,member);
}catch (Exception e){
e.printStackTrace();
return 0L;
}
}
/**
* geospatial 地理位置 基本指令 geoPos 獲取多個城市的 經緯度
* @param key 需要獲取的鍵
* @param member 需要的獲取的地理位置名稱
* @return 回傳經緯度集合
*/
public List<Point> geoPos(String key, Object ... member){
try {
return redisTemplate.opsForGeo().position(key,member);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* geospatial 地理位置 基本指令 geoDist 獲取兩個城市之間的距離
* @param key 地理位置的集合
* @param member1 地理位置1
* @param member2 地理位置2
* @return 回傳兩個地理位置之間的距離，默認單位為米
*/
public Distance geoDist(String key, Object member1, Object member2){
try {
return redisTemplate.opsForGeo().distance(key,member1,member2);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* geospatial 地理位置 基本指令 geoRadius 距離地理位置集合中一個地理位置距離范圍內的地理位置
* @param key 地理位置集合的鍵
* @param member 地理位置名稱
* @param radius 范圍單位 米
* @return 回傳地理位置的集合資訊
*/
public GeoResults<RedisGeoCommands.GeoLocation<Object>> geoRadius(String key, Object member, double radius){
try {
return redisTemplate.opsForGeo().radius(key, member, radius);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* geospatial 地理位置 基本指令 geoRadius 距離給定一個經緯度的地理位置距離范圍內的地理位置
* @param key 地理位置集合的鍵
* @param circle 給定經緯度和范圍的物件 ，需要Point表經緯度和Distinct表示距離
* @return 回傳地理位置的集合資訊
*/
public GeoResults<RedisGeoCommands.GeoLocation<Object>> geoRadius(String key, Circle circle){
try {
return redisTemplate.opsForGeo().radius(key,circle);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* geospatial 地理位置 基本指令 geoHash 回傳一個位置的hash值，"wx4g0bm9xh0"
* @param key 需要操作的地理位置集合的鍵
* @param members 需要獲取hash值的地理位置
* @return 回傳hash值的集合
*/
public List<String> geoHash(String key, Object ... members){
try {
return redisTemplate.opsForGeo().hash(key,members);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/508048.html
標籤：Java