SpringBoot整合Redis（RedisTemplate5种数据类型的用法）_springboot redistemplate

SpringDataRedis

Spring Data Redis 是 Spring Data 系列的一部分，它提供了从 Spring 应用程序对 Redis 的轻松配置和访问。它提供了与商店交互的低级和高级抽象，使用户摆脱了对基础设施的担忧。

SpringDataRedis能干什么？

提供了对不同 Redis 客户端的整合（Lettuce 和 Jedis），默认是 Lettuce

提供了 RedisTemplate 统一 API 来操作 Redis

支持 Redis 的发布订阅模型

支持 Redis 哨兵和 Redis 集群

支持基于 Lettuce 的响应式编程

支持基于 JDK、JSON、字符串、Spring 对象的数据序列化及反序列化

支持基于 Redis 的 JDKCollection 实现

Jedis与RedisTemplate

在java开发中操作redis常用的就是集成RedisTemplate与Jedis这两种方式。RedisTemplate与spring整合较好，配置、操作比较简单。jedis性能较强，jedis结合jedisPool使用既可以有高性能又可以保证redis的连接可控。在性能要求、并发操作不高的场景建议使用RedisTemplate，在并发高，性能要求高的场景下建议使用Jedis。本文只介绍RedisTemplate。

RedisTemplate的API

RedisTemplate怎么用？

引入 spring-boot-starter-data-redis 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1
2
3
4

在 application.yml 配置 Redis 的信息

server:
  port: 8888
spring:
  application:
    name: redisTemplateDemo
  redis:
    port: 6379
    host:#服务器公网IP
    database: 0
    lettuce:
      pool:
        max-active: 8 #最大连接
        max-idle: 8 #最大空闲连接
        min-idle: 0 #最小空闲连接
        max-wait: 100ms #连接等待时间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

编写RedisConfig配置文件进行序列化否则使用可视化工具访问会乱码

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        //配置连接工厂
        template.setConnectionFactory(redisConnectionFactory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSerialize  = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public=
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); //如果过期，用下面的方法来代替
        //om.activateDefaultTyping(BasicPolymorphicTypeValidator.builder().build(), ObjectMapper.DefaultTyping.NON_FINAL);
        om.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        om.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        jacksonSerialize.setObjectMapper(om);
        // value序列化方式采用jackson
        template.setValueSerializer(jacksonSerialize);
        // key采用String的序列化方式
        template.setKeySerializer(new StringRedisSerializer());
        // 对hash的key采用String的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        // 对hash的value采用jackson的序列化方式
        template.setHashValueSerializer(jacksonSerialize);
        template.afterPropertiesSet();
        return template;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

注入 RedisTemplate

@Service
public class RedisService {
    @Resource
    RedisTemplate redisTemplate;
}
1
2
3
4
5

RedisTemplate的直接方法

//删除key
redisTemplate.delete(key);
//删除多个key
redisTemplate.delete(keys);
//设置key的过期时间
redisTemplate.expire(key,time,TimeUnit.MINUTES);
//根据key获取过期时间
redisTemplate.getExpire(key);
//返回剩余过期时间并且指定时间单位
redisTemplate.getExpire(key, unit);
//判断是否存在
redisTemplate.hasKey(key)
//修改key的名称
redisTemplate.rename(oldKey, newKey);
//查找匹配的key值，返回一个Set集合类型
redisTemplate.keys(pattern);
//将key持久化保存
redisTemplate.persist(key);
//将当前数据库的key移动到指定redis中数据库当中
redisTemplate.move(key, dbIndex);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

String类型相关操作（opsForValue()）

设置当前的key以及value值

redisTemplate.opsForValue().set(key, value)
1

根据key获取value

redisTemplate.opsForValue().get(key)
1

批量获取值

redisTemplate.opsForValue().multiGet(keys);
1

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

redisTemplate.renameIfAbsent(oldKey, newKey);
1

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

redisTemplate.opsForValue().set(key, value, timeout, unit)
//eg  设置age为10，5秒后失效
redisTemplate.opsForValue().set("age",10,5, TimeUnit.SECONDS);
1
2
3

将旧的key设置为value，并且返回旧的key

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

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

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

获取key对应value的长度

redisTemplate.opsForValue().size(key)
1

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

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

批量设置的key以及value值

 Map valueMap = new HashMap();
 valueMap.put("k1","v1");
 valueMap.put("k1","v1");
 valueMap.put("k1","v1");
 redisTemplate.opsForValue().multiSet(valueMap);
1
2
3
4
5

批量设置的key以及value值,若某个key已经存在不做修改，不存在的则新增

Map valueMap = new HashMap();
 valueMap.put("k1","v1");
 valueMap.put("k1","v1");
 valueMap.put("k1","v1");
 redisTemplate.opsForValue().multiSetIfAbsent(valueMap);
1
2
3
4
5

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

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

Hash类型相关操作（opsForHash()）

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

设置Hash值

redisTemplate.opsForHash().put(key, hashKey, value)
//eg
redisTemplate.opsForHash().put("student", "name", "zs");
1
2
3

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

 redisTemplate.opsForHash().putAll(key, maps);
//eg
 HashMap<String,Object> map = new HashMap<>();
 map.put("age",23);
 map.put("score",60);
 redisTemplate.opsForHash().putAll("student",map);
1
2
3
4
5
6

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

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

获取变量中的键值对

redisTemplate.opsForHash().entries(key);
1

仅当hashKey不存在时才设置

redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
1

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

redisTemplate.opsForHash().delete(key, fields);
1

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

redisTemplate.opsForHash().hasKey(key, field);
1

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

redisTemplate.opsForHash().increment(key, field, increment);
1

获取所有hash表中字段

redisTemplate.opsForHash().keys(key)
1

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

redisTemplate.opsForHash().values(key);
1

获取hash表中字段的数量

redisTemplate.opsForHash().size(key)
1

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

//options 为 ScanOptions类型对象 
redisTemplate.opsForHash().scan(key, options);
1
2

List类型相关操作（opsForList()）

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

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

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

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

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

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

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

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

List存在的时候再加入

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

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

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

设置指定索引处元素的值

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

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

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

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

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

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

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

删除集合中值等于value的元素(index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素; index<0, 从尾部开始删除第一个值等于value的元素)

redisTemplate.opsForList().remove(key, index, value)
1

将List列表进行剪裁

redisTemplate.opsForList().trim(key, start, end)
1

获取当前key的List列表长度

redisTemplate.opsForList().size(key)
1

Set类型相关操作（opsForSet()）

添加元素

redisTemplate.opsForSet().add(key, values)
1

移除元素(单个值、多个值)

redisTemplate.opsForSet().remove(key, values)
1

获取集合的大小

redisTemplate.opsForSet().size(key)
1

判断集合是否包含value

redisTemplate.opsForSet().isMember(key, value)
1

获取两个集合的交集(key对应的无序集合与otherKey对应的无序集合求交集)

redisTemplate.opsForSet().intersect(key, otherKey)
1

获取多个集合的交集(Collection var2)

redisTemplate.opsForSet().intersect(key, otherKeys)
1

key集合与otherKey集合的交集存储到destKey集合中(其中otherKey可以为单个值或者集合)

redisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey)
1

key集合与多个集合的交集存储到destKey无序集合中

redisTemplate.opsForSet().intersectAndStore(key, otherKeys, destKey)
1

获取两个或者多个集合的并集(otherKeys可以为单个值或者是集合)

redisTemplate.opsForSet().union(key, otherKeys)
1

key集合与otherKey集合的并集存储到destKey中(otherKeys可以为单个值或者是集合)

redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey)
1

获取两个或者多个集合的差集(otherKeys可以为单个值或者是集合)

redisTemplate.opsForSet().difference(key, otherKeys)
1

差集存储到destKey中(otherKeys可以为单个值或者集合)

redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)
1

获取集合中的所有元素

redisTemplate.opsForSet().members(key)
1

随机获取集合中count个元素

redisTemplate.opsForSet().randomMembers(key, count)
1

随机获取集合中的一个元素

redisTemplate.opsForSet().randomMember(key)
1

遍历set类似于Interator(ScanOptions.NONE为显示所有的)

redisTemplate.opsForSet().scan(key, options)
1

zSet类型（opsForZSet()）

ZSetOperations提供了一系列方法对有序集合进行操作

添加元素(有序集合是按照元素的score值由小到大进行排列)

redisTemplate.opsForZSet().add(key, value, score)
1

删除对应的value,value可以为多个值

redisTemplate.opsForZSet().remove(key, values)
1

增加元素的score值，并返回增加后的值

redisTemplate.opsForZSet().incrementScore(key, value, delta)
1

返回元素在集合的排名,有序集合是按照元素的score值由小到大排列

redisTemplate.opsForZSet().rank(key, value)
1

返回元素在集合的排名,按元素的score值由大到小排列

redisTemplate.opsForZSet().reverseRank(key, value)
1

获取集合中给定区间的元素(start 开始位置，end 结束位置, -1查询所有)

redisTemplate.opsForZSet().reverseRangeWithScores(key, start,end)
1

按照Score值查询集合中的元素，结果从小到大排序

redisTemplate.opsForZSet().reverseRangeByScore(key, min, max)
1

从高到低的排序集中获取分数在最小和最大值之间的元素

redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end)
1

根据score值获取集合元素数量

redisTemplate.opsForZSet().count(key, min, max)
1

获取集合的大小

redisTemplate.opsForZSet().size(key)
1

获取集合中key、value元素对应的score值

redisTemplate.opsForZSet().score(key, value)
1

移除指定索引位置处的成员

redisTemplate.opsForZSet().removeRange(key, start, end)
1

移除指定score范围的集合成员

redisTemplate.opsForZSet().removeRangeByScore(key, min, max)
1

获取key和otherKey的并集并存储在destKey中（其中otherKeys可以为单个字符串或者字符串集合）

redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey)
1

获取key和otherKey的交集并存储在destKey中（其中otherKeys可以为单个字符串或者字符串集合）

redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey)
1