RedisTemplate使用详情简介（二）

最新推荐文章于 2025-02-28 23:42:38 发布

Trouble-Solver

最新推荐文章于 2025-02-28 23:42:38 发布

阅读量838

点赞数 3

分类专栏： redis

本文链接：https://blog.youkuaiyun.com/syq8023/article/details/105968815

版权

redis 专栏收录该内容

2 篇文章

订阅专栏

Redis存储介绍：

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

Spring-data-redis介绍:

Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问redis服务，对reids底层开发包(Jedis,JRedis, and RJC)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1cache进行了实现。

官网：http://projects.spring.io/spring-data-redis/
项目地址：https://github.com/spring-projects/spring-data-redis

一、spring-data-redis功能介绍

jedis客户端在编程实施方面存在如下不足：

connection管理缺乏自动化，connection-pool的设计缺少必要的容器支持。
数据操作需要关注“序列化”/“反序列化”，因为jedis的客户端API接受的数据类型为string和byte，对结构化数据 (json,xml,pojo等)操作需要额外的支持。
事务操作纯粹为硬编码。
pub/sub功能，缺乏必要的设计模式支持，对于开发者而言需要关注的太多。

spring-data-redis针对jedis提供了如下功能：
1.连接池自动管理，提供了一个高度封装的“RedisTemplate”类
2.针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口

ValueOperations：简单K-V操作
SetOperations：set类型数据操作
ZSetOperations：zset类型数据操作
HashOperations：针对map类型的数据操作
ListOperations：针对list类型的数据操作

3.提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key，即BoundKeyOperations：

BoundValueOperations
BoundSetOperations
BoundListOperations
BoundSetOperations
BoundHashOperations

4.将事务操作封装，有容器控制。
5.针对数据的“序列化/反序列化”，提供了多种可选择策略(RedisSerializer)
**

二 Redis的String数据结构

set void set(K key, V value);

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

set void set(K key, V value, long timeout, TimeUnit unit);
- TimeUnit.DAYS //天
- TimeUnit.HOURS //小时
- TimeUnit.MINUTES //分钟
- TimeUnit.SECONDS //秒
- TimeUnit.MILLISECONDS //毫秒**

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

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

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

		template.opsForValue().set("key","hello world");
		template.opsForValue().set("key","redis", 6);
		System.out.println("***************"+template.opsForValue().get("key"));

结果：***************hello redis

get V get(Object key);

		template.opsForValue().set("key","hello world");
		System.out.println("***************"+template.opsForValue().get("key"));

   	结果：***************hello world

getAndSet V getAndSet(K key, V value);

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

 		template.opsForValue().set("getSetTest","test");
		System.out.println(template.opsForValue().getAndSet("getSetTest","test2"));

结果：test

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

		template.opsForValue().append("test","Hello");
		System.out.println(template.opsForValue().get("test"));
		template.opsForValue().append("test","world");
		System.out.println(template.opsForValue().get("test"));
		Hello
		Helloworld

size Long size(K key);

返回key所对应的value值得长度

	template.opsForValue().set("key","hello world");
	System.out.println("***************"+template.opsForValue().size("key"));

结果：***************11

三、Redis的List数据结构

Long size(K key);

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

System.out.println(template.opsForList().size("list"));

Long leftPush(K key, V value);

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

template.opsForList().leftPush("list","java");
template.opsForList().leftPush("list","python");
template.opsForList().leftPush("list","c++");

返回的结果为推送操作后的列表的长度

Long leftPushAll(K key, V… values);

批量把一个数组插入到列表中

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

结果：[3, 2, 1]

Long rightPush(K key, V value);

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

template.opsForList().rightPush("listRight","java");
template.opsForList().rightPush("listRight","python");
template.opsForList().rightPush("listRight","c++");

Long rightPushAll(K key, V… values);

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

[1, 2, 3]

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

在列表中index的位置设置value值

System.out.println(template.opsForList().range("listRight",0,-1));
template.opsForList().set("listRight",1,"setValue");
System.out.println(template.opsForList().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的所有元素。

System.out.println(template.opsForList().range("listRight",0,-1));
template.opsForList().remove("listRight",1,"setValue");//将删除列表中存储的列表中第一次次出现的“setValue”。
System.out.println(template.opsForList().range("listRight",0,-1));

[java, setValue, oc, c++]
[java, oc, c++]

V index(K key, long index);

根据下表获取列表中的值，下标是从0开始的

System.out.println(template.opsForList().range("listRight",0,-1));
System.out.println(template.opsForList().index("listRight",2));

[java, oc, c++]
c++

V leftPop(K key);

弹出最左边的元素，弹出之后该值在列表中将不复存在

System.out.println(template.opsForList().range("list",0,-1));
System.out.println(template.opsForList().leftPop("list"));
System.out.println(template.opsForList().range("list",0,-1));

[c++, python, oc, java, c#, c#]
c++
[python, oc, java, c#, c#]

V rightPop(K key);

弹出最右边的元素，弹出之后该值在列表中将不复存在

System.out.println(template.opsForList().range("list",0,-1));
System.out.println(template.opsForList().rightPop("list"));
System.out.println(template.opsForList().range("list",0,-1));

[python, oc, java, c#, c#]
c#
[python, oc, java, c#]

四、Redis的Hash数据机构

Long delete(H key, Object… hashKeys);

删除给定的哈希hashKeys

System.out.println(template.opsForHash().delete("redisHash","name"));
System.out.println(template.opsForHash().entries("redisHash"));

{class=6, age=28.1}

Boolean hasKey(H key, Object hashKey);

确定哈希hashKey是否存在

System.out.println(template.opsForHash().hasKey("redisHash","666"));
System.out.println(template.opsForHash().hasKey("redisHash","777"));

true
false

HV get(H key, Object hashKey);

从键中的哈希获取给定hashKey的值

System.out.println(template.opsForHash().get("redisHash","age"));

26

Set keys(H key);

获取key所对应的散列表的key

System.out.println(template.opsForHash().keys("redisHash"));
//redisHash所对应的散列表为{class=1, name=666, age=27}

[name, class, age]

Long size(H key);

获取key所对应的散列表的大小个数

System.out.println(template.opsForHash().size("redisHash"));

//redisHash所对应的散列表为{class=1, name=666, age=27}

void putAll(H key, Map<? extends HK, ? extends HV> m);

使用m中提供的多个散列字段设置到key对应的散列表中

Map<String,Object> testMap = new HashMap();
testMap.put("name","666");
testMap.put("age",27);
testMap.put("class","1");
template.opsForHash().putAll("redisHash1",testMap);
System.out.println(template.opsForHash().entries("redisHash1"));

{class=1, name=jack, age=27}

void put(H key, HK hashKey, HV value);

设置散列hashKey的值

template.opsForHash().put("redisHash","name","666");
template.opsForHash().put("redisHash","age",26);
template.opsForHash().put("redisHash","class","6");
System.out.println(template.opsForHash().entries("redisHash"));

{age=26, class=6, name=666}

List values(H key);

获取整个哈希存储的值根据密钥

System.out.println(template.opsForHash().values("redisHash"));

[tom, 26, 6]

Map<HK, HV> entries(H key);

获取整个哈希存储根据密钥

System.out.println(template.opsForHash().entries("redisHash"));

{age=26, class=6, name=tom}

Cursor<Map.Entry<HK, HV>> scan(H key, ScanOptions options);

使用Cursor在key的hash中迭代，相当于迭代器。

Cursor<Map.Entry<Object, Object>> curosr = template.opsForHash().scan("redisHash",    ScanOptions.ScanOptions.NONE);
    while(curosr.hasNext()){
        Map.Entry<Object, Object> entry = curosr.next();
        System.out.println(entry.getKey()+":"+entry.getValue());
    }

age:27
class:6
name:666

五、Redis的Set数据结构

Long add(K key, V… values);

无序集合中添加元素，返回添加个数也可以直接在add里面添加多个值
如：template.opsForSet().add(“setTest”,“aaa”,“bbb”)

String[] strs= new String[]{"str1","str2"};
System.out.println(template.opsForSet().add("setTest", strs));

Long remove(K key, Object… values);

移除集合中一个或多个成员

String[] strs = new String[]{"str1","str2"};
System.out.println(template.opsForSet().remove("setTest",strs));

2

V pop(K key);

移除并返回集合中的一个随机元素

System.out.println(template.opsForSet().pop("setTest"));
System.out.println(template.opsForSet().members("setTest"));

bbb
[aaa, ccc]

Boolean move(K key, V value, K destKey);

将 member 元素从 source 集合移动到 destination 集合

template.opsForSet().move("setTest","aaa","setTest2");
System.out.println(template.opsForSet().members("setTest"));
System.out.println(template.opsForSet().members("setTest2"));

[ccc]
[aaa]

Long size(K key);

无序集合的大小长度

System.out.println(template.opsForSet().size("setTest"));

1

Set members(K key);

返回集合中的所有成员

System.out.println(template.opsForSet().members("setTest"));

[ddd, bbb, aaa, ccc]

Cursor scan(K key, ScanOptions options);

遍历set

Cursor<Object> curosr = template.opsForSet().scan("setTest", ScanOptions.NONE);
  while(curosr.hasNext()){
     System.out.println(curosr.next());
  }

ddd
bbb
aaa
ccc

六、Redis的ZSet数据结构

Boolean add(K key, V value, double score);

新增一个有序集合，存在的话为false，不存在的话为true

System.out.println(template.opsForZSet().add("zset1","zset-1",1.0));
true

Long add(K key, Set<TypedTuple> tuples);

新增一个有序集合

ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>("zset-5",9.6);
ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>("zset-6",9.9);
Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<ZSetOperations.TypedTuple<Object>>();
tuples.add(objectTypedTuple1);
tuples.add(objectTypedTuple2);
System.out.println(template.opsForZSet().add("zset1",tuples));
System.out.println(template.opsForZSet().range("zset1",0,-1));

[zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]

Long remove(K key, Object… values);

从有序集合中移除一个或者多个元素

System.out.println(template.opsForZSet().range("zset1",0,-1));
System.out.println(template.opsForZSet().remove("zset1","zset-6"));
System.out.println(template.opsForZSet().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);

返回有序集中指定成员的排名，其中有序集成员按分数值递增(从小到大)顺序排列

System.out.println(template.opsForZSet().range("zset1",0,-1));
System.out.println(template.opsForZSet().rank("zset1","zset-2"));

[zset-2, zset-1, zset-3, zset-4, zset-5]
0 //表明排名第一

Set range(K key, long start, long end);

通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列

System.out.println(template.opsForZSet().range("zset1",0,-1));

[zset-2, zset-1, zset-3, zset-4, zset-5]

Long count(K key, double min, double max);

通过分数返回有序集合指定区间内的成员个数

System.out.println(template.opsForZSet().rangeByScore("zset1",0,5));
System.out.println(template.opsForZSet().count("zset1",0,5));

[zset-2, zset-1, zset-3]
3

Long size(K key);

获取有序集合的成员数，内部调用的就是zCard方法

System.out.println(template.opsForZSet().size("zset1"));

6

Double score(K key, Object o);

获取指定成员的score值

System.out.println(template.opsForZSet().score("zset1","zset-1"));

2.2

Long removeRange(K key, long start, long end);

移除指定索引位置的成员，其中有序集成员按分数值递增(从小到大)顺序排列

System.out.println(template.opsForZSet().range("zset2",0,-1));
System.out.println(template.opsForZSet().removeRange("zset2",1,2));
System.out.println(template.opsForZSet().range("zset2",0,-1));

[zset-1, zset-2, zset-3, zset-4]
2
[zset-1, zset-4]

Cursor<TypedTuple> scan(K key, ScanOptions options);

遍历zset

Cursor<ZSetOperations.TypedTuple<Object>> cursor = template.opsForZSet().scan("zzset1", ScanOptions.NONE);
    while (cursor.hasNext()){
       ZSetOperations.TypedTuple<Object> item = cursor.next();
       System.out.println(item.getValue() + ":" + item.getScore());
    }

zset-1:1.0
zset-2:2.0
zset-3:3.0
zset-4:6.0