multi —标记一个事务块的开始
exec —执行事务块中的命令
discard — 取消事务，放弃执行事务块内的所有命令。
watch — 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。
unwatch — 取消 WATCH 命令对所有 key 的监视

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set name li3
QUEUED
127.0.0.1:6379> get name
QUEUED
127.0.0.1:6379> ttl name
QUEUED
127.0.0.1:6379> expire name 20
QUEUED
127.0.0.1:6379> ttl name
QUEUED
127.0.0.1:6379> exec
1) OK
2) "li3"
3) (integer) -1
4) (integer) 1
5) (integer) 20

redis服务器默认只能本机访问,不对外开放 ( bind 绑定 ip 默认是 bind 127.0.0.1, 增加 当前虚拟机的IP )
没有密码,需要设置密码才是安全的生产环境 ( requirepass 密码, 设置 登录密码 )
运行在前台 ( daemonize 改成 yes, 调整成守护进程 )
需要修改服务器配置,则修改redis.conf即可 ( 执行 vi redis.conf )

redis.conf 配置文件 根据安装方式不同 , 文件位置也不同

输入/requirepass 从上往下搜索 requirepass 单词

# 转到配置文件所在位置
[root@localhost ~]# cd /etc
# 打开 redis配置文件 redis.conf 的编辑界面
[root@localhost etc]# vi redis.conf



# 在文件中 通过 /bind 找到 bind 配置, 增加虚拟机ip
# 或者 将 这行注释掉, 所有都可以访问
bind 192.168.0.93 127.0.0.1


# 在文件中 通过 /requirepass 找到 登录密码设置
# requirepass foobared
# 解开注释, 调整成自己的密码
requirepass turing


# 在文件中 通过 /daemonize 找到 设置守护进程
# 将 daemonize no  调整成 yes
daemonize yes

# 退出 保存
:wq

修改 protected-mode yes 改为：protected-mode no

redis-cli

​ -h ip 地址

​ -p 端口

-a 密码

# 在没有打开 redis服务时, 登录客户端 会报连接不上
[root@localhost ~]# redis-cli
Could not connect to Redis at 127.0.0.1:6379: Connection refused
not connected> 

# 运行启动指令时, 要指明 配置文件及路径 
[root@localhost ~]# redis-server /etc/redis.conf 

# 启动客户端时, 可以通过  -h 指定 服务器 所在IP
[root@localhost ~]# redis-cli -h 192.168.0.93
# 但通过ping 不通, 没有权限
192.168.0.93:6379> ping
(error) NOAUTH Authentication required.

# 通过 auth 指明 密码
192.168.0.93:6379> auth turing
OK
192.168.0.93:6379> ping
PONG

在 windows 环境 中 安装 客户端 RedisDesktopManager

关闭 虚拟机 防火墙 后 , 再启动redis服务器

# 关闭防火墙
[root@localhost ~]# systemctl stop firewalld.service 
# 禁止开机启动防火墙
[root@localhost ~]# systemctl disable firewalld.service
Removed symlink /etc/systemd/system/multi-user.target.wants/firewalld.service.
Removed symlink /etc/systemd/system/dbus-org.fedoraproject.FirewallD1.service.
# 再启动 redis 服务器
[root@localhost ~]# redis-server /etc/redis.conf 

在 增加连接

RedisDesktopManager

Another Redis Desktop Manager

在 redis 保存 name -> hello

127.0.0.1:6379> set name hello
OK
# 在客户端 就可以 查看到,也可以修改
127.0.0.1:6379> get name
"hello"

# 在这里也可以查看 客户端的修改内容
127.0.0.1:6379> get name
"hello world"

​ Redis 提供两种持久化机制 RDB（默认） 和 AOF 机制:

是Redis DataBase缩写快照

RDB是Redis默认的持久化方式。按照一定的时间将内存的数据以快照的形式保存到硬盘中，对应产生的数据文件为dump.rdb。通过配置文件中的save参数来定义快照的周期。

优点：

• 1、只有一个文件 dump.rdb，方便持久化。
• 2、容灾性好，一个文件可以保存到安全的磁盘。
• 3、性能最大化，fork 子进程来完成写操作，让主进程继续处理命令，所以是 IO 最大化。使用单独子进程来进行持久化，主进程不会进行任何 IO 操作，保证了 redis 的高性能
• 4.相对于数据集大时，比 AOF 的启动效率更高。

缺点：

• 1、数据安全性低。RDB 是间隔一段时间进行持久化，如果持久化之间 redis 发生故障，会发生数据丢失。所以这种方式更适合数据要求不严谨的时候)
• 2、由于RDB是通过fork子进程来协助完成数据持久化工作的，因此，如果当数据集较大时，可能会导致整个服务器停止服务几百毫秒，甚至是1秒钟。

AOF持久化(即Append Only File持久化)，则是将Redis执行的每次写命令记录到单独的日志文件中，当重启Redis会重新将持久化的日志中文件恢复数据。

当两种方式同时开启时，数据恢复Redis会优先选择AOF恢复。

优点：

• 1、数据安全，aof 持久化可以配置 appendfsync 属性，有 always，每进行一次 命令操作就记录到 aof 文件中一次。
• 2、通过 append 模式写文件，即使中途服务器宕机，可以通过 redis-check-aof 工具解决数据一致性问题。
• 3、AOF 机制的 rewrite 模式。AOF 文件没被 rewrite 之前（文件过大时会对命令 进行合并重写），可以删除其中的某些命令（比如误操作的 flushall）)

缺点：

• 1、AOF 文件比 RDB 文件大，且恢复速度慢。
• 2、数据集大的时候，比 rdb 启动效率低。

两种方式比较:

• AOF文件比RDB更新频率高，优先使用AOF还原数据。
• AOF比RDB更安全也更大
• RDB性能比AOF好
• 如果两个都配了优先加载AOF

不通过 配置文件启动 服务, dump.rdb 在 启动的文件夹

[root@localhost ~]# ls
dump.rdb

使用 配置文件 启动时 , dump.rdb 默认在 /var/lib/redis 文件夹下, 这是配置在 配置文件里

备份时会在 dir 属性指定的路径下存储一个 dump.rdb 文件,

还原: 在 dump.rdb 文件所在目录启动服务即可.

# 获取存储文件的位置

127.0.0.1:6379> config get dir
1) "dir"
2) "/var/lib/redis"

# 修改存储文件的位置
127.0.0.1:6379> config set dir /root/temp

#  同步备份 save 异步备份  bgsave 
127.0.0.1:6379> save
OK

redis-check-rdb dump.rdb 检查备份文件

[root@localhost ~]# redis-check-rdb dump.rdb 
[offset 0] Checking RDB file dump.rdb
[offset 27] AUX FIELD redis-ver = '3.2.12'
[offset 41] AUX FIELD redis-bits = '64'
[offset 53] AUX FIELD ctime = '1624846372'
[offset 68] AUX FIELD used-mem = '757288'
[offset 70] Selecting DB ID 0
[offset 530] Checksum OK
[offset 530] \o/ RDB looks OK! \o/
[info] 13 keys read
[info] 0 expires
[info] 0 already expired

​

(1)连接
auth 验证密码
select index 切换数据库 redis 有 16个数据库, 默认用 db0

​ quit 断开连接
​ ping 判断客户端是否与服务端连通

(2)服务
dbsize 当前数据库 key 的数量
flushdb 删除当前数据库的所有 key
flushall 删除所有数据库的所有 key
info 服务运行信息
time 查看时间

​ shutdown 关闭服务

Springboot2 中使用 redis,有两个客户端可供选择,他们是 Jedis 和 lettuce, 且Springboot2 默认采用 lettuce 作为客户端.
Jedis 和 lettuce 的区别?
jedis 在多线程环境下是非线程安全的，使用了 jedis pool 连接池，为每个 Jedis 实例增加物理连接。
Lettuce 的连接是基于 Netty 的，连接实例（StatefulRedisConnection）可以在多个线程间并发访问。

Jedis：是Redis的Java实现客户端，提供了比较全面的Redis命令的支持，使用阻塞的I/O，程序流需要等到sockets处理完I/O才能执行，不支持异步。Jedis客户端实例不是线程安全的，所以需要通过连接池来使用Jedis。

Redisson：Redisson实现了分布式和可扩展的Java数据结构，和Jedis相比，功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。基于Netty框架的事件驱动的通信层，其方法调用是异步的。Redisson的API是线程安全的。

Lettuce：高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器，主要在一些分布式缓存框架上使用比较多。基于Netty框架的事件驱动的通信层，其方法调用是异步的。Lettuce的API是线程安全的。

使用 Jedis 客户端

        <!--springboot 1.X 是使用 jedis 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>

        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

使用 lettuce 客户端

<!-- springboot 2.X redis 依赖-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
        <!--连接池-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

使用 jedis 客户端

spring.redis.host=192.168.0.93
spring.redis.port=6379
spring.redis.password=turing
spring.redis.timeout=3000
spring.redis.database=0
#最大连接数,默认 8
spring.redis.jedis.pool.max-active=30
#最小空闲数,默认 0
spring.redis.jedis.pool.min-idle=0
#最大空闲数,默认 8
spring.redis.jedis.pool.max-idle=8
#等待时间,负值表示没有限制
spring.redis.jedis.pool.max-wait=-1

使用 lettuce 客户端

spring.redis.host=192.168.0.93
spring.redis.port=6379
spring.redis.password=turing
spring.redis.timeout=3000
spring.redis.database=0
#关闭超时时间
spring.redis.lettuce.shutdown-timeout=100
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=30
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=8
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.lettuce.pool.max-wait=-1

@Autowired
private RedisTemplate redisTemplate;

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

@Autowired
private RedisTemplate redisTemplate;

// 删除key
public void delete(String key){
    redisTemplate.delete(key);
}
// 删除多个key
public void deleteKey (String ...keys){
    redisTemplate.delete(keys);
}
// 指定key的失效时间
public void expire(String key,long time){
    redisTemplate.expire(key,time,TimeUnit.MINUTES);
}
// 根据key获取过期时间
public long getExpire(String key){
    Long expire = redisTemplate.getExpire(key);
    return expire;
}
// 判断key是否存在
public boolean hasKey(String key){
    return redisTemplate.hasKey(key);
}

//1、通过redisTemplate设置值
redisTemplate.boundValueOps("StringKey").set("StringValue");
redisTemplate.boundValueOps("StringKey").set("StringValue",1, TimeUnit.MINUTES);

//2、通过BoundValueOperations设置值
BoundValueOperations stringKey = redisTemplate.boundValueOps("StringKey");
stringKey.set("StringVaule");
stringKey.set("StringValue",1, TimeUnit.MINUTES);

//3、通过ValueOperations设置值
ValueOperations ops = redisTemplate.opsForValue();
ops.set("StringKey", "StringVaule");
ops.set("StringValue","StringVaule",1, TimeUnit.MINUTES);

redisTemplate.boundValueOps("StringKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("StringKey",1,TimeUnit.MINUTES);

//1、通过redisTemplate设置值
String str1 = (String) redisTemplate.boundValueOps("StringKey").get();

//2、通过BoundValueOperations获取值
BoundValueOperations stringKey = redisTemplate.boundValueOps("StringKey");
String str2 = (String) stringKey.get();

//3、通过ValueOperations获取值
ValueOperations ops = redisTemplate.opsForValue();
String str3 = (String) ops.get("StringKey");

//1、通过redisTemplate设置值
redisTemplate.boundHashOps("HashKey").put("SmallKey", "HashVaue");

//2、通过BoundValueOperations设置值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
hashKey.put("SmallKey", "HashVaue");

//3、通过ValueOperations设置值
HashOperations hashOps = redisTemplate.opsForHash();
hashOps.put("HashKey", "SmallKey", "HashVaue");

redisTemplate.boundValueOps("HashKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("HashKey",1,TimeUnit.MINUTES);

HashMap<String, String> hashMap = new HashMap<>();
redisTemplate.boundHashOps("HashKey").putAll(hashMap );

//1、通过redisTemplate获取值
Set keys1 = redisTemplate.boundHashOps("HashKey").keys();

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
Set keys2 = hashKey.keys();

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
Set keys3 = hashOps.keys("HashKey");

//1、通过redisTemplate获取值
List values1 = redisTemplate.boundHashOps("HashKey").values();

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
List values2 = hashKey.values();

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
List values3 = hashOps.values("HashKey");

//1、通过redisTemplate获取
String value1 = (String) redisTemplate.boundHashOps("HashKey").get("SmallKey");

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
String value2 = (String) hashKey.get("SmallKey");

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
String value3 = (String) hashOps.get("HashKey", "SmallKey");

//1、通过redisTemplate获取
Map entries = redisTemplate.boundHashOps("HashKey").entries();

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
Map entries1 = hashKey.entries();

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
Map entries2 = hashOps.entries("HashKey");

//删除小key
redisTemplate.boundHashOps("HashKey").delete("SmallKey");
//删除大key
redisTemplate.delete("HashKey");

//1、通过redisTemplate设置值
redisTemplate.boundSetOps("setKey").add("setValue1", "setValue2", "setValue3");

//2、通过BoundValueOperations设置值
BoundSetOperations setKey = redisTemplate.boundSetOps("setKey");
setKey.add("setValue1", "setValue2", "setValue3");

//3、通过ValueOperations设置值
SetOperations setOps = redisTemplate.opsForSet();
setOps.add("setKey", "SetValue1", "setValue2", "setValue3");

redisTemplate.boundValueOps("setKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("setKey",1,TimeUnit.MINUTES);

//1、通过redisTemplate获取值
Set set1 = redisTemplate.boundSetOps("setKey").members();

//2、通过BoundValueOperations获取值
BoundSetOperations setKey = redisTemplate.boundSetOps("setKey");
Set set2 = setKey.members();

//3、通过ValueOperations获取值
SetOperations setOps = redisTemplate.opsForSet();
Set set3 = setOps.members("setKey");

//1、通过redisTemplate设置值
redisTemplate.boundListOps("listKey").leftPush("listLeftValue1");
redisTemplate.boundListOps("listKey").rightPush("listRightValue2");

//2、通过BoundValueOperations设置值
BoundListOperations listKey = redisTemplate.boundListOps("listKey");
listKey.leftPush("listLeftValue3");
listKey.rightPush("listRightValue4");

//3、通过ValueOperations设置值
ListOperations opsList = redisTemplate.opsForList();
opsList.leftPush("listKey", "listLeftValue5");
opsList.rightPush("listKey", "listRightValue6");

ArrayList<String> list = new ArrayList<>();
redisTemplate.boundListOps("listKey").rightPushAll(list);
redisTemplate.boundListOps("listKey").leftPushAll(list);

redisTemplate.boundValueOps("listKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("listKey",1,TimeUnit.MINUTES);

String listKey2 = (String) redisTemplate.boundListOps("listKey").leftPop();  //从左侧弹出一个元素
String listKey3 = (String) redisTemplate.boundListOps("listKey").rightPop(); //从右侧弹出一个元素

//1、通过redisTemplate设置值
redisTemplate.boundZSetOps("zSetKey").add("zSetVaule", 100D);

//2、通过BoundValueOperations设置值
BoundZSetOperations zSetKey = redisTemplate.boundZSetOps("zSetKey");
zSetKey.add("zSetVaule", 100D);

//3、通过ValueOperations设置值
ZSetOperations zSetOps = redisTemplate.opsForZSet();
zSetOps.add("zSetKey", "zSetVaule", 100D);

DefaultTypedTuple<String> p1 = new DefaultTypedTuple<>("zSetVaule1", 2.1D);
DefaultTypedTuple<String> p2 = new DefaultTypedTuple<>("zSetVaule2", 3.3D);
redisTemplate.boundZSetOps("zSetKey").add(new HashSet<>(Arrays.asList(p1,p2)));

Set<TypedTuple<String>> tuples = redisTemplate.boundZSetOps("zSetKey").rangeWithScores(0L, 3L);
  for (TypedTuple<String> tuple : tuples) {
      System.out.println(tuple.getValue() + " : " + tuple.getScore());
  }ss

//从小到大
Long startRank = redisTemplate.boundZSetOps("zSetKey").rank("zSetVaule");
//从大到小
Long endRank = redisTemplate.boundZSetOps("zSetKey").reverseRank("zSetVaule");

if redis.call("get",KEYS[1]) == ARGV[1]
then
    return redis.call("del",KEYS[1])
else
    return 0
end

String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
                                "then\n" +
                                "    return redis.call(\"del\",KEYS[1])\n" +
                                "else\n" +
                                "    return 0\n" +
                                "end";
redisTemplate.execute(new DefaultRedisScript<Integer>(script, Integer.class), Arrays.asList("lock"), uuid);