声明：本博客部分内容是从终极SpringBoot讲义摘抄的，文字是OCR识别出来的，有可能存在识别错误的可能，如有错误，请大胆指正，我马上修改！

0.官方参考手册API
1.连接命令
2.key相关命令
3.String命令
4.List命令
5.Set命令
6.ZSet命令
7.Hash相关命令
8.事务相关命令
9.Java代码运行示例
- 9.1Redis同步请求代码
- 9.2Redis异步请求代码
- 9.3Redis反应式请求代码
10.订阅发布的Redis的Java代码演示
- 1.Subscriber.java
- 2.subscriber2.java
- 3.Publisher.java
11.杂碎的Redis笔记

在介绍 Redis 的使用之前，先简单介绍一下Redis 的数据存储知识。Redis 使用key-value 结构来保存数据，其中 value 支持如下 5 种数据类型。

Sting：最基本的数据类型，可保存任何数据。
Hash：是key-value 集合（类似于 Java 的 Map），key 和value 都是String 类型的数据。这
种类型主要用于保存对象。
List：元素是String 类型的有序集合，集合中的元素可以重复。
Set：元素是 String 类型的无序集合，集合中的元素不能重复。
ZSet：元素是 string 类型的有序集合，集合中的元素不能重复。

Redis 为不同数据类型提供了不同的操作命令，因此对于特定类型的数据需要使用对应类型的命令执行操作。
下面简单介绍一些 Redis 的常用命令。

0.官方参考手册API

👉：🔗Spring Data Redis 官方API参考手册
👉：🔗Lettuce 6.2.5.RELEASE API官方API参考手册

1.连接命令

auth 【用户名】 【密码】
这里用户名可以省略，假如我的密码是123456可以直接
auth 123456

在这里插入图片描述

2.key相关命令

与key 相关的常用命令如下。

DEL key:刪除key 対的 key-value 対。
DUMP key：导出key 对应的值。
EXISTS key：判断key 是否存在。
EXPIRE key seconds：设置key对应的key-value 对经过 seconds 秒后过期。
EXPIREAT key timestamp：设置key 对应的key-value 对到timestamp 时过期。
PEXPIRE key milliseconds: 设置 key 対的 key-value 对经过 milliseconds 毫秒后辻期。
PEXPIREAT key milliseconds-timestamp: 设置 key 对应的 key-value 对到
milliseconds-timestamp 时过期。
KEYS pattern: 返回匹配 pattern 的所有 key.
MOVE key db：将指定 key 移动到db 数据库中。
PERSIST key：删除key 的过期时间，key 将持久保持。
PTTL key：以毫秒为单位返回指定 key剩余的过期时间。
TTL key：以秒为单位返回指定key剩余的过期时问。
RANDOMKEY：从当前数据库返回一个随机的 key。
RENAME key newkey: 将 key 重命名 newkey。
RENAMENX key newkey: 相当手安全版的 RENAME，当 newkey 不存在オ能重命名
TYPE key：返回指定 key 存储的数据类型。
运行示例

3.String命令

正如前面所言，Redis 内不同数据类型提供了不同的操作命令，当 value 是 String 类型時，需要使用与 string 相关的命令进行操作。与 string 相关的常用命令如下。

SET key value: 设置 key-value 対。
GET key：返回指定key 对应的 value。
GETRANGE key start end: 获取指定 key 対的 value 中心 start 到 end 的子串。
GETSET key value: 指定 key 设置新的 value，非返回原来的 value。
MGET key [key .]：返回一个（或多个）指定key 对应的 value。
SETEX key seconds value：设置key-value 对，并设置过期时间为 seconds 秒。
SETNX key value： SET 的安全版本，只有当key 不存在时才能设置该key-value 对。
SETRANGE key offset value：设置和覆盖指定key对应的 value，从原有 value 的 offset 个字符开始；如果key 不存在，则将前 offset 个字符设为空 (\N0000)。
STRLEN key：获取 key对应的value 的字符串长度。
MSET key value rkey value…]：设置多个key value对。
MSETNX key value Tkey value…]： MSET 的安全版本，仅当所有key 都不存在时才能设置成功。
PSETEX key milliseconds value: SETEX 的毫秒版本，过期时间以毫秒计算。
INCR key：将指定 key 中存储的整数值加 1。
INCRBY key increment. 将指定key 中存修的整数値増加、inorement 整数值。
INCRBYFLOAT key increment. INCRBY 的平点数版木，incremcnt 可以是小数。
DECR Key：将指定 koy 中存储的整数值减1。
DECRBY key decrement。将指定key 中存储的整数值少decrement整数值。
APPEND key value 在指定key对应的字符串后追加新的value内容

在这里插入图片描述

4.List命令

List代表有序的集合，可通过命令为List添加或删除元素，List最多可包含2³²-1个元素。实际上，Redis的List也具有队列的性质，因此它包含了LPUSH LPOP RPUSH RPOP等命令，其中LPUSH LPOP表示从List的左边（队列头部）压入弹出元素；RPUSH RPOP表示从List的右边（队列尾部）压入弹出元素。
与List相关的常用命令如下。
➢ LINDEX key index：获取key对应的List的index处的元素。
➢ LINSERT key BEFORE|AFTER pivot value：在key对应的List的pivot元素之前或之后插入新的value元素。
➢ LLEN key：返回key对应的List的长度。
➢ LPOP key：弹出并返回key对应的List的第一个元素。
➢ LPUSH key value [value…]：向key对应的List的左边（队列头部）添加一个或多个元素。
➢ LPUSHX key value：LPUSH的安全版本，仅当key对应的List存在时有效。
➢ LRANGE key start stop：获取key对应的List中从start到stop范围内的元素。
➢ LREM key count value：从key对应的value中删除count个value元素。如果count大于0，则从左向右删除count个元素；如果count小于0，则从右向左删除count个元素；如果count等于0，则删除所有元素。
➢ LSET key index value：将key对应的List的index处的元素改为value。
➢ LTRIM key start stop：修剪List，只保留key对应的List中从start到stop之间的元素。
➢ RPOP key：弹出并返回key对应的List的最后一个元素。
➢ RPOPLPUSH source destination：弹出source的最后一个元素，添加到destination的左边（队列头部），并返回该元素。
➢ RPUSH key value [value…]：向key对应的List的右边（队列尾部）添加一个或多个元素。
➢ RPUSHX key value：RPUSH的安全版本，仅当key对应的List存在时有效。
➢ BLPOP key [key…] timeout：LPOP的阻塞版本。弹出并返回多个List的第一个元素，如果某个List没有元素，该命令会阻塞进
程，直到所有List都有元素弹出或超时。该命令的B代表Block。
➢ BRPOP key [key] timeout：RPOP的阻塞版本。弹出并返回多个List的最后一个元素，如果某个List没有元素，该命令会阻塞进
程，直到所有List都有元素弹出或超时。
➢ BRPOPLPUSH source destination timeout：RPOPLPUSH的阻塞版本，如果source中没有元素，该命令会阻塞进程，直到source有元
素弹出或超时。
在这里插入图片描述

5.Set命令

Set代表无序元素不能重复的集合，因此Set中的元素都是唯一的。Set最多可包含2³²-1个元素。Set底层其实是通过Hash表实现的，
因此它的删除查找的复杂度都是O（1），性能很好。
与Set相关的常用命令如下。
➢ SADD key member [member…]：向key对应的Set中添加一个
或多个元素。
➢ SCARD key：返回key对应的Set中元素的个数。
➢ SDIFF key [key…]：计算多个Set之间的差值。
➢ SDIFFSTORE destination key [key…]：SDIFF的存储版本，将多个Set之间的差值保存到destination中。
➢ SINTER key [key…]：返回给定Set的交集。
➢ SINTERSTORE destination key [key…]：SINTER的存储版本，将给定Set的交集保存到destination中。
➢ SISMEMBER key member：判断member是否为key对应的Set的元素。
➢ SMEMBERS key：返回key对应的Set的全部元素。
➢ SMOVE source destination member：将source中的member元素移到destination中。
➢ SPOP key：弹出key对应的Set中随机的一个元素。
➢ SRANDMEMBER key [count]：返回key对应的Set中随机的count个元素（不删除元素）。
➢ SREM key member [member…]：删除key对应的Set中的一个或多个元素。
➢ SUNION key [key…]：计算给定Set的并集。
➢ SUNIONSTORE destination key [key…]：SUNION的存储版本，将给定Set的并集保存到destination中。
在这里插入图片描述

6.ZSet命令

ZSet相当于Set 的增强版，它会为每个元素都分配一个double类型的score（分数），并按该score对集合中元素进行排序。
ZSet集合中的元素不允许重复，但元素的score是可以重复的。
与ZSet相关的常用命令如下。
➢ ZADD key score member [score member…]：向ZSet中添加一个或多个元素，或者更新已有元素的score。
➢ ZCARD key：返回key对应的ZSet中元素的个数。
➢ ZCOUNT key min max：返回ZSet中score位于min和max之间的元素个数。
➢ ZDIFF numkeys key [key…] [WITHSCORES]：计算给定ZSet之间的差值。该命令在Redis 6.2及更新版本中才可用。
➢ ZDIFFSTORE destination numkeys key [key…]：ZDIFF的存储版本，将给定ZSet之间的差值保存到destination中。该命令在Redi
s 6.2及更新版本中才可用。
➢ ZINCRBY key increment member：将memeber元素的score增加increment。
➢ ZINTER numkeys key [key…]：计算给定ZSet的交集。该命令在Redis 6.2及更新版本中才可用。
➢ ZINTERSTORE destination numkeys key [key…]：ZINTER的存储版本，将给定ZSet的交集保存到destination中。交集中元素的sc
ore是相同元素的score之和。
➢ ZLEXCOUNT key min max：返回ZSet中按字典排序时从min到max之间所有元素的个数。
提示：
当向ZSet中添加多个score相等的元素时，ZSet就会使用字典顺序
（英文字典中字母的排序方式）对这些元素进行排序，此时就可按字
典顺序来获取指定范围内元素的个数。
➢ ZPOPMAX key [count]：弹出ZSet中score最大的元素。
➢ BZPOPMAX key [key…] timeout：ZPOPMAX的阻塞版本。该命令会阻塞进程，直到指定ZSet有元素弹出或超时。
➢ ZPOPMIN key [count]：弹出ZSet中score最小的元素。
➢ BZPOPMIN key [key…] timeout：ZPOPMIN的阻塞版本。该命令会阻塞进程，直到指定ZSet有元素弹出或超时。
➢ ZRANGE key start stop [WITHSCORES]：返回ZSet中从start索引到stop索引范围内的元素（及score）。索引支持负数，负数表示
从最后面开始，比如-1代表最后一个元素。
➢ ZRANGEBYLEX key min max [LIMIT offset count]：返回ZSet
中按字典排序时从min到max之间的所有元素。
➢ ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]：返回ZSet中score位于min和max之间的所有元素。
➢ ZRANK key member：返回ZSet中指定元素的索引。score最小的元素的索引是0。
➢ ZREM key member [member…]：删除ZSet中一个或多个元素。
➢ ZREMRANGEBYLEX key min max：删除ZSet中按字典排序时从min到max之间的所有元素。
➢ ZREMRANGEBYRANK key start stop：删除ZSet中从start索引到stop索引之间的所有元素。
➢ ZREMRANGEBYSCORE key min max：删除ZSet中score位于min和max之间的所有元素。
➢ ZREVRANGE key start stop [WITHSCORES]：ZRANGE的反向版本。
➢ ZREVRANGEBYLEX key max min [LIMIT offset count]：ZRANGEBYLEX的反向版本。
➢ ZREVRANGEBYSCORE key max min [WITHSCORES]：ZRANGEBYSCORE的反向版本。
➢ ZREVRANK key member：ZRANK的反向版本。score最大的元素的反向索引是0。
➢ ZSCORE key member：获取指定元素的score。
➢ ZUNION numkeys key [key…]：计算给定ZSet的并集。该命令在Redis 6.2及更新版本中才可用。
➢ ZUNIONSTORE destination numkeys key [key…]：ZUNION的存储版本，将给定ZSet的并集保存到destination中。
➢ ZMSCORE key member [member…]：获取多个元素的score。该命令在Redis 6.2及更新版本中才可用。
在这里插入图片描述

7.Hash相关命令

Hash类型是一个key和value都是String类型的key-value对。Hash类型适合存储对象。每个Hash最多可存储2³²-1个key-value对。
与Hash相关的常用命令如下。
➢ HDEL key field [field…]：删除Hash对象中一个或多个key-value对。此处的field参数其实代表Hash对象中的key，后面提到的f
ield参数皆如此。
➢ HEXISTS key field：判断Hash对象中指定的key是否存在。
➢ HGET key field：获取Hash对象中指定key对应的value。
➢ HGETALL key：获取Hash对象中所有的key-value对。
➢ HINCRBY key field increment：为Hash对象中指定的key增加increment。
➢ HINCRBYFLOAT key field increment：HINCRBY的浮点数版本，支持小数。
➢ HKEYS key：获取Hash对象中所有的key。
➢ HLEN key：获取Hash对象中key-value对的数量。
➢ HMGET key field [field…]：HGET的加强版，可同时获取多个key对应的value。
➢ HSET key field value：为Hash对象设置一个key-value对。如果field对应的key已经存在，新设置的value将会覆盖原有的value。
➢ HMSET key field value [field value…]：HSET的加强版，可同时设置多个key-value对。
➢ HSETNX key field value：HSET的安全版本，只有当field对应的key不存在时，才能设置成功。
➢ HSTRLEN key field：获取Hash对象中指定key对应的value的字符串长度。
➢ HVALS key：获取Hash对象中所有的value。
在这里插入图片描述

8.事务相关命令

Redis事务保证事务内的多条命令会按顺序作为整体执行，其他客户端发出的请求绝不可能被插入到事务处理的中间，这样可以保证事
务内所有的命令作为一个隔离操作被执行。Redis事务同样具有原子性，事务内所有的命令要么全部被执行，要么全部被放弃。比如Redis在事务执行过程中遇到数据库宕机，假如事务已经执行了一半的命令，Redis将会自动回滚这些已经执行过的命令。注意某条命令执行出现错误并不会影响事务的提交。
与事务相关的常用命令如下。
➢ DISCARD：取消事务，放弃执行事务块内的所有命令。
➢ EXEC：执行事务。
➢ MULTI：开启事务。
➢ WATCH key [key…]：监视一个或多个key，如果在事务执行
之前这些key对应的值被其他命令改动，事务会自动中断。
➢ UNWATCH：取消WATCH命令对所有key的监视。
在这里插入图片描述

9.Java代码运行示例

记得导入依赖！！

        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </dependency>

9.1Redis同步请求代码

package com.example.domain;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.ScoredValue;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;

import java.time.Duration;
import java.util.Map;

public class Syn {
    public static void main(String[] args) {
        load_redis();
    }

    private static void load_redis() {
        RedisURI uri = RedisURI.builder().withHost("localhost")
                .withPort(6379)
                .withDatabase(0)
                .withPassword(new char[]{
                        '1', '2', '3', '4', '5', '6'
                }).withTimeout(Duration.ofMinutes(5)).build();
        RedisClient redisClient = RedisClient.create(uri);
        StatefulRedisConnection<String, String> connect = redisClient.connect();
        RedisCommands<String, String> cmd = connect.sync();
        cmd.set("name","fkjava");
        cmd.hmset("user", Map.of("name","fkjava","age","25","height","182"));
        cmd.sadd("items","鼠标","要是","钱包");
        cmd.zadd("test",3.0,"java");
        cmd.zadd("test", ScoredValue.just(2.0,"kotlin"),ScoredValue.just(2.5,"python"));
        connect.close();
        redisClient.shutdown();
    }
}

在这里插入图片描述

9.2Redis异步请求代码

package com.example.domain;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.ScoredValue;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.async.RedisAsyncCommands;
import io.lettuce.core.api.sync.RedisCommands;

import java.time.Duration;
import java.util.Map;
//异步请求
//异步请求
//异步请求
//异步请求
//异步请求
//异步请求
public class ASyn {
    private RedisClient client;
    private StatefulRedisConnection<String,String> conn;
    public void init(){
        RedisURI uri = RedisURI.builder().withHost("localhost")
                .withPort(6379)
                .withDatabase(2)
                .withPassword(new char[]{
                        '1', '2', '3', '4', '5', '6'
                }).withTimeout(Duration.ofMinutes(5)).build();
        this.client = RedisClient.create(uri);
        this.conn = client.connect();
    }
    public void AccessRedis(){
//        创建异步方式
        RedisAsyncCommands<String, String> cmd = conn.async();
        cmd.set("name","fkjava").thenAccept(System.out::println);
        cmd.hmset("user", Map.of("name","fkjava","age","25","height","182")).thenAccept(System.out::println);
        cmd.sadd("items","鼠标","要是","钱包").thenAccept(System.out::println);
        cmd.zadd("test",3.0,"java").thenAccept(System.out::println);
        cmd.zadd("test", ScoredValue.just(2.0,"kotlin"),ScoredValue.just(2.5,"python")).thenAccept(System.out::println);
    }
    public void closeResource(){
        conn.close();
        client.shutdown();
    }

    public static void main(String[] args) {
        ASyn app = new ASyn();
        app.init();
        app.AccessRedis();
        app.closeResource();
    }
}

9.3Redis反应式请求代码

package com.example.domain;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.ScoredValue;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.async.RedisAsyncCommands;
import io.lettuce.core.api.reactive.RedisReactiveCommands;

import java.time.Duration;
import java.util.Map;
//反应式请求
//反应式请求
//反应式请求
//反应式请求
//反应式请求
//反应式请求
//反应式请求
//反应式请求
//反应式请求
public class Reactive {
    private RedisClient client;
    private StatefulRedisConnection<String,String> conn;
    public void init(){
        RedisURI uri = RedisURI.builder().withHost("localhost")
                .withPort(6379)
                .withDatabase(3)
                .withPassword(new char[]{
                        '1', '2', '3', '4', '5', '6'
                }).withTimeout(Duration.ofMinutes(5)).build();
        this.client = RedisClient.create(uri);
        this.conn = client.connect();
    }

    /**
     * 对于反应式API，由于测试时想要立即获取结果，因此需要使用block来阻塞县城，获取反应式方法的结果。否则你的程序已经退出了，但反应式方法搜返回的Mono或Flux中数据还未到来.
     * 但如果你结合WebFlux使用反应式API，你可以直接让你控制器返回Mono或者Flux，这样就不需要block了。
     * 如果前端用的WEbFlux，后端用反应式api是很爽的，但如果前端用的是普通Spring MVC，那就不太理想了。
     */
    public void AccessRedis(){
//        创建反应式
        RedisReactiveCommands<String, String> cmd = conn.reactive();
        System.out.println(cmd.set("name","fkjava").block());
        System.out.println(cmd.hmset("user", Map.of("name","fkjava","age","25","height","182")).block());
        System.out.println(cmd.sadd("items","鼠标","要是","钱包").block());
        System.out.println(cmd.zadd("test",3.0,"java").block());
        System.out.println(cmd.zadd("test", ScoredValue.just(2.0,"kotlin"),ScoredValue.just(2.5,"python")).block());
    }
    public void closeResource(){
        conn.close();
        client.shutdown();
    }

    public static void main(String[] args) {
        Reactive app = new Reactive();
        app.init();
        app.AccessRedis();
        app.closeResource();
    }
}

10.订阅发布的Redis的Java代码演示

先启动Subscriber1和2的，后启动Publisher.java的，注意：public void subscribed(String channel, long count)的count是表示有几个订阅的意思！
Redis对象池的依赖


		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
			<version>2.10.0</version>
		</dependency>

1.Subscriber.java

package org.crazyit.app;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.ScoredValue;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.pubsub.RedisPubSubAdapter;
import io.lettuce.core.pubsub.StatefulRedisPubSubConnection;
import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands;
import io.lettuce.core.support.ConnectionPoolSupport;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import java.time.Duration;
import java.util.Map;

/**
 * Description:<br>
 * 网站: <a href="http://www.crazyit.org">疯狂Java联盟</a><br>
 * Copyright (C), 2001-2022, Yeeku.H.Lee<br>
 * This program is protected by copyright laws.<br>
 * Program Name:<br>
 * Date:<br>
 *
 * @author Yeeku.H.Lee kongyeeku@163.com 公众号: fkbooks<br>
 * @version 1.0
 */
public class Subscriper
{
	private RedisClient redisClient;
	private GenericObjectPool<StatefulRedisPubSubConnection<String, String>> pool;

	public void init()
	{
		// 1 定义RedisURI
		var uri = RedisURI.builder()
				.withHost("127.0.0.1")
				.withPort(6379)
				.withDatabase(1)
				.withPassword(new char[]{'1', '2', '3', '4', '5','6'})
				.withTimeout(Duration.ofMinutes(5))
				.build();
		// 2. 创建RedisClient
		this.redisClient = RedisClient.create(uri);
		var conf = new GenericObjectPoolConfig<StatefulRedisPubSubConnection<String, String>>();
		conf.setMaxTotal(20); // 设置允许的最大连接数
		// 3. 创建连接池对象（其中连接由redisClient的connectPubSub方法创建）
		pool = ConnectionPoolSupport.createGenericObjectPool(
				this.redisClient::connectPubSub, conf);
	}

	public void closeResource()
	{
		// 关闭连接池
		this.pool.close();
		this.redisClient.shutdown();
	}

	public void subscribe() throws Exception
	{
		// 从连接池中取出连接
		StatefulRedisPubSubConnection<String, String> conn = this.pool.borrowObject();
		// 4. 创建RedisPubSubCommands
		RedisPubSubCommands cmd = conn.sync();

		// 消息到来时，肯定是通过监听器来实现的
		conn.addListener(new RedisPubSubAdapter<>()
		{
			@Override
			public void message(String channel, String message)
			{
				System.out.printf("从%s收到消息:%s\n", channel, message);
			}

			@Override
			public void subscribed(String channel, long count)
			{
				System.out.println("完成订阅" + count);
			}

			@Override
			public void unsubscribed(String channel, long count)
			{
				System.out.println("取消订阅" + count);
			}
		});

		// 订阅channel
		cmd.subscribe("c1", "c2");
	}
	public static void main(String[] args) throws Exception
	{
		Subscriper s = new Subscriper();
		s.init();
		s.subscribe();
		// 该程序就只订阅1min
		Thread.sleep(60000);
		// 5. 关闭资源
		s.closeResource();
	}
}

2.subscriber2.java

package org.crazyit.app;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.pubsub.RedisPubSubAdapter;
import io.lettuce.core.pubsub.StatefulRedisPubSubConnection;
import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands;
import io.lettuce.core.support.ConnectionPoolSupport;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import java.time.Duration;

/**
 * Description:<br>
 * 网站: <a href="http://www.crazyit.org">疯狂Java联盟</a><br>
 * Copyright (C), 2001-2022, Yeeku.H.Lee<br>
 * This program is protected by copyright laws.<br>
 * Program Name:<br>
 * Date:<br>
 *
 * @author Yeeku.H.Lee kongyeeku@163.com 公众号: fkbooks<br>
 * @version 1.0
 */
public class Subscriper2
{
	private RedisClient redisClient;
	private GenericObjectPool<StatefulRedisPubSubConnection<String, String>> pool;

	public void init()
	{
		// 1 定义RedisURI
		var uri = RedisURI.builder()
				.withHost("127.0.0.1")
				.withPort(6379)
				.withDatabase(1)
				.withPassword(new char[]{'1', '2', '3', '4', '5','6'})
				.withTimeout(Duration.ofMinutes(5))
				.build();
		// 2. 创建RedisClient
		this.redisClient = RedisClient.create(uri);
		var conf = new GenericObjectPoolConfig<StatefulRedisPubSubConnection<String, String>>();
		conf.setMaxTotal(20); // 设置允许的最大连接数
		// 3. 创建连接池对象（其中连接由redisClient的connectPubSub方法创建）
		pool = ConnectionPoolSupport.createGenericObjectPool(
				this.redisClient::connectPubSub, conf);
	}

	public void closeResource()
	{
		// 关闭连接池
		this.pool.close();
		this.redisClient.shutdown();
	}

	public void subscribe() throws Exception
	{
		// 从连接池中取出连接
		StatefulRedisPubSubConnection<String, String> conn = this.pool.borrowObject();
		// 4. 创建RedisPubSubCommands
		RedisPubSubCommands cmd = conn.sync();

		// 消息到来时，肯定是通过监听器来实现的
		conn.addListener(new RedisPubSubAdapter<>()
		{
			@Override
			public void message(String channel, String message)
			{
				System.out.printf("从%s收到消息:%s\n", channel, message);
			}

			@Override
			public void subscribed(String channel, long count)
			{
				System.out.println("完成订阅" + count);
			}

			@Override
			public void unsubscribed(String channel, long count)
			{
				System.out.println("取消订阅" + count);
			}
		});

		// 订阅channel
		cmd.subscribe("c2");
	}

	public static void main(String[] args) throws Exception
	{
		Subscriper2 s = new Subscriper2();
		s.init();
		s.subscribe();
		// 该程序就只订阅1min
		Thread.sleep(60000);
		// 5. 关闭资源
		s.closeResource();
	}
}

3.Publisher.java

package org.crazyit.app;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.pubsub.RedisPubSubAdapter;
import io.lettuce.core.pubsub.StatefulRedisPubSubConnection;
import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands;
import io.lettuce.core.support.ConnectionPoolSupport;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import java.time.Duration;

/**
 * Description:<br>
 * 网站: <a href="http://www.crazyit.org">疯狂Java联盟</a><br>
 * Copyright (C), 2001-2022, Yeeku.H.Lee<br>
 * This program is protected by copyright laws.<br>
 * Program Name:<br>
 * Date:<br>
 *
 * @author Yeeku.H.Lee kongyeeku@163.com 公众号: fkbooks<br>
 * @version 1.0
 */
public class Publisher
{
	private RedisClient redisClient;
	private GenericObjectPool<StatefulRedisPubSubConnection<String, String>> pool;

	public void init()
	{
		// 1 定义RedisURI
		var uri = RedisURI.builder()
				.withHost("127.0.0.1")
				.withPort(6379)
				.withDatabase(1)
				.withPassword(new char[]{'1', '2', '3', '4', '5','6'})
				.withTimeout(Duration.ofMinutes(5))
				.build();
		// 2. 创建RedisClient
		this.redisClient = RedisClient.create(uri);
		var conf = new GenericObjectPoolConfig<StatefulRedisPubSubConnection<String, String>>();
		conf.setMaxTotal(20); // 设置允许的最大连接数
		// 3. 创建连接池对象（其中连接由redisClient的connectPubSub方法创建）
		pool = ConnectionPoolSupport.createGenericObjectPool(
				this.redisClient::connectPubSub, conf);
	}

	public void closeResource()
	{
		// 关闭连接池
		this.pool.close();
		this.redisClient.shutdown();
	}

	public void publish() throws Exception
	{
		// 从连接池中取出连接
		StatefulRedisPubSubConnection<String, String> conn = this.pool.borrowObject();
		// 4. 创建RedisPubSubCommands
		RedisPubSubCommands cmd = conn.sync();

		// 发布两条消息
		cmd.publish("c2", "欢迎学习Redis的消息机制");
		cmd.publish("c1", "Redis其实很简单");

		// 5. 关闭资源
		this.closeResource();
	}

	public static void main(String[] args) throws Exception
	{
		Publisher s = new Publisher();
		s.init();
		s.publish();
		s.closeResource();
	}
}

在这里插入图片描述

11.杂碎的Redis笔记

★ Lettuce的核心API

RedisURI：用于封装Redis服务器的URI信息。
RedisClient：代表Redis客户端，如果连接Cluster模式的Redis，则使用RedisClusterClient。
有点类似于redis-cli工具。
StatefulConnection<K,V>：代表Redis连接的父接口，它派生了不少子接口来代表不同的连接。
RedisCommands：用于执行Redis命令的接口，它的方法几乎覆盖了Redis的所有命令（前面介绍的那些命令全部都支持）
它的方法名和Redis命令名也是一一对应的，肯定一看就会，
比如Redis对操作Hash对象提供了hmset命令，那RedisCommands就支持hmset()方法，
它派生了一个RedisPubSubCommands<K,V>子接口，用于运行消息发布/订阅的命令。

★ Lettuce编程步骤：

 使用Lettuce操作Redis的大致步骤如下：

（1）定义RedisURI（有点类似于数据库的URL），再以RedisURI为参数，创建RedisClient或RedisClusterClient对象。
（2）调用RedisClient或RedisClusterClient的connectXxx()方法连接Redis服务器，根据所连接的Redis服务器的状态不同，该方法返回StatefulRedisXxxConnection连接对象。
（3）调用连接对象的sync()、async()或reactive()方法创建同步、异步或反应式模式的RedisCommands对象。
（4）调用RedisCommands执行Redis命令。这一步是变化最多的，因为RedisCommands可以执行Redis的全部命令。
（5）关闭资源。关闭资源时按照惯例“先开后闭”，因此先关闭与Redis的连接对象，再关闭RedisClient对象。 

 URI  →  创建Client → 建立连接  → 创建RedisCommands → 执行命令 → 关闭资源

★ 构建RedisURI：

Lettuce提供了如下三种方式来构建RedisURI：

A. 调用静态的create()方法。这种方式要求把所有的连接信息都写在create()方法的String参数中。
   该String参数既支持单机模式的Redis，也支持集群模式的Redis，也支持哨兵模式的Redis。

B. 调用Builder来构建。这种构建方式下，所有信息都通过Builder对应的方法逐项传入，

   因此可读性最好，这也是我所推荐的方式。 

C. 调用构造器来构建。这种方式是最不灵活的方式，因为它只能传入3个构造器参数，
   通过该方式构建RedisURI之后还需要调用它的setter方法对它进行设置，这种方式是最差的一种。

★ 从RedisClient到StatefulConnection对象（连接）
——获取与Redis服务器的连接

以RedisURI为参数，调用RedisClient（或RedisClusterClient）的create()静态方法即可创建RedisClient（或RedisClusterClient）对象。
根据Redis运行模式调用RedisClient或RedisClusterClient对象对应的connectXxx()方法获取StatefulConnection对象。

▲ StatefulConnection提供如下常用子接口：

- StatefulRedisConnection：最基本的Redis连接。
- StatefulRedisPubSubConnection：带消息发布/订阅功能的Redis连接。
- StatufulRedisMasterSlaveConnection：主从模式的Redis连接。
- StatefulRedisSentinelConnection：哨兵模式的Redis连接。

★ 从StatefulConnection到RedisXxxCommands对象

调用StatefulRedisXxxConnection连接对象的以下三个方法来创建RedisXxxCommands对象。

sync()：创建同步模式的RedisCommands对象。
async()：创建异步模式的RedisAsyncCommands对象。
reactive()：创建反应式模式的RedisReactiveCommands对象。

RedisCommands的作用类似于redis-cli.exe工具，用于执行各种Redis命令。
其中RedisAsyncCommands是异步版本，而RedisReactiveCommands则是反应式版本

★ 使用连接池管理Redis连接

从Redis 6.0开始，Redis可支持使用多线程来接收、处理客户端命令，因此应用程序可使用连接池来管理Redis连接。

Lettuce连接池支持需要Apache Commons Pool2的支持

接下来即可在程序中通过类似如下代码片段来创建连接池了。

var conf = new GenericObjectPoolConfig<StatefulRedisConnection<String, String>>();
conf.setMaxTotal(20); // 设置允许的最大连接数
// 创建连接池对象（其中连接由redisClient的connectPubSub方法创建）
pool = ConnectionPoolSupport.createGenericObjectPool(
redisClient::connect, conf);

★ Spring Boot为Redis提供的自动配置

spring-boot-starter-data-redis使用Spring Data Redis对底层Lettuce（或Jedis）进行了封装。

▲ 自动配置

Spring Boot会为Redis自动配置RedisConnectionFactory、
SpringBoot支持两种配置连接：Lettuce，Jedis。
StringRedisTemplate，
ReactiveStringRedisTemplate（反应式API），因此可将它们注入任意其他组件（比如DAO组件）。



如果配置了自定义的RedisConnectionFactory ，Spring Boot就不会自动配置RedisConnectionFactory。

但RedisTemplate可额外配置很多个，只要额外配置的RedisTemplate的id不是redisTemplate，
Spring Boot依然会自动配置id为redisTemplate的RedisTemplate。

StringRedisTemplate则不同，只要你在容器中配置了类型为StringRedisTemplate Bean,自动配置将不再配置它。

★ Redis配置相关的属性

可通过spring.redis.*开头的属性进行配置连接的服务器（该配置属于由RedisProperties类负责处理），例如如下配置：
spring.redis.host=192.168.1.188
spring.redis.port=6380
如果你指定了url属性，host, port, and password这些属性就会被覆盖

如果类加载路径下包含了Apache Commons Pool2依赖库，Spring Boot会使用连接池管理连接。可通过spring.redis.lettuce.pool.*开头的属性配置连接池。例如如下两行配置了有关连接池的信息：

# 指定连接池中最大的活动连接数为20
spring.redis.lettuce.pool.maxActive = 20
# 指定连接池中最大的空闲连接数为20
spring.redis.lettuce.pool.maxIdle=20

★ RedisTemplate

RedisTemplate是Spring Data Redis提供的，它相当于一个操作Redis数据库的门面类。

它提供如下方法来操作数据库：
一般用的都是它的子类：StringRedisTemplate——相当于它的key、value都是String类型：

- <HK,HV> HashOperations<K,HK,HV> opsForHash()：返回操作Hash对象的HashOperations对象。 
- ListOperations<K,V> opsForList()：返回操作List对象的ListOperations对象。
- SetOperations<K,V> opsForSet()：返回操作Set对象的SetOperations对象。
- ValueOperations<K,V> opsForValue()：返回操作String对象的ValueOperations对象。
- ZSetOperations<K,V> opsForZSet()：返回操作Zset对象的ZSetOperations<K,V> 对象。

【注意：】 程序实际上应该使用StringRedisTemplate来操作Redis数据库。

★ RedisTemplate VS RedisCommands

- RedisCommands的做法是它自己为Redis所有命令定义了对应的方法；

- RedisTemplate对Redis命令进行了分类，不同的命令由不同的接口提供支持：
  比如操作List的命令，由ListOperations负责提供；操作Set的命令，则由SetOperations负责提供；

  而RedisTemplate只是提供opsForXxx()方法来返回相应的操作接口。 

- RedisTemplate还提供了一些直接操作key的方法，例如delete(K key)（删key）、
  getExpire(K key)（获取key的过期时间）、move(K key, int dbIndex)（移动key）、

  rename(K oldKey, K newKey)（重命名key）等方法 


▲ 很明显，还是用Spring Bot Data Redis编程更简单。

 如果你直接用Lettuce编程，你需要自行创建RedidUri, RedisClient，StatefuleConnection，最后才能得到RedisCommand。
 但如果你用Spring Boot data Reids，Spring Boot可以自动配置RedisTEmplate，并将它注入DAO组件，因此方便得多。

★ Spring Data Redis的功能

 DAO接口只需继承CrudRepository，Spring Data Redis能为DAO组件提供实现类。

 - Spring Data Redis支持方法名关键字查询，只不过Redis查询的属性必须是被索引过的
   （索引就是为它建立对应的key，这样才能被查询）

 - Spring Data Redis同样支持DAO组件添加自定义的查询方法
   ——通过添加额外的父接口，并为额外的父接口提供实现类，
   Spring Data Redis就能该实现类中的方法“移植”到DAO组件中。

 - Spring Data Redis同样支持Example查询。

 A. 不支持@Query的自定义查询；
 B. 也不支持方法名查询中定义复杂的运算符；
 C. 也不支持Specification查询。

★ 方法名关键字查询

 Spring Data Redis的方法名关键字查询不如JPA那么强大，这是由Redis底层决定：
 Redis并不支持任何查询，它是一个简单的key-value数据库，
 因此它获取数据的唯一方式就是根据key获取value。因此它不能支持GreaterThan、LessThan、Like……等复杂关键字，它只能支持如下简单的关键字：

 - And：例如在接口中可以定义“findByNameAndAge”。
 - Or：例如“findByNameOrAge”。
 - Is、Equals：例如“findByNameIs”、“findByName”、“findByNameEquals”。
   这种表示相同或相等的关键字不加也行。
 - Top、First：例如“findFirst5Name”、“findTop5ByName”，实现查询前5条记录。

★ 注解

 Spring Data Redis提供了如下两个注解：

 - @RedisHash：该注解指定将数据类映射到Redis的Hash对象。类似于JPA的@Entity。
 - @TimeToLive：该注解修饰一个数值类型的属性，用于指定该对象的过期时长。

 Spring Data Redis还提供了如下两个索引化注解：

 - @Indexed：指定对普通类型的属性建立索引，索引化后的属性可用于查询。
 - @GeoIndexed：指定对Geo数据（地理数据）类型的属性建立索引。

★ Spring Data Redis的存储机制

 - key为books（由@RedisHash注解指定）的value是一个Set，Set中元素就是每个Book对象的标识属性值。

 - key为“books:<id值>”对应的Hash对象，就保存一个一个的持久化对象的全部信息。
   你的程序保存了几个持久化对象，Redis中就有几个key为“books:id值”格式的key-value对。

 - 每个索引后的属性，都会建立对应key。
   比如你对author属性建立了索引（@Indexed修饰），Spring Data Redis就会在数据库中建立以
   “books:author:*”开头的key，其中*就代表索引属性的每个可能的值。
   比如你对name属性建立了索引（@Indexed修饰），Spring Data Redis就会在数据库中建立以
   “books:name:*”开头的key，其中*就代表索引属性的每个可能的值。

   这种索引key对应的value是Set类型，该Set的元素就是该key对应的所有实体的id值。


 - 每个实体，都会有一个单独key。
   books: <id值>: idx： 该key对应的value是Set，该Set集合就保存在实体所支持的全部的索引属性key。


 ▲ 假设Spring Data Redis要查询ID为2的Book对象

 （1）确定Book类上的@RedisHash，该注解指定Book对应的key前缀为books

 （2）Redis获取key为 “books:2”对应value，该value是被查询对象的全部信息。


 ▲ 根据索引属性来查询，假设Spring Data Redis要查询name为Python的Book对象

 （1）确定Book类上的@RedisHash，该注解指定Book对应的key前缀为books

 （2） Redis获取key为" books:name:Python"所对应的value。

 （3）该value返回的就是Set，该Set中的每个值都是ID。

 （4）遍历第3步中Set里的每个ID，然后Redis获取key为 “books:<ID>”对应value，该value是被查询对象的全部信息。