RedisTemplate用法详解

时间：2025-03-21 08:40:59

新增RedisTemplate封装工具类 : 最全的 基于 RedisTemplate 封装的 RedisUtils 工具类

Redis 可以存储键与5种不同数据结构类型之间的映射，这5种数据结构类型分别为String（字符串）、List（列表）、Set（集合）、Hash（散列）和 Zset（有序集合）。

Redis的String数据结构 

set void set(K key, V value);

().set("num","123");
().get("num")  输出结果为123

set void set(K key, V value, long timeout, TimeUnit unit); 

().set("num","123",10, );
().get("num")设置的是10秒失效，十秒之内查询有结果，十秒之后返回为null

set void set(K key, V value, long offset);

覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始

().set("key","hello world");
().set("key","redis", 6);
("***************"+().get("key"));
结果：***************hello redis

get V get(Object key);

().set("key","hello world");
("***************"+().get("key"));
结果：***************hello world

getAndSet V getAndSet(K key, V value); 

设置键的字符串值并返回其旧值

().set("getSetTest","test");
(().getAndSet("getSetTest","test2"));
结果：test

append Integer append(K key, String value);

如果key已经存在并且是一个字符串，则该命令将该值追加到字符串的末尾。如果键不存在，则它被创建并设置为空字符串，因此APPEND在这种特殊情况下将类似于SET。

().append("test","Hello");
(().get("test"));
().append("test","world");
(().get("test"));
Hello
Helloworld

size Long size(K key);
返回key所对应的value值得长度

().set("key","hello world");
("***************"+().size("key"));
***************11

Redis的List数据结构

Long size(K key);
返回存储在键中的列表的长度。如果键不存在，则将其解释为空列表，并返回0。当key存储的值不是列表时返回错误。

(().size("list"));
6

Long leftPush(K key, V value);
将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从左边插入）

().leftPush("list","java");
().leftPush("list","python");
().leftPush("list","c++");
返回的结果为推送操作后的列表的长度
1
2
3

Long leftPushAll(K key, V... values);
批量把一个数组插入到列表中

String[] strs = new String[]{"1","2","3"};
().leftPushAll("list",strs);
(().range("list",0,-1));
[3, 2, 1]

Long rightPush(K key, V value);
将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从右边插入）

().rightPush("listRight","java");
().rightPush("listRight","python");
().rightPush("listRight","c++");
1
2
3

Long rightPushAll(K key, V... values);

String[] strs = new String[]{"1","2","3"};
().rightPushAll("list",strs);
(().range("list",0,-1));
[1, 2, 3]

void set(K key, long index, V value);
在列表中index的位置设置value值

(().range("listRight",0,-1));
().set("listRight",1,"setValue");
(().range("listRight",0,-1));
[java, python, oc, c++]
[java, setValue, oc, c++]

Long remove(K key, long count, Object value);
从存储在键中的列表中删除等于值的元素的第一个计数事件。
计数参数以下列方式影响操作：
count> 0：删除等于从头到尾移动的值的元素。
count <0：删除等于从尾到头移动的值的元素。
count = 0：删除等于value的所有元素。

(().range("listRight",0,-1));
().remove("listRight",1,"setValue");//将删除列表中存储的列表中第一次次出现的“setValue”。
(().range("listRight",0,-1));
[java, setValue, oc, c++]
[java, oc, c++]

V index(K key, long index);
根据下表获取列表中的值，下标是从0开始的

(().range("listRight",0,-1));
(().index("listRight",2));
[java, oc, c++]
c++

V leftPop(K key);
弹出最左边的元素，弹出之后该值在列表中将不复存在

(().range("list",0,-1));
(().leftPop("list"));
(().range("list",0,-1));
[c++, python, oc, java, c#, c#]
c++
[python, oc, java, c#, c#]

V rightPop(K key);
弹出最右边的元素，弹出之后该值在列表中将不复存在

(().range("list",0,-1));
(().rightPop("list"));
(().range("list",0,-1));
[python, oc, java, c#, c#]
c#
[python, oc, java, c#]

Redis的Hash数据机构

Long delete(H key, Object... hashKeys);
删除给定的哈希hashKeys

(().delete("redisHash","name"));
(().entries("redisHash"));
1
{class=6, age=28.1}

Boolean hasKey(H key, Object hashKey);
确定哈希hashKey是否存在

(().hasKey("redisHash","666"));
(().hasKey("redisHash","777"));
true
false

HV get(H key, Object hashKey);
从键中的哈希获取给定hashKey的值

(().get("redisHash","age"));
26

 Set<HK> keys(H key);
获取key所对应的散列表的key

(().keys("redisHash"));
//redisHash所对应的散列表为{class=1, name=666, age=27}
[name, class, age]

Long size(H key);
获取key所对应的散列表的大小个数

(().size("redisHash"));
//redisHash所对应的散列表为{class=1, name=666, age=27}
3

 void putAll(H key, Map<? extends HK, ? extends HV> m);
使用m中提供的多个散列字段设置到key对应的散列表中

Map<String,Object> testMap = new HashMap();
("name","666");
("age",27);
("class","1");
().putAll("redisHash1",testMap);
(().entries("redisHash1"));
{class=1, name=jack, age=27}

 void put(H key, HK hashKey, HV value);
设置散列hashKey的值

().put("redisHash","name","666");
().put("redisHash","age",26);
().put("redisHash","class","6");
(().entries("redisHash"));
{age=26, class=6, name=666}

 List<HV> values(H key);
获取整个哈希存储的值根据密钥

(().values("redisHash"));
[tom, 26, 6]

 Map<HK, HV> entries(H key);
获取整个哈希存储根据密钥

(().entries("redisHash"));
{age=26, class=6, name=tom}

 Cursor<<HK, HV>> scan(H key, ScanOptions options);
使用Cursor在key的hash中迭代，相当于迭代器。

Cursor<<Object, Object>> curosr = ().scan("redisHash", 
  );
    while(()){
        <Object, Object> entry = ();
        (()+":"+());
    }
age:27
class:6
name:666

Redis的Set数据结构

Long add(K key, V... values);
无序集合中添加元素，返回添加个数
也可以直接在add里面添加多个值 如：().add("setTest","aaa","bbb")

String[] strs= new String[]{"str1","str2"};
(().add("setTest", strs));
2

 Long remove(K key, Object... values);
移除集合中一个或多个成员

String[] strs = new String[]{"str1","str2"};
(().remove("setTest",strs));
2

 V pop(K key);
移除并返回集合中的一个随机元素

(().pop("setTest"));
(().members("setTest"));
bbb
[aaa, ccc]

 Boolean move(K key, V value, K destKey);
将 member 元素从 source 集合移动到 destination 集合

().move("setTest","aaa","setTest2");
(().members("setTest"));
(().members("setTest2"));
[ccc]
[aaa]

 Long size(K key);
无序集合的大小长度

(().size("setTest"));
1

Set<V> members(K key);
返回集合中的所有成员

(().members("setTest"));
[ddd, bbb, aaa, ccc]

 Cursor<V> scan(K key, ScanOptions options);
遍历set

Cursor<Object> curosr = ().scan("setTest", );
  while(()){
     (());
  }
ddd
bbb
aaa
ccc

Redis的ZSet数据结构 

Boolean add(K key, V value, double score);
新增一个有序集合，存在的话为false，不存在的话为true

(().add("zset1","zset-1",1.0));
true

 Long add(K key, Set<TypedTuple<V>> tuples);
新增一个有序集合

<Object> objectTypedTuple1 = new DefaultTypedTuple<>("zset-5",9.6);
<Object> objectTypedTuple2 = new DefaultTypedTuple<>("zset-6",9.9);
Set<<Object>> tuples = new HashSet<<Object>>();
(objectTypedTuple1);
(objectTypedTuple2);
(().add("zset1",tuples));
(().range("zset1",0,-1));
[zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]

Long remove(K key, Object... values);
从有序集合中移除一个或者多个元素

(().range("zset1",0,-1));
(().remove("zset1","zset-6"));
(().range("zset1",0,-1));
[zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]
1
[zset-1, zset-2, zset-3, zset-4, zset-5]

 Long rank(K key, Object o);
返回有序集中指定成员的排名，其中有序集成员按分数值递增(从小到大)顺序排列

(().range("zset1",0,-1));
(().rank("zset1","zset-2"));
[zset-2, zset-1, zset-3, zset-4, zset-5]
0   //表明排名第一

Set<V> range(K key, long start, long end);
通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列

(().range("zset1",0,-1));
[zset-2, zset-1, zset-3, zset-4, zset-5]

Long count(K key, double min, double max);
通过分数返回有序集合指定区间内的成员个数

(().rangeByScore("zset1",0,5));
(().count("zset1",0,5));
[zset-2, zset-1, zset-3]
3

Long size(K key);
获取有序集合的成员数，内部调用的就是zCard方法

(().size("zset1"));
6

 Double score(K key, Object o);
获取指定成员的score值

(().score("zset1","zset-1"));
2.2

Long removeRange(K key, long start, long end);
移除指定索引位置的成员，其中有序集成员按分数值递增(从小到大)顺序排列

(().range("zset2",0,-1));
(().removeRange("zset2",1,2));
(().range("zset2",0,-1));
[zset-1, zset-2, zset-3, zset-4]
2
[zset-1, zset-4]

Cursor<TypedTuple<V>> scan(K key, ScanOptions options);
遍历zset

Cursor<<Object>> cursor = ().scan("zzset1", );
    while (()){
       <Object> item = ();
       (() + ":" + ());
    }
zset-1:1.0
zset-2:2.0
zset-3:3.0
zset-4:6.0

相关文章