Springboot整合Redis

新建Springboot项目

此步骤不再赘述

xml文件添加依赖

传统套路，第一步还是添加依赖，本次使用以下依赖(Springboot版本：2.3.12.RELEASE)：

    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.12.RELEASE
         
    
    com.wpp
    springboot_redis
    0.0.1-SNAPSHOT
    springboot_redis
    Demo project for Spring Boot
    
        1.8
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
        
            org.springframework.boot
            spring-boot-starter-data-redis
        


    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

配置文件

第二步，编写一下配置文件：

spring:
  redis:
    host: Redis地址
    port: 6379
    password: Redis密码
    jedis:
    #连接池相关配置
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 500
        min-idle: 0
    lettuce:
      shutdown-timeout: 0

配置类

第三步，也是springboot整合的常用步骤，编写一个配置类，启动项目之后，RedisTemplate就注入了Spring容器中

package com.wpp.springboot_redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;



/**
 * @Author wpp
 * @Date 2022/06/13/14:27
 * @Description
 */

@EnableCaching
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate template = new RedisTemplate();
        RedisSerializer redisSerializer = new StringRedisSerializer();
   
        template.setConnectionFactory(redisConnectionFactory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(redisSerializer);// 防止出现双引号的问题
        //value hashmap序列化
        template.setHashValueSerializer(redisSerializer);// 防止出现双引号的问题
        //field hashMap序列化
        template.setHashKeySerializer(redisSerializer);// 防止出现16进制的问题
        return template;
    }



}

测试

接下来就可以在测试类中玩耍了，就是这么简单

package com.wpp.springboot_redis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class SpringbootRedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void test1() {
        redisTemplate.opsForValue().set("name","wangDa");
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }

}

测试结果如下：

RedisTemplate提供的API String 类型

设置当前的 key以及 value 值

redisTemplate.opsForValue().set("name","wangDa");

redisTemplate.opsForValue().set("key1","value1",20,TimeUnit.SECONDS);// 同时设置过期时间

判断是否有 key 所对应的值，有则返回 true，没有则返回 false

Boolean b = redisTemplate.hasKey("name");

有则取出 key 值所对应的值

Object name = redisTemplate.opsForValue().get("name");

删除单个 key 值

Boolean b = redisTemplate.delete("name");

批量删除 key

Set keys = new HashSet();
keys.add("key1");
keys.add("key2");
keys.add("key3");
// 返回成功删除的数量
Long count = redisTemplate.delete(keys);

设置过期时间

Boolean b = redisTemplate.expire("key1", 20, TimeUnit.SECONDS);//延迟时间，单位（秒）

//指定 key 在指定的日期过期
DateFormat dateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = dateFormat2.parse("2022-09-13 22:36:01");
Boolean b = redisTemplate.expireAt("key1", date);//延时到某个时间，传参（Date）

查找匹配的 key 的值，返回一个 set 集合

String pattern = "userId:" + "*";//pattern 为正则表达式
Set stringSet = redisTemplate.keys(pattern);

修改 redis 中 key 的名称

//key1 不存在会报错（ERR no such key），key2 已存在则会删除 key1
redisTemplate.rename("key1","key2");// 无返回值

Boolean b = redisTemplate.renameIfAbsent("key1","key3");// 有返回值

返回传入 key 所存储的值的类型

DataType key1 = redisTemplate.type("key1");

从 redis 中随机取出一个 key

String s = redisTemplate.randomKey();

返回当前 key 所对应的剩余过期时间

Long schedule = redisTemplate.getExpire("key1");

Long schedule = redisTemplate.getExpire("key1", TimeUnit.SECONDS);// 指定时间单位

将 key 持久化保存

Boolean b = redisTemplate.persist("key1");

将当前数据库的 key 移动到指定 redis 中数据库中

Boolean b = redisTemplate.move("key1", 1);

返回 key 中字符串的子字符串

String subStr = redisTemplate.opsForValue().get("key1", 1, -1);

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

Object obj = redisTemplate.opsForValue().getAndSet("key1", "abcde");

批量获取值

Set keys = new HashSet();
keys.add("key1");
keys.add("key2");
keys.add("key3");
List list = redisTemplate.opsForValue().multiGet(keys);

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

Integer append = redisTemplate.opsForValue().append("key1", "123");// 返回值为新的value长度

以增量的方式将 double 值存储在变量中

Long key1 = redisTemplate.opsForValue().increment("key1", 10);

如果对应的 map 集合名称不存在，则添加，否则不做修改

Map map = new HashMap();
map.put("mapKey1","mapValue1");
map.put("mapKey4","mapValue4");
map.put("mapKey5","mapValue5");
Boolean b = redisTemplate.opsForValue().multiSetIfAbsent(map); // 操作具有原子性，有一个key已存在，则全失败

设置 map 集合到 redis

Map map = new HashMap();
map.put("mapKey1","mapValue1");
map.put("mapKey2","mapValue2");
map.put("mapKey4","mapValue4");
redisTemplate.opsForValue().multiSet(map);// 不具有原子性

获取字符串长度

Long size = redisTemplate.opsForValue().size("key1");

用 value 参数覆写给定 key 所存储的字符串值，从偏移量 offset 开始

redisTemplate.opsForValue().set("key1", "123", 1);

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

Boolean b = redisTemplate.opsForValue().setIfAbsent("key1", "value1");

将值 value 关联到 key，并将 key 的过期时间设为 timeout

redisTemplate.opsForValue().set("key1", "value2", 20, TimeUnit.SECONDS);

Hash 类型

新增 hashMap 值

redisTemplate.opsForHash().put("user1","name","wangDa");
redisTemplate.opsForHash().put("user1","age","18");

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

Map map = new HashMap();
map.put("name","wangEe");
map.put("age","16");
redisTemplate.opsForHash().putAll("user2",map);

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

Object o = redisTemplate.opsForHash().get("user1", "name");

获取变量中的键值对

Map user1 = redisTemplate.opsForHash().entries("user1");

删除一个或多个 hash 表字段

Long count = redisTemplate.opsForHash().delete("user3", "name", "age");// 返回删除 field 的数量

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

Boolean b = redisTemplate.opsForHash().hasKey("user1", "name");

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

Long increment = redisTemplate.opsForHash().increment("user1", "age", 10);

获取所有 hash 表中的字段

Set user1 = redisTemplate.opsForHash().keys("user1");

获取 hash 表中字段的数量

Long size = redisTemplate.opsForHash().size("user1");

获取 hash 表中存在的所有值

List list = redisTemplate.opsForHash().values("user1");

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

Cursor scan = redisTemplate.opsForHash().scan("user1", ScanOptions.NONE);

List 类型

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

Long size = redisTemplate.opsForList().leftPush("key1", "a");

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

Object obj = redisTemplate.opsForList().index("key1", 0);

获取列表指定单位内的元素（start 开始位置，end 结束位置，-1返回所有）

List list = redisTemplate.opsForList().range("key1", 0, 2);

把多个值存入 list 中（value 可以是多个值，也可以是一个 Collection value）

Long size = redisTemplate.opsForList().leftPushAll("key1", "b", "c");
List list = new ArrayList();
list.add("d");
list.add("e");
Long size1 = redisTemplate.opsForList().leftPushAll("key1", list);

list 存在的时候再加入

Long size = redisTemplate.opsForList().leftPushIfPresent("key1", "f");

// 如果 pivot 处值存在，则在 pivot 前面添加

Long size = redisTemplate.opsForList().leftPush("key1", "c", "嗯哼");

从右侧来添加

Long size = redisTemplate.opsForList().rightPush("key1", "唐僧");

从右侧来添加（value 可以是多个值，或者是 Collection var2）

Long size = redisTemplate.opsForList().rightPushAll("key1", "孙悟空","猪八戒");

List list = new ArrayList();
list.add("沙僧");
list.add("白龙马");
Long size = redisTemplate.opsForList().rightPushAll("key1", list);

在 pivot 元素的右边添加值

Long size = redisTemplate.opsForList().rightPush("key1", "嗯哼", "fight");

设置指定索引处的值

redisTemplate.opsForList().set("key1",0,"唐僧");

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

Object o = redisTemplate.opsForList().leftPop("key1");

Object o = redisTemplate.opsForList().leftPop("key1", 2, TimeUnit.SECONDS);

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

Object o = redisTemplate.opsForList().rightPop("key1");

Object o = redisTemplate.opsForList().leftPop("key1",2,TimeUnit.SECONDS);

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

Object o = redisTemplate.opsForList().rightPopAndLeftPush("key1", "key2");

Object o = redisTemplate.opsForList().rightPopAndLeftPush("key1", "key2", 2, TimeUnit.SECONDS);

删除集合中值等于 value 的元素（index = 0，删除所有值等于 value 的元素；index > 0，从头部开始删除第一个值等于 value 的元素index < 0，从尾部开始删除第一个值等于 value 的元素）

Long size = redisTemplate.opsForList().remove("key1", -1, "b");

将 list 列表进行裁剪

redisTemplate.opsForList().trim("key1",0,1);

获取当前列表的长度

Long size = redisTemplate.opsForList().size("key1");

Set 类型

添加元素

Long size = redisTemplate.opsForSet().add("key1", "a", "b", "c");

移除元素（单个值、多个值）

Long size = redisTemplate.opsForSet().remove("key1", "a", "b");

删除并返回一个随机元素

Object o = redisTemplate.opsForSet().pop("key1");

获取集合的大小

Long size = redisTemplate.opsForSet().size("key1");

判断集合是否包含 value

Boolean b = redisTemplate.opsForSet().isMember("key1", "a");

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

Set set = redisTemplate.opsForSet().intersect("key1", "key2");

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

List list = new ArrayList();
list.add("key2");
list.add("key3");
Set set = redisTemplate.opsForSet().intersect("key1", list);

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

List list = new ArrayList();
list.add("key2");
list.add("key3");
Long size = redisTemplate.opsForSet().unionAndStore("key1", list, "key4");

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

List list = new ArrayList();
list.add("key2");
list.add("key3");
Set set = redisTemplate.opsForSet().difference("key1", list);

差集存储到 destrKey 中（otherKeys 可以为单个值或者集合）

List list = new ArrayList();
list.add("key2");
list.add("key3");
Long size = redisTemplate.opsForSet().differenceAndStore("key1", list, "key4");

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

Object o = redisTemplate.opsForSet().randomMember("key1");

获取集合中的所有元素

Set set = redisTemplate.opsForSet().members("key1");

随机获取集合中 count 个元素

List list = redisTemplate.opsForSet().randomMembers("key1", 3);

获取key 无序集合中多个元素（去重），count 表示个数

Set set = redisTemplate.opsForSet().distinctRandomMembers("key1", 3);

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

Cursor scan = redisTemplate.opsForSet().scan("key1", ScanOptions.NONE);

zSet 类型

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

Boolean b = redisTemplate.opsForZSet().add("key1", "唐僧", 100);

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

Long size = redisTemplate.opsForZSet().remove("key1", "孙悟空", "猪八戒");

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

Double d = redisTemplate.opsForZSet().incrementScore("key1", "唐僧", 100);

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

Long rank = redisTemplate.opsForZSet().rank("key1", "唐僧");

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

Long rank = redisTemplate.opsForZSet().reverseRank("key1", "唐僧");

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

Set set = redisTemplate.opsForZSet().reverseRangeWithScores("key1", 0, 1);

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

Set set = redisTemplate.opsForZSet().reverseRangeByScore("key1", 100, 200);

Set set = redisTemplate.opsForZSet().reverseRangeByScoreWithScores("key1", 80, 100);
//返回值为:Set

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

Set set = redisTemplate.opsForZSet().reverseRangeByScore("key1", 80, 200, 0, 2);

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

Long count = redisTemplate.opsForZSet().count("key1", 80, 200);

获取集合的大小

Long size = redisTemplate.opsForZSet().size("key1");

Long size = redisTemplate.opsForZSet().zCard("key1");

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

Double score = redisTemplate.opsForZSet().score("key1", "唐僧");

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

Long remove = redisTemplate.opsForZSet().removeRange("key1", 0,1);

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

Long size = redisTemplate.opsForZSet().removeRangeByScore("key1", 80, 100);

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

List list = new ArrayList();
list.add("key2");
Long size = redisTemplate.opsForZSet().unionAndStore("key1", list, "key3");

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

List list = new ArrayList();
list.add("key3");
Long size = redisTemplate.opsForZSet().intersectAndStore("key1", list, "key4");

遍历集合

Cursor scan = redisTemplate.opsForZSet().scan("key1", ScanOptions.NONE);
while (scan.hasNext()){
    ZSetOperations.TypedTuple item = scan.next();
    System.out.println("value:" + item.getValue() + "score:" + item.getScore());
}