redisTemplate 方法总结

客官°小女子只卖身不卖艺 2023-01-15 08:29 131阅读 0赞

jedis 封装参考：  
[https://blog.csdn.net/leinminna/article/details/116042493][https_blog.csdn.net_leinminna_article_details_116042493]

### 1. redis五大基础数据类型 ###

@Resource
    		    private RedisTemplate<String, T> redisTemplate;
    		    
                /** * redis五大基础数据类型 * T 限制redis 保存的数据类型 */
                redisTemplate.opsForValue().set("string_key", (T) "value");
                redisTemplate.opsForHash().put("hash_key","fieldName","fieldValue");
                redisTemplate.opsForList().rightPush("list_key",(T) "itemValue");
                redisTemplate.opsForSet().add("set_key",(T) "item1");
                redisTemplate.opsForZSet().add("zset_key",(T) "item1",0.1);
    
    			/** * redis集群操作方法 */
                redisTemplate.opsForCluster();
                redisTemplate.opsForGeo();
                redisTemplate.opsForHyperLogLog();

### 2. String 封装方法 ###

/** * remove by key * @param key * @return */
        public <T> T remove(String key) { 
            T v = (T) redisTemplate.opsForValue().get(key);
            del(key);
            return v;
        }
        /** * 普通缓存获取 * * @param key 键 * @return 值 */
        public T get(String key) { 
            ValueOperations<String, T> opsForValue = redisTemplate.opsForValue();
            return key == null ? null : opsForValue.get(key);
        }
    
        public <T> T get(String key, Class<T> claz) { 
            return key == null ? null : claz.cast(redisTemplate.opsForValue().get(key));
        }
    
        /** * 普通缓存放入 * * @param key 键 * @param value 值 * @return true成功 false失败 */
        public boolean set(String key, T value) { 
            try { 
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
    
        }
    
        public boolean setIfAbsent(String key, T value, long expireTime) { 
            try { 
                Boolean a = redisTemplate.opsForValue().setIfAbsent(key, value, expireTime, TimeUnit.SECONDS);
                return a;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 普通缓存放入并设置时间 * * @param key 键 * @param value 值 * @param ttl 时间(秒) ttl要大于0 如果time小于等于0 将设置无限期 * @return true成功 false 失败 */
        public boolean set(String key, T value, long ttl) { 
            try { 
                if (ttl > 0) { 
                    redisTemplate.opsForValue().set(key, value, ttl, TimeUnit.SECONDS);
                } else { 
                    redisTemplate.opsForValue().set(key, value);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 保存 k-v 数据，并设置失效时间 * * @param key key * @param value 数据 * @param time 失效期 * @return 操作结果 */
        public boolean set(String key, T value, Date time) { 
            try { 
    
                redisTemplate.opsForValue().set(key, value);
                if (time != null) { 
                    redisTemplate.expireAt(key, time);
                }
                return true;
    
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 递增 * * @param key 键 * @param delta 要增加几(大于0) * @return */
        public long incr(String key, long delta) { 
            if (delta < 0) { 
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
        /** * 递减 * * @param key 键 * @param delta 要减少几(小于0) * @return */
        public long decr(String key, long delta) { 
            if (delta < 0) { 
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }

### 3. hash 封装方法 ###

/** * HashGet，不指定返回类型 * * @param key 键 不能为null * @param item 项 不能为null * @return 值 */
        public T hget(String key, String item) { 
            HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
            return opsForHash.get(key, item);
        }
    
        /** * 将item 的值获取，然后转化为 指定类型的对象 * * @param key hash的key * @param item item 名称 * @param claz item 指定参数是T的calss * @param <T> 指定T 的类型，不指定T 默认为对象 * @return T类型数据，没有指定返回的是JSON对象 */
        public <T> T hget(String key, String item, Class<T> claz) { 
    
            HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
            return claz.cast(opsForHash.get(key, item));
        }
    
    
        /** * 获取hashKey对应的所有键值对 * * @param key 键 * @return 对应的多个键值 */
        public Map<String, T> hmget(String key) { 
            HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
            return opsForHash.entries(key);
        }
    
        /** * HashSet * * @param key 键 * @param map 对应多个键值 * @return true 成功 false 失败 */
        public boolean hmset(String key, Map<String, T> map) { 
            try { 
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * HashSet 并设置时间 * * @param key 键 * @param map 对应多个键值 * @param time 时间(秒) * @return true成功 false失败 */
        public boolean hmset(String key, Map<String, T> map, long time) { 
            try { 
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) { 
                    expire(key, time);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 向一张hash表中放入数据,如果不存在将创建 * * @param key 键 * @param item 项 * @param value 值 * @return true 成功 false失败 */
        public boolean hset(String key, String item, T value) { 
            try { 
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 向一张hash表中放入数据,如果不存在将创建 * * @param key 键 * @param item 项 * @param value 值 * @param ttl 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间 * @return true 成功 false失败 */
        public boolean hset(String key, String item, T value, long ttl) { 
            try { 
                redisTemplate.opsForHash().put(key, item, value);
                if (ttl > 0) { 
                    expire(key, ttl);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 将对象 key 的item 属性值 value 保存 * 并设置有效整个对象 key 的失效时间 * * @param key 可以看作是对象的名称 * @param item 对象的属性名称 * @param value 属性值 * @param time 失效时间 * @return 操作结果 */
        public boolean hset(String key, String item, T value, Date time) { 
            try { 
    
                redisTemplate.opsForHash().put(key, item, value);
                if (time != null) { 
                    redisTemplate.expireAt(key, time);
                }
                return true;
    
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 删除hash表中的值 * * @param key 键 不能为null * @param item 项 可以使多个 不能为null */
        public void hdel(String key, T... item) { 
            redisTemplate.opsForHash().delete(key, item);
        }
    
        /** * 判断hash表中是否有该项的值 * * @param key 键 不能为null * @param item 项 不能为null * @return true 存在 false不存在 */
        public boolean hHasKey(String key, String item) { 
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
        /** * hash递增 如果不存在,就会创建一个 并把新增后的值返回 * * @param key 键 * @param item 项 * @param by 要增加几(大于0) * @return */
        public double hincr(String key, String item, double by) { 
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
        /** * hash递减 * * @param key 键 * @param item 项 * @param by 要减少记(小于0) * @return */
        public double hdecr(String key, String item, double by) { 
            return redisTemplate.opsForHash().increment(key, item, -by);
        }

### 4.list ###

/** * 获取list缓存的内容 * * @param key 键 * @param start 开始 * @param end 结束 0 到 -1代表所有值 * @return */
        public List<T> lGet(String key, long start, long end) { 
            try { 
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 获取list缓存的长度 * * @param key 键 * @return */
        public long lGetListSize(String key) { 
            try { 
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    
        /** * 通过索引 获取list中的值 * * @param key 键 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推 * @return */
        public Object lGetIndex(String key, long index) { 
            try { 
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 将list放入缓存 * * @param key 键 * @param value 值 * @return */
        public boolean lSet(String key, T value) { 
            try { 
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 将list放入缓存 * * @param key 键 * @param value 值 * @param time 时间(秒) * @return */
        public boolean lSet(String key, T value, long time) { 
            try { 
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0)
                    expire(key, time);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 将list放入缓存 * * @param key 键 * @param value 值 * @return */
        public boolean lSet(String key, List<T> value) { 
            try { 
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 将list放入缓存 * * @param key 键 * @param value 值 * @param time 时间(秒) * @return 是否设置成功 */
        public boolean lSet(String key, List<T> value, long time) { 
            try { 
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0)
                    expire(key, time);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 根据索引修改list中的某条数据 * * @param key 键 * @param index 索引 * @param value 值 * @return 是否更新成功 */
        public boolean lUpdateIndex(String key, long index, T value) { 
            try { 
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 移除N个值为value * * @param key 键 * @param count 移除前count个值等于value的项. * count=0: 移除全部，count<0: 从后到前移除, count>0: 从前到后移除 * @param value 值 * @return 实际移除的个数 */
        public long lRemove(String key, long count, T value) { 
            try { 
                return redisTemplate.opsForList().remove(key, count, value);
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }

### 5.set ###

/** * 根据key获取Set中的所有值 * * @param key 键 * @return */
        public Set<T> sGet(String key) { 
            try { 
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 根据value从一个set中查询,是否存在 * * @param key 键 * @param value 值 * @return true 存在 false不存在 */
        public boolean sHasKey(String key, T value) { 
            try { 
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 将数据放入set缓存 * * @param key 键 * @param values 值 可以是多个 * @return 成功个数 */
        public long sSet(String key, T... values) { 
            try { 
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    
        /** * 将set数据放入缓存 * * @param key 键 * @param time 时间(秒) * @param values 值 可以是多个 * @return 成功个数 */
        public long sSetAndTime(String key, long time, T... values) { 
            try { 
                Long count = redisTemplate.opsForSet().add(key, values);
                if (time > 0)
                    expire(key, time);
                return count;
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    
        /** * 获取set缓存的长度 * * @param key 键 * @return */
        public long sGetSetSize(String key) { 
            try { 
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }
    
        /** * 移除值为value的 * * @param key 键 * @param values 值 可以是多个 * @return 移除的个数 */
        public long setRemove(String key, T... values) { 
            try { 
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) { 
                e.printStackTrace();
                return 0;
            }
        }

### 6.key的封装 ###

/** * 指定缓存失效时间 * * @param key 键 * @param ttl 生存时间(秒) * @return */
        public boolean expire(String key, long ttl) { 
            try { 
                if (ttl > 0) { 
                    redisTemplate.expire(key, ttl, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        public boolean expireAt(String key, long time) { 
            try { 
                if (time > 0) { 
                    redisTemplate.expireAt(key, new Date(time));
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 根据key 获取过期时间 * * @param key 键 不能为null * @return 时间(秒) 返回0代表为永久有效 */
        public long getExpire(String key) { 
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        /** * 判断key是否存在 * * @param key 键 * @return true 存在 false不存在 */
        public boolean hasKey(String key) { 
            try { 
                return redisTemplate.hasKey(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 删除缓存 * * @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));
                }
            }
        }

[https_blog.csdn.net_leinminna_article_details_116042493]: https://blog.csdn.net/leinminna/article/details/116042493