常用命令

String

序号命令描述
1SET key value设定指定key的值
2GET key获取指定 key 的值。
3GETRANGE key start end返回 key 中字符串值的子字符
4GETSET key value将给定 key 的值设为 value ,并返回 key 的旧值(old value)。
5GETBIT key offset对 key 所储存的字符串值,获取指定偏移量上的位(bit)。
6MGET key1 [key2..]获取所有(一个或多个)给定 key 的值。
7SETBIT key offset value对 key 所储存的字符串值,设置或清除指定偏移量上的位(bit)。
8SETEX key seconds value将值value关联到key,并将key的过期时间设置为seconds(单位:秒)。
9SETNX key value只有在key不存在时设置key的值。
10SETRANGE key offset value用 value 参数覆写给定 key 所储存的字符串值,从偏移量 offset 开始。
11STRLEN key返回 key 所储存的字符串值的长度。
12MSET key value [key value …]同时设置一个或多个 key-value 对。
13MSETNX key value [key value …]同时设置一个或多个 key-value 对,当且仅当所有给定 key 都不存在。
14PSETEX key milliseconds value这个命令和 SETEX 命令相似,但它以毫秒为单位设置 key 的生存时间,而不是像 SETEX 命令那样,以秒为单位。
15INCR key将 key 中储存的数字值增一。
16INCRBY key increment将 key 所储存的值加上给定的增量值(increment)。
17INCRBYFLOAT key increment将 key 所储存的值加上给定的浮点增量值(increment)。
18DECR key将 key 中储存的数字值减一。
19DECRBY key decrementkey 所储存的值减去给定的减量值(decrement)。
20APPEND key value如果 key 已经存在并且是一个字符串, APPEND 命令将指定的 value 追加到该 key 原来值(value)的末尾。

Hash

添加 删除 存在 自增自减 长度
序号命令描述
1HDEL key field1 [field2]删除一个或多个哈希表字段
2HEXISTS key field查看哈希表 key 中,指定的字段是否存在。
3HGET key field获取存储在哈希表中指定字段的值。
4HGETALL key获取在哈希表中指定 key 的所有字段和值
5HINCRBY key field increment为哈希表 key 中的指定字段的整数值加上增量 increment 。
6HINCRBYFLOAT key field increment为哈希表 key 中的指定字段的浮点数值加上增量 increment 。
7HKEYS key获取哈希表中的所有字段
8HLEN key获取哈希表中字段的数量
9HMGET key field1 [field2]获取所有给定字段的值
10HMSET key field1 value1 [field2 value2同时将多个 field-value (域-值)对设置到哈希表 key 中。
11HSET key field value将哈希表 key 中的字段 field 的值设为 value 。
12HSETNX key field value只有在字段 field 不存在时,设置哈希表字段的值。
13HVALS key获取哈希表中所有值。

List

pop(l,r)  push(l,r)   左右添加删除(定时任务) 索引获取  
序号命令描述
1BLPOP key1 [key2 ] timeout移出并获取列表的第一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
2BRPOP key1 [key2 ] timeout移出并获取列表的最后一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
3BRPOPLPUSH source destination timeout从列表中弹出一个值,将弹出的元素插入到另外一个列表中并返回它; 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
4LINDEX key index通过索引获取列表中的元素
5LINSERT key BEFOREAFTER pivot value
6LLEN key获取列表长度
7LPOP key移出并获取列表的第一个元素
8LPUSH key value1 [value2]将一个或多个值插入到列表头部
9LPUSHX key value将一个值插入到已存在的列表头部
10LRANGE key start stop获取列表指定范围内的元素
11LREM key count value移除列表元素
12LSET key index value通过索引设置列表元素的值
13LTRIM key start stop对一个列表进行修剪(trim),就是说,让列表只保留指定区间内的元素,不在指定区间之内的元素都将被删除。
14RPOP key移除列表的最后一个元素,返回值为移除的元素。
15RPOPLPUSH source destination移除列表的最后一个元素,并将该元素添加到另一个列表并返回
16RPUSH key value1 [value2]在列表中添加一个或多个值到列表尾部
17RPUSHX key value为已存在的列表添加值

Set

增加 删除 交集 并集  以及第一个集合与其他的差异
序号命令描述
1SADD key member1 [member2]向集合添加一个或多个成员
2SCARD key获取集合的成员数
3SDIFF key1 [key2]返回第一个集合与其他集合之间的差异。
4SDIFFSTORE destination key1 [key2]返回给定所有集合的差集并存储在 destination 中
5SINTER key1 [key2]返回给定所有集合的交集
6SINTERSTORE destination key1 [key2]返回给定所有集合的交集并存储在 destination 中
7SISMEMBER key member判断 member 元素是否是集合 key 的成员
8SMEMBERS key返回集合中的所有成员
9SMOVE source destination member将 member 元素从 source 集合移动到 destination 集合
10SPOP key移除并返回集合中的一个随机元素
11SRANDMEMBER key [count]返回集合中一个或多个随机数
12SREM key member1 [member2]移除集合中一个或多个成员
13SUNION key1 [key2]返回所有给定集合的并集
14SUNIONSTORE destination key1 [key2]所有给定集合的并集存储在 destination 集合中

Zset

序号命令描述
1ZADD key score1 member1 [score2 member2]向有序集合添加一个或多个成员,或者更新已存在成员的分数
2ZCARD key获取有序集合的成员数
3ZCOUNT key min max计算在有序集合中指定区间分数的成员数
4ZINCRBY key increment member有序集合中对指定成员的分数加上增量 increment
5ZINTERSTORE destination numkeys key [key …]计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 destination 中
6ZLEXCOUNT key min max在有序集合中计算指定字典区间内成员数量
7ZRANGE key start stop [WITHSCORES]通过索引区间返回有序集合指定区间内的成员
8ZRANGEBYLEX key min max [LIMIT offset count]通过字典区间返回有序集合的成员
9ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]通过分数返回有序集合指定区间内的成员分数从低到高排
10ZRANK key member返回有序集合中指定成员的索引
11ZREM key member [member …]移除有序集合中的一个或多个成员
12ZREMRANGEBYLEX key min max移除有序集合中给定的字典区间的所有成员
13ZREMRANGEBYRANK key start stop移除有序集合中给定的排名区间的所有成员
14ZREMRANGEBYSCORE key min max移除有序集合中给定的分数区间的所有成员
15ZREVRANGE key start stop [WITHSCORES]返回有序集中指定区间内的成员,通过索引,分数从高到低
16ZREVRANGEBYSCORE key max min [WITHSCORES]返回有序集中指定分数区间内的成员,分数从高到低排
17ZREVRANK key member返回有序集合中指定成员的排名,有序集成员按分数值递减(从大到小)排序
18ZSCORE key member返回有序集中,成员的分数值
19ZUNIONSTORE destination numkeys key [key …]迭代有序集合中的元素(包括元素成员和元素分值)

*发布订阅命令行实现*

1、 打开一个客户端订阅channel1

SUBSCRIBE channel1

img

2、打开另一个客户端,给channel1发布消息hello

publish channel1 hello

img

返回的1是订阅者数量

3、打开第一个客户端可以看到发送的消息

img

注:发布的消息没有持久化,如果在订阅的客户端收不到hello,只能收到订阅后发布的消息


Units单位

配置大小单位,开头定义了一些基本的度量单位,只支持bytes,不支持bit

大小写不敏感

img

INCLUDES包含

img

类似jsp中的include,多实例的情况可以把公用的配置文件提取出来

###网络相关配置

bind

默认情况bind=127.0.0.1只能接受本机的访问请求

不写的情况下,无限制接受任何ip地址的访问

生产环境肯定要写你应用服务器的地址;服务器是需要远程访问的,所以需要将其注释掉

如果开启了protected-mode,那么在没有设定bind ip且没有设密码的情况下,Redis只允许接受本机的响应

img

保存配置,停止服务,重启启动查看进程,不再是本机访问了。

img

protected-mode

将本机访问保护模式设置no

img

Port

端口号,默认 6379

img

tcp-backlog

设置tcp的backlog,backlog其实是一个连接队列,backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列。

在高并发环境下你需要一个高backlog值来避免慢客户端连接问题。

注意Linux内核会将这个值减小到/proc/sys/net/core/somaxconn的值(128),所以需要确认增大/proc/sys/net/core/somaxconn和/proc/sys/net/ipv4/tcp_max_syn_backlog(128)两个值来达到想要的效果

img

timeout

一个空闲的客户端维持多少秒会关闭,0表示关闭该功能。即永不关闭。

img

tcp-keepalive

对访问客户端的一种心跳检测,每个n秒检测一次。

单位为秒,如果设置为0,则不会进行Keepalive检测,建议设置成60

img

GENERAL通用

daemonize

是否为后台进程,设置为yes

守护进程,后台启动

img

*pidfile*

存放pid文件的位置,每个实例会产生一个不同的pid文件

img

*loglevel*

指定日志记录级别,Redis总共支持四个级别:debug、verbose、notice、warning,默认为****notice****

四个级别根据使用阶段来选择,生产环境选择notice 或者warning

img

*logfile*

日志文件名称

img

databases 16

设定库的数量 默认16,默认数据库为0,可以使用SELECT 命令在连接上指定数据库id

img

SECURITY安全

*设置密码*

img

访问密码的查看、设置和取消

在命令中设置密码,只是临时的。重启redis服务器,密码就还原了。

永久设置,需要再配置文件中进行设置。

img

LIMITS限制

*maxclients*

Ø 设置redis同时可以与多少个客户端进行连接。

Ø 默认情况下为10000个客户端。

Ø 如果达到了此限制,redis则会拒绝新的连接请求,并且向这些连接请求方发出“max number of clients reached”以作回应。

img

*maxmemory*

Ø 建议****必须设置****,否则,将内存占满,造成服务器宕机

Ø 设置redis可以使用的内存量。一旦到达内存使用上限,redis将会试图移除内部数据,移除规则可以通过maxmemory-policy来指定。

Ø 如果redis无法根据移除规则来移除内存中的数据,或者设置了“不允许移除”,那么redis则会针对那些需要申请内存的指令返回错误信息,比如SET、LPUSH等。

Ø 但是对于无内存申请的指令,仍然会正常响应,比如GET等。如果你的redis是主redis(说明你的redis有从redis),那么在设置内存使用上限时,需要在系统中留出一些内存空间给同步队列缓存,只有在你设置的是“不移除”的情况下,才不用考虑这个因素。

img

*maxmemory-policy*

Ø volatile-lru:使用LRU算法移除key,只对设置了过期时间的键;(最近最少使用)

Ø allkeys-lru:在所有集合key中,使用LRU算法移除key

Ø volatile-random:在过期集合中移除随机的key,只对设置了过期时间的键

Ø allkeys-random:在所有集合key中,移除随机的key

Ø volatile-ttl:移除那些TTL值最小的key,即那些最近要过期的key

Ø noeviction:不进行移除。针对写操作,只是返回错误信息

img

*maxmemory-samples*

Ø 设置样本数量,LRU算法和最小TTL算法都并非是精确的算法,而是估算值,所以你可以设置样本的大小,redis默认会检查这么多个key并选择其中LRU的那个。

Ø 一般设置3到7的数字,数值越小样本越不准确,但性能消耗越小。

img

bgrewriteaof

我们可以输入命令来手动执行重写操作:

bgrewriteaof

或是在配置文件中配置自动重写:

# 百分比计算,这里不多介绍
auto-aof-rewrite-percentage 100
# 当达到这个大小时,触发自动重写
auto-aof-rewrite-min-size 64mb

至此,我们就完成了两种持久化方案的介绍,最后我们再来进行一下总结:

  • AOF:
    • 优点:存储速度快、消耗资源少、支持实时存储
    • 缺点:加载速度慢、数据体积大
  • RDB:
    • 优点:加载速度快、数据体积小
    • 缺点:存储速度慢大量消耗资源、会发生数据丢失

redis 事务 就是创建一个队列一起执行 之后提交后进行 multi ---- > exec | X discard

mysql 事务开启 执行未提交 报错回滚



keys *查看当前库所有key (匹配:keys *1)
exists key判断某个key是否存在
type key查看你的key是什么类型
del key删除指定的key数据
unlink key根据value选择非阻塞删除/仅将keys从keyspace元数据中删除,真正的删除会在后续异步操作。
expire key 1010秒钟:为给定的key设置过期时间
ttl key查看还有多少秒过期,-1表示永不过期,-2表示已过期
select命令切换数据库
dbsize查看当前数据库的key的数量
flushdb清空当前库
flushall通杀全部库

Redis - String相关命令
set 添加键值对
*NX当数据库中key不存在时,可以将key-value添加数据库
*XX当数据库中key存在时,可以将key-value添加数据库,与NX参数互斥
*EXkey的超时秒数
*PXkey的超时毫秒数,与EX互斥
get 查询对应键值
append 将给定的 追加到原值的末尾
strlen 获得值的长度
setnx 只有在 key 不存在时 设置 key 的值
incr 将 key 中储存的数字值增1 只能对数字值操作,如果为空,新增值为1
decr 将 key 中储存的数字值减1 只能对数字值操作,如果为空,新增值为-1
incrby / decrby <步长>将 key 中储存的数字值增减。自定义步长。
mset .....同时设置一个或多个 key-value对
mget .....同时获取一个或多个 value
msetnx .....同时设置一个或多个 key-value 对,当且仅当所有给定 key 都不存在。*原子性,有一个失败则都失败*
getrange <起始位置><结束位置>获得值的范围,类似java中的substring,*前包,后包*
setrange <起始位置>用 覆写所储存的字符串值,从<起始位置>开始(*索引从0开始*)。
*setex <过期时间**>*设置键值的同时,设置过期时间,单位秒。
getset 以新换旧,设置了新值同时获得旧值。

Redis-List常用命令
lpush/rpush ....从左边/右边插入一个或多个值。
lpop/rpop 从左边/右边吐出一个值。值在键在,值光键亡。
rpoplpush 从列表右边吐出一个值,插到列表左边。
lrange 按照索引下标获得元素(从左到右)
lrange mylist 0 -10左边第一个,-1右边第一个,(0 -1表示获取所有)
lindex 按照索引下标获得元素(从左到右)
llen 获得列表长度
linsert before 在的后面插入插入值
lrem 从左边删除n个value(从左到右)
lset将列表key下标为index的值替换成value

Redis - Set常用命令
sadd .....将一个或多个 member 元素加入到集合 key 中,已经存在的 member 元素将被忽略
smembers 取出该集合的所有值。
sismember 判断集合是否为含有该值,有1,没有0
scard返回该集合的元素个数。
srem ....删除集合中的某个元素。
spop 随机从该集合中吐出一个值。
srandmember 随机从该集合中取出n个值。不会从集合中删除 。
smove value把集合中一个值从一个集合移动到另一个集合
sinter 返回两个集合的交集元素。
sunion 返回两个集合的并集元素。
sdiff 返回两个集合的****差集****元素(key1中的,不包含key2中的)

Redis - Hash常用命令
hset 给集合中的 键赋值
hget 从集合取出 value
hmset ...批量设置hash的值
hexists查看哈希表 key 中,给定域 field 是否存在
hkeys 列出该hash集合的所有field
hvals 列出该hash集合的所有value
hincrby 为哈希表 key 中的域 field 的值加上增量 1 -1
hsetnx 将哈希表 key 中的域 field 的值设置为 value ,当且仅当域 field 不存在 .

Redis - Zset常用命令
zadd …将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
zrange [WITHSCORES]返回有序集 key 中,下标在之间的元素带WITHSCORES,可以让分数一起和值返回到结果集。
zrangebyscore key minmax [withscores] [limit offset count]返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
zrevrangebyscore key maxmin [withscores] [limit offset count]返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从大到小)次序排列。
zincrby 为元素的score加上增量
zrem 删除该集合下,指定值的元素
zcount 统计该集合,分数区间内的元素个数
zrank 返回该值在集合中的排名,从0开始。

一、String(字符串)

String 是 Redis 最基本的数据类型,一个 key 对应一个 value,这个 value 存储的就是一个String,它是二进制安全的,既可以存储纯文本字符串,也可以存储二进制字符串,也就是说可以直接存储图片或序列化的对象。String 类型的值最大为 512 MB

String 类型常用命令:

redis> set name jack
redis> get name
redis> setnx                     # 不存在才写入 (not exist)
redis> setex name 5 jack         # 指定过期时间
redis> incr num                  # 将 num 自增 1(不存在 num 时,当作 0 处理,自增后是 1)
redis> incrby num 3              # 将 num 自增 3

二、Hash(哈希)

Hash 即值是一个 String 类型键值映射表,简单理解为 JSON 格式数据。 Hash 适合用于存储对象

hset 命令用于为哈希表中的字段赋值。如果哈希表不存在,一个新的哈希表被创建并进行 hset 操作。如果字段已经存在于哈希表中,旧值将被覆盖

Hash 类型常用命令:

redis> hset user1 name jack
redis> hset user1 age 18

redis> hget user1 name
redis> hget user1 age

redis> hmset user2 name lily age 18
redis> hmget user2 name age

redis> hgetall user2

redis> HINCRBY user2 age 1

三、List(列表)

Redis 列表是简单的字符串列表,按照插入顺序排序。你可以添加一个元素导列表的头部(左边)或者尾部(右边)

List 类型常用命令:

redis> lpush mylist hello     # 从左放入
redis> lpush mylist world

redis> llen mylist            # 查看长度
redis> lrange mylist 0 -1     # 查看全部

redis> rpush mylist haha      # 从右放入
redis> rpop mylist            # 从右取出
redis> lpop mylist			   # 从左取出

redis> ltrim mylist 0 2       # 只留下左边的 3 条(下标 0 到 2)

四、Set(无序集合)

Redis 的 Set 是 String 类型的无序集合

Set 类型常用命令: (Set 是无序的,数据不能重复,List 是有序的,数据可重复)

redis> sadd myset1 a
redis> sadd myset1 b
redis> sadd myset1 c

redis> smembers myset1    # 查看全部

redis> srem myset1 b      # 删除

redis> spop  myset1       # 随机出一个

redis> sdiff   # 差集
redis> sinter  # 交集 
redis> sunion  # 并集

五、zset(Sorted Set 有序集合)

Redis zset 和 Set 一样也是 String 类型元素的集合,可排序 Set 集合,且不允许重复的成员。不同的是每个元素都会关联一个 double 类型的分数。Redis 正是通过分数来为集合中的成员进行从小到大的排序

Sorted Set 类型常用命令: ()

redis> zadd myzset1 1 a
redis> zadd myzset1 3 b
redis> zadd myzset1 2 c

redis> zrange myzset1 0 -1
redis> zrange myzset1 0 -1 withscores        # 显示分值
redis> zrevrange myzset1 0 -1 withscores     # 按分值从大到小

redis> ZINCRBY myzset1 4 a                   # 给 a 自增 4

配置文件


重写key vlaue的序列化方法 以及对象序列化


Java中操作Redis

掌握在 SpringBoot 中使用 RedisTemplate 操作 Redis

添加依赖 pom.xml

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

配置类

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.annotation.CachingConfigurerSupport;
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.*;
import org.springframework.data.redis.serializer.*;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * RedisTemplate 默认配置的是使用 Java JDK 的序列化,如果是对象,在Redis里查看时不直观
     * key 使用 String, value 列序列化 json
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();

        // 连接工厂
        template.setConnectionFactory(factory);

        // key 使用 StringRedisSerializer 来序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);

        // value 采用 json 序列化
        Jackson2JsonRedisSerializer<Object> jsonRedisSerializer = jsonSerializer();
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);

        template.afterPropertiesSet();

        return template;
    }

    /**
     * 序列化器
     */
    private Jackson2JsonRedisSerializer<Object> jsonSerializer() {

        Jackson2JsonRedisSerializer<Object> jsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

        // 对象映射
        ObjectMapper om = new ObjectMapper();

        // 序列化所有字段和修饰符范围
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        // 将类名序列化到json中 {"@class":"model.User", "id":"1", "name":"hello"}
        // 否则不能反序列化 {"id":"1", "name":"hello"}
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);

        jsonRedisSerializer.setObjectMapper(om);

        return jsonRedisSerializer;
    }
}

数据操作示例

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController
public class TestController {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @GetMapping("/test")
    public String test() {

        // string
        redisTemplate.opsForValue().set("foo", "hello");
        redisTemplate.opsForValue().set("bar", 100);

        String foo = (String) redisTemplate.opsForValue().get("foo");
        System.out.println(foo);  // hello

        String noData = (String) redisTemplate.opsForValue().get("noData");
        System.out.println(noData); // null

        redisTemplate.opsForValue().increment("bar");
        int bar2 = (int) redisTemplate.opsForValue().get("bar"); // 101
        System.out.println(bar2);

        // hash
        User user = new User(3, "Jack");
        redisTemplate.opsForValue().set("user1", user);
        User obj = (User) redisTemplate.opsForValue().get("obj");
        System.out.println(obj);

        Map<String, Object> map = new HashMap<>();
        map.put("name", "Mary");
        map.put("age", 18);
        redisTemplate.opsForHash().putAll("user2", map);


        Map<Object, Object> user3 = redisTemplate.opsForHash().entries("user2");
        System.out.println(user3);


        // list
        redisTemplate.opsForList().leftPush("names", "jack");
        redisTemplate.opsForList().leftPush("names", "mary");
        redisTemplate.opsForList().leftPush("names", "lily");


        System.out.println(redisTemplate.opsForList().rightPop("names"));  // jack
        System.out.println(redisTemplate.opsForList().rightPop("names"));  // mary
        System.out.println(redisTemplate.opsForList().rightPop("names"));  // lily
        System.out.println(redisTemplate.opsForList().rightPop("names"));  // null


        return "ok";
    }

    public static class User {
        private int id;
        private String name;

        public User() {
        }

        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

连接配置信息 application.properties

# Redis服务器地址 (默认127.0.0.1)
spring.redis.host=127.0.0.1
# Redis服务器连接端口 (默认6379)
spring.redis.port=6379
# Redis数据库索引 (默认为0)
spring.redis.database=0
# Redis服务器连接密码 (默认为空)
spring.redis.password=

刚学java菜鸡,永劫无间蚀月,王者荣耀王者,金铲铲小铂金,第五人格菜鸡,原神开服玩家,星穹铁道菜鸡,崩坏的菜鸡,闪耀暖暖,和平精英,LOL,CSGO,以及三A大作收集者等等。。。