springboot3 redis配置 不自动注入

【快速上手系列】redis介绍配置和springboot集成redis的使用

redis

redis简介

redis是一个key-value。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets）与范围查询， bitmaps， hyperloglogs和 地理空间（geospatial）索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions）和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）

Redis的应用

1. 缓存，毫无疑问这是Redis当今最为人熟知的使用场景。再提升服务器性能方面非常有效；
2. 排行榜，如果使用传统的关系型数据库来做这个事儿，非常的麻烦，而利用Redis的SortSet数据结构能够非常方便搞定；
3. 计算器/限速器，利用Redis中原子性的自增操作，我们可以统计类似用户点赞数、用户访问数等，这类操作如果用MySQL，频繁的读写会带来相当大的压力；限速器比较典型的使用场景是限制某个用户访问某个API的频率，常用的有抢购时，防止用户疯狂点击带来不必要的压力；
   注：限速器也是对请求限流的一种实现方式。
4. 好友关系，利用集合的一些命令，比如求交集、并集、差集等。可以方便搞定一些共同好友、共同爱好之类的功能；
5. 简单消息队列，除了Redis自身的发布/订阅模式，我们也可以利用List来实现一个队列机制，比如：到货通知、邮件发送之类的需求，不需要高可靠，但是会带来非常大的DB压力，完全可以用List来完成异步解耦；
6. Session共享，默认Session是保存在服务器的文件中，即当前服务器，如果是集群服务，同一个用户过来可能落在不同机器上，这就会导致用户频繁登陆；采用Redis保存Session后，无论用户落在那台机器上都能够获取到对应的Session信息。

redis特点

• Redis将其数据库完全保存在内存中，仅使用磁盘进行持久化。
• 与其它键值数据存储相比，Redis有一组相对丰富的数据类型（string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型））
• Redis可以将数据复制到任意数量的从机中。

redis优点

• 异常快
  Redis非常快，每秒可执行大约110000次的设置(SET)操作，每秒大约可执行81000次的读取/获取(GET)操作。
• 支持丰富的数据类型
  Redis支持开发人员常用的大多数数据类型，例如列表，集合，排序集和散列等等。这使得Redis很容易被用来解决各种问题，因为我们知道哪些问题可以更好使用地哪些数据类型来处理解决。
• 操作具有原子性
  所有Redis操作都是原子操作，这确保如果两个客户端并发访问，Redis服务器能接收更新的值。
• 多实用工具
  Redis是一个多实用工具，可用于多种用例，如：缓存，消息队列(Redis本地支持发布/订阅)，应用程序中的任何短期数据，例如，web应用程序中的会话，网页命中计数等。

redis安装（Windows系统）

下载包
https:///MicrosoftArchive/redis/releases

解压到自己所需目录下

redis使用

1. 启动redis

在这个目录下cmd，然后直接redis-server.exe redis.windows.conf，即可启动redis
或新建记事本文件startup.bat，输入redis-server.exe redis.windows.conf

放到当前目录下

如果放在别的地方需要在文件中配置一下具体位置

比如我想在桌面上开启redis，但我的文件放在F盘时，则可以这样写：

这是代码

::进入F盘
F:
::进入redis目录
cd F:\Redis-x64-3.0.504
::设置字体颜色
color 06
::启动服务
redis-server.exe redis.windows.conf

tips：可以用color设置颜色，网上有很多很多颜色喜欢可以自己查查，我这是黄色的

2. 修改密码

解压目录下找到redis.windows.conf
大概在387行左右requirepass 下添加requirepass 密码，保存，重新运行即可

可以看到成功启动

tips：使用时误关闭此界面，redis服务器也会随之关闭

redis可视化

Redis Desktop Manager

网上有挺多工具的，我用的是这个（下的版本不太一样所以界面还是有些不太一样的），打开之后开始连接自己的redis即可：

连接步骤

点击橙色区域部分来连接到我们的redis服务器

然后配置连接信息，测试一下连接看是否成功，然后确定

然后可以看见左侧的redis服务器被成功添加进来

可以看到redis默认给了我们15个数据库来使用

我们可以使用界面来操作这些数据库，也可以用控制命令来操作

点击服务器然后点击橙色按钮，或者快捷键Ctrl+T

可以看到命令台窗口，然后来进行数据库操作

简单的命令操作

切换数据库

打开控制台我们可以看见默认选中的是服务器redis01中的db0数据库，我们可以换成在其它数据库中操作，比如db1

//切换数据库
select 数据库号

当显示"ok"时则说明操作成功，我们也可以看到数据库被成功切换到db1中

设置key-value和得到key-value

然后我们如果想在db1中设置一个key-value数据该怎么办呢？

//放置key-value
set key value

当显示"ok"时则说明操作成功，这时我们可以刷新一下左侧的数据库，可以看到我们设置的数据被成功放入到了数据库db1中

当然我们也可以直接从命令行中进行取值，就是根据key来获得value

//根据key来获得value
get key

可以看到控制台成功给我们返回了相应key的value值

redis有很多命令，可以在下面的网站找找看看：

Redis 命令参考 — Redis 命令参考 (redisfans.com)

字符串 — Redis 命令参考 (redisdoc.com)

使用springboot集成redis

引入jar

添加maven依赖

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
    <version>1.3.8.RELEASE</version>
</dependency>

或版本高一些的（比如2.1.17.RELEASE什么的）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置文件

application.yml

spring:
  redis:
    database: 0 #选择redis数据库索引（默认就这，不写也行）
    host: localhost #设置服务器地址（默认127.0.0.1，不写也行）
    port: 6379  #设置redis服务器端口号（默认就这，不写也行）
    password: 123456 #设置redis服务器密码（这个必须写嗷，如果设置过服务器密码那么不写不行哦，会无法连接上，当然也许会出现设置密码失效的原因）

application.properties（用上面的yml就好，这个看看理解一下就行）

# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=111111
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8  
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1  
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8  
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0  
# 连接超时时间（毫秒）
spring.redis.timeout=0

上述两个步骤完成后，SpringBoot会自动在Spring容器中配置一个redisTemplate的Bean，所以我们可以直接来使用redisTemplate

然后我们就可以使用spring封装的redisTemplate来操作redis

一些常用操作

RedisTemplate

常用方法

//操作字符串
redisTemplate.opsForValue();
//操作list
redisTemplate.opsForList();
//操作set
redisTemplate.opsForSet();
//操作有序set
redisTemplate.opsForZSet();
//操作hash
redisTemplate.opsForHash();

使用opsForValue操作字符串

//存储字符串
使用：redisTemplate.opsForValue().set("dog","kuma");
结果：redisTemplate.opsForValue().get("dog") 
//输出结果为kuma
------------------------------------------------------------------
//设置失效时间
使用：redisTemplate.opsForValue().set("cat","leo",10, TimeUnit.SECONDS);
TimeUnit.DAYS           //天  
TimeUnit.HOURS          //小时
TimeUnit.MINUTES        //分钟  
TimeUnit.SECONDS       //秒
TimeUnit.MILLISECONDS  //毫秒
//结果：redisTemplate.opsForValue().get("cat")由于设置的是10秒失效，十秒之内查询有结果，十秒之后返回为null
-------------------------------------------------------------------
//支持整型与浮点型（increment）
使用：template.opsForValue().increment("sex",1);
System.out.println(template.opsForValue().get("sex"));
//结果：1
--------------------------------------------------------------------
//如果key已经存在并且是一个字符串，则该命令将该值追加到字符串的末尾。如果键不存在，则它被创建并设置为空字符串，因此APPEND在这种特殊情况下将类似于SET
使用：template.opsForValue().append("cat"," smile");
      System.out.println(template.opsForValue().get("cat"));
//结果：leo smile
--------------------------------------------------------------------
//截取key所对应的value字符串
System.out.println("*********"+template.opsForValue().get("cat",0,3));
//结果：leo
--------------------------------------------------------------------
//返回key所对应的value值得长度
System.out.println("***************"+template.opsForValue().size("key"));
--------------------------------------------------------------------
//存储一个对象（此类必须先序列化实现接口Serializable）
 RedisSerializer rs = new StringRedisSerializer();
redisTemplate.setStringSerializer(rs);
ValueOperations ops = redisTemplate.opsForValue();
ops.set("user",user);//放入redis
//取出对象
User setuser = (User) redisTemplate.opsForValue().get("user");

使用opsForList操作list

//将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从左边插入）
redisTemplate.opsForList().leftPush("names","张三");
redisTemplate.opsForList().leftPush("names","李四");
--------------------------------------------------------------------
//将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从右边插入）
redisTemplate.opsForList().rightPush("names","王五");
redisTemplate.opsForList().rightPush("names","马六");
--------------------------------------------------------------------
//获取集合长度
redisTemplate.opsForList().size("names")；
--------------------------------------------------------------------
//返回存储在键中的列表的指定元素
使用：System.out.println(redisTemplate.opsForList().range("list",0,-1));
//结果:[c#, c++, python, java, c#, c#]
--------------------------------------------------------------------
//在列表中index的位置设置value值（如果index不存在则报错）
redisTemplate.opsForList().set("names",1,"岳不群");
--------------------------------------------------------------------
//批量把一个数组插入到列表中
String[] stringarrays = new String[]{"1","2","3"};
redisTemplate.opsForList().leftPushAll("listarray",stringarrays);
--------------------------------------------------------------------
//从存储在键中的列表中删除等于值的元素的第一个计数事件
count> 0：删除等于从头到尾移动的值的元素。
count <0：删除等于从尾到头移动的值的元素。
count = 0：删除等于value的所有元素
redisTemplate.opsForList().remove("names",1,"王五");
--------------------------------------------------------------------
//根据下表获取列表中的值，下标是从0开始的
redisTemplate.opsForList().index("names",2);

使用opsForSet操作set

//无序集合中添加元素，返回添加个数
使用：String[] strarrays = new String[]{"strarr1","sgtarr2"};
     System.out.println(redisTemplate.opsForSet().add("setTest", strarrays));
//结果：2
--------------------------------------------------------------------
//返回集合中的所有成员
使用：System.out.println(redisTemplate.opsForSet().members("setTest"));
//结果：[ddd, bbb, aaa, ccc]
--------------------------------------------------------------------
//移除集合中一个或多个成员
使用：String[] strarrays = new String[]{"strarr1","sgtarr2"};
System.out.println(redisTemplate.opsForSet().remove("setTest",strarrays));
//结果：2
--------------------------------------------------------------------
//无序集合的大小长度
使用：System.out.println(redisTemplate.opsForSet().size("setTest"));
//结果：1
--------------------------------------------------------------------
//判断 ccc 元素是否是集合 key 的成员
使用：System.out.println(redisTemplate.opsForSet().isMember("setTest","ccc"));
//结果：true
--------------------------------------------------------------------
//随机获取key无序集合中的一个元素
redisTemplate.opsForSet().randomMember("setTest");

使用opsForZSet操作有序set

//新增一个有序集合，存在的话为false，不存在的话为true（这是反着来的，别看错了，可以理解为如果存在了就说明并没有新增成功，所以返回了false，而不存在则说明操作成功了，所以返回true）
使用：System.out.println(template.opsForZSet().add("zset1","zset-1",1.1));
//结果：true
--------------------------------------------------------------------
//从有序集合中移除一个或者多个元素
使用：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]
*/
--------------------------------------------------------------------
//增加元素的score值，并返回增加后的值
使用：//原为1.1
System.out.println(template.opsForZSet().incrementScore("zset1","zset-1",1.1));  
//结果：2.2
--------------------------------------------------------------------
//通过分数返回有序集合指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
使用：
System.out.println(redisTemplate.opsForZSet().add("zset1","zset-1",1.0));
System.out.println(redisTemplate.opsForZSet().add("zset1","zset-2",6.0));
System.out.println(redisTemplate.opsForZSet().add("zset1","zset-3",8.0));
System.out.println(redisTemplate.opsForZSet().add("zset1","zset-4",4.0));
System.out.println(redisTemplate.opsForZSet().add("zset1","zset-5",10.0));
System.out.println(redisTemplate.opsForZSet().add("zset1","zset-6",2.0));
System.out.println(redisTemplate.opsForZSet().rangeByScore("zset1",0,5));
//结果：[zset-1, zset-6, zset-4]
--------------------------------------------------------------------
//通过分数返回有序集合指定区间内的成员个数
使用：System.out.println(template.opsForZSet().rangeByScore("zset1",0,5));
      System.out.println(template.opsForZSet().count("zset1",0,5));
/*
结果：[zset-1, zset-6, zset-4]
3
*/
--------------------------------------------------------------------
//获取有序集合的成员数（zCard与size一样）
使用：System.out.println(template.opsForZSet().size("zset1"));
//结果：6
--------------------------------------------------------------------
//获取指定成员的score值
使用：System.out.println(template.opsForZSet().score("zset1","zset-1"));
//结果：1.0

StringRedisTemplate

StringRedisTemplate与RedisTemplate区别

1. 两者的关系是StringRedisTemplate继承RedisTemplate
2. 两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。
3. （序列化类）RedisTemplate使用的是JdkSerializationRedisSerializer 存入数据会将数据先序列化成字节数组然后在存入Redis数据库。 StringRedisTemplate使用的是StringRedisSerializer

使用时注意事项：

• 当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候，那么你就使用StringRedisTemplate即可。
• 但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象，那么使用RedisTemplate是更好的选择。

RedisTemplate使用时常见问题
redisTemplate 中存取数据都是字节数组。当redis中存入的数据是可读形式而非字节数组时，使用redisTemplate取值的时候会无法获取导出数据，获得的值为null

StringRedisTemplate常用操作

//向redis里存入数据和设置缓存时间  
stringRedisTemplate.opsForValue().set("test", "100",60*10,TimeUnit.SECONDS);
//val做-1操作
stringRedisTemplate.boundValueOps("test").increment(-1);
//根据key获取缓存中的val
stringRedisTemplate.opsForValue().get("test")
//val +1
stringRedisTemplate.boundValueOps("test").increment(1);
//根据key获取过期时间
stringRedisTemplate.getExpire("test")
//根据key获取过期时间并换算成指定单位 
stringRedisTemplate.getExpire("test",TimeUnit.SECONDS)
//根据key删除缓存
stringRedisTemplate.delete("test");
//检查key是否存在，返回boolean值 
stringRedisTemplate.hasKey("ccc");
//向指定key中存放set集合
stringRedisTemplate.opsForSet().add("red_123", "1","2","3");
//设置过期时间
stringRedisTemplate.expire("red_123",1000 , TimeUnit.MILLISECONDS);
//根据key查看集合中是否存在指定数据
stringRedisTemplate.opsForSet().isMember("red_123", "1")
//根据key获取set集合
stringRedisTemplate.opsForSet().members("red_123");

备注：使用方式

1、创建一个controller

然后自动装配redisTemplate或stringRedisTemplate

//redisTemplate只支持这两种泛型
//springboot默认情况下给我们定义了泛型为<Object,Object>
@Autowired
private RedisTemplate<Object,Object> redisTemplate;
//用于字符串（泛型两个string）
@Autowired
private RedisTemplate<String,String> redisTemplate;
//如果不定义自己的RedisTemplate,则不能使用其他的泛型注入（如果写这个就不能再写其它泛型的redisTemplate）
@Autowired
private RedisTemplate redisTemplate;

//stringRedisTemplate
@Autowired
private StringRedisTemplate stringRedisTemplate;

当我们将redisTemplate的泛型设置为<String，Object>和<String，Integer>时， redisTemplate== stringRedisTemplate，两者这时为同一个对象，就像这样（当然也是会报错的）：

@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private RedisTemplate<String, Integer> redisTemplate;

如果我们自定义的 redisTemplate 的名称和springboot默认给我们的名称一样，当我们使用时则会覆盖springboot给我们的，当然自定义时最好使用@Resource注解，否则@Autowired会找不到我们这个自定义的泛型导致找不到bean导致报错无法使用

@Resource
RedisTemplate<String,Object> redisTemplate11;
@Resource
RedisTemplate<String,Long> redisTemplate22;
@Resource
RedisTemplate<String,User> redisTemplate33;

设置键时可以这样设置

/**
     * 操作字符串
     * @return
     */
@RequestMapping("/opsForValue")
public String opsForValue() {
    redisTemplate.opsForValue().set("name","kuma");
    Object vo = redisTemplate.opsForValue().get("name");
    System.out.println(vo.toString());
    return "操作成功";
}

进行操作时给返回一个“操作成功”的结果显示即可

我写了一个用于上面来测试的小例子，使用时来注释一下不需要的语句即可，然后在Redis Desktop Manager中可用于查看redis数据的变化

完整测试代码

/**
 * @Author Tuerlechat,
 * @Date 2022/11/25
 */
@RestController
public class RedisController {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    //用于对象测试
    //    @Autowired
    //    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 操作字符串
     * @return
     */
    @RequestMapping("/opsForValue")
    public String opsForValue() {
        redisTemplate.opsForValue().set("name","kuma");
        Object vo = redisTemplate.opsForValue().get("name");
        System.out.println(vo.toString());
        return "操作成功";
    }

    /**
     * 追加字符串
     * @return
     */
    @RequestMapping("/opsForValue1")
    public String opsForValue1() {
        redisTemplate.opsForValue().set("name","kuma");
        redisTemplate.opsForValue().append("name","hello");
        Object vo = redisTemplate.opsForValue().get("name");
        System.out.println(vo.toString());
        return "操作成功";
    }

    /**
     * 存储一个对象（可以这么写，也可以自己写json工具类来相互转换字符串来实现）
     * @return
     */
    @RequestMapping("/opsForProvider")
    public String opsForProvider() {
        //
        //        RedisSerializer rs = new StringRedisSerializer();
        //        redisTemplate.setStringSerializer(rs);  //设置redis支持序列化
        //        //存放对象
        //        Provider provider = new Provider();
        //        provider.setId(1001);
        //        redisTemplate.opsForValue().set("provider",provider);
        //        //取出对象
        //        Provider pro = (Provider)redisTemplate.opsForValue().get("provider");
        //        System.out.println(pro.getId());
        return "操作成功";
    }

    /**
     * 操作list
     * @return
     */
    @RequestMapping("/opsForList")
    public String opsForList() {
        //将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从左边插入）
        redisTemplate.opsForList().leftPush("names","张三");
        redisTemplate.opsForList().leftPush("names","李四");
        //将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从右边插入）
        redisTemplate.opsForList().rightPush("names","王五");
        redisTemplate.opsForList().rightPush("names","马六");
        //获取集合长度
        System.out.println("获取集合长度:" + redisTemplate.opsForList().size("names"));
        //返回存储在键中的列表的指定元素
        System.out.println("返回存储在键中的列表的指定元素:" + redisTemplate.opsForList().range("names",0,-1));
        //在列表中index的位置设置value值（如果index不存在则报错）
        redisTemplate.opsForList().set("names",1,"岳不群");
        //批量把一个数组插入到列表中
        String[] stringarrays = new String[]{"1","2","3"};
        redisTemplate.opsForList().leftPushAll("names",stringarrays);
        //从存储在键中的列表中删除等于值的元素的第一个计数事件
        redisTemplate.opsForList().remove("names",0,"李四");
        //根据下表获取列表中的值，下标是从0开始的
        System.out.println(redisTemplate.opsForList().index("names",2));
        return "操作成功";

    }

    /**
     * 操作set
     * @return
     */
    @RequestMapping("/opsForSet")
    public String opsForSet() {
        //无序集合中添加元素，返回添加个数
        String[] strarrays = new String[]{"strarr1","sgtarr2"};
        System.out.println(redisTemplate.opsForSet().add("setTest", strarrays));
        //返回集合中的所有成员
        System.out.println(redisTemplate.opsForSet().members("setTest"));
        //移除集合中一个或多个成员
        System.out.println(redisTemplate.opsForSet().remove("setTest",strarrays));
        //无序集合的大小长度
        System.out.println(redisTemplate.opsForSet().size("setTest"));
        //判断 ccc 元素是否是集合 key 的成员
        System.out.println(redisTemplate.opsForSet().isMember("setTest","ccc"));
        //随机获取key无序集合中的一个元素
        System.out.println(redisTemplate.opsForSet().randomMember("setTest"));
        return "操作成功";
    }

    /**
     * 操作有序set
     * @return
     */
    @RequestMapping("/opsForZSet")
    public String opsForZSet() {
        //        //新增一个有序集合，存在的话为false，不存在的话为true
        //        System.out.println(redisTemplate.opsForZSet().add("zset1","zset-1",1.1));
        //        //增加元素的score值，并返回增加后的值
        //        System.out.println(redisTemplate.opsForZSet().incrementScore("zset1","zset-1",1.1));
        //        //获取指定成员的score值
        //        System.out.println(redisTemplate.opsForZSet().score("zset1","zset-1"));
        //通过分数返回有序集合指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
        System.out.println(redisTemplate.opsForZSet().add("zset1","zset-1",1.0));
        System.out.println(redisTemplate.opsForZSet().add("zset1","zset-2",6.0));
        System.out.println(redisTemplate.opsForZSet().add("zset1","zset-3",8.0));
        System.out.println(redisTemplate.opsForZSet().add("zset1","zset-4",4.0));
        System.out.println(redisTemplate.opsForZSet().add("zset1","zset-5",10.0));
        System.out.println(redisTemplate.opsForZSet().add("zset1","zset-6",2.0));
        //通过分数返回有序集合指定区间内的成员个数
        System.out.println(redisTemplate.opsForZSet().rangeByScore("zset1",0,5));
        System.out.println(redisTemplate.opsForZSet().count("zset1",0,5));
        //获取有序集合的成员数（zCard与size一样）
        System.out.println(redisTemplate.opsForZSet().size("zset1"));
        //从有序集合中移除一个或者多个元素
        System.out.println(redisTemplate.opsForZSet().range("zset1",0,-1));
        System.out.println(redisTemplate.opsForZSet().remove("zset1","zset-6"));
        System.out.println(redisTemplate.opsForZSet().range("zset1",0,-1));
        return "操作成功";
    }

    /**
     * StringRedisTemplate操作字符串
     * @return
     */
    @RequestMapping("/StringRedisTemplate")
    public String StringRedisTemplate() {
        //向redis里存入数据和设置缓存时间
        stringRedisTemplate.opsForValue().set("test", "100",60*10, TimeUnit.SECONDS);
        //val做-1操作
        stringRedisTemplate.boundValueOps("test").increment(-1);
        //根据key获取缓存中的val
        System.out.println(stringRedisTemplate.opsForValue().get("test"));
        //val +1
        stringRedisTemplate.boundValueOps("test").increment(1);
        //根据key获取过期时间
        System.out.println(stringRedisTemplate.getExpire("test"));
        //根据key获取过期时间并换算成指定单位
        System.out.println(stringRedisTemplate.getExpire("test",TimeUnit.SECONDS));
        //根据key删除缓存
        //stringRedisTemplate.delete("test");
        //检查key是否存在，返回boolean值
        System.out.println(stringRedisTemplate.hasKey("546545"));
        //向指定key中存放set集合
        stringRedisTemplate.opsForSet().add("red_123", "1","2","3");
        //设置过期时间
        stringRedisTemplate.expire("red_123",10000 , TimeUnit.MILLISECONDS);
        //根据key查看集合中是否存在指定数据
        System.out.println(stringRedisTemplate.opsForSet().isMember("red_123", "1"));
        //根据key获取set集合
        System.out.println(stringRedisTemplate.opsForSet().members("red_123"));
        return "操作成功";
    }
}

注意事项

RedisTemplate使用泛型<Object,Object>时（包括存储对象什么的）在Redis Desktop Manager上面可能会显示乱码什么的，这并没有什么问题，只是说界面显示上有点问题，不过我们是可以在程序中成功取回相应的值的（不乱码的），不必担心🤓