手把手实战 Redis 教学

# 查看 C语言环境版本: Centos7默认gcc 版本是4.8.3 安装redis6，gcc版本一定要5.3以上
# Red Hat 为了软件的稳定和版本支持，yum 上版本也是4.8.3 所以不建议使用：yum install gcc-c++ 下载/更新
gcc --version

# 安装scl源
# 是为了给 RHEL/CentOS 用户提供一种以方便、安全地安装和使用应用程序和运行时环境的多个版本的方式，同时避免把系统搞乱
# yum 下载过程中需要,确定操作一下,输入 y 回车
yum install centos-release-scl scl-utils-build
# 安装8版本的gcc、gcc-c++、gdb工具链
yum install -y devtoolset-8-toolchain
# 启动...
scl enable devtoolset-8 bash

# ① 进入上传目录,解压Redis 压缩文件
tar -zxvf redis-6.2.1.tar.gz

# ② 进入解压后的Redis 文件目录: 执行 编译安装...
cd redis-6.2.1
# 	make C语言的命令对文件进行编译,如果没有C语言环境是会出错的,需要执行： make distclean 清理错误
make
# 	正常情况编译后会提示：make test 测试,可以忽略直接进行安装：
make install

# ③ 最开始上传的只是一个安装包,通过make 命令进行了安装,Linux 默认安装程序的目录是：/usr/local/bin
#	进入Linux软件安装目录,查看安装的Redis服务
cd /usr/local/bin
ls
#	Redis服务介绍：
# 	redis-benchmark:	 性能测试工具，可以在自己本子运行，看看自己本子性能如何
# 	redis-check-aof：	修复有问题的AOF文件，rdb和aof后面介绍
# 	redis-check-dump：	修复有问题的dump.rdb文件
# 	redis-sentinel：		Redis集群使用(哨兵模式)
#	redis-server：		Redis服务器启动命令
# 	redis-cli：			客户端，操作入口

# ④ 启动redis服务 /usr/local/bin 目录下执行：
redis-server
# 	可以看到Redis 服务器的：ip 端口6379
16999:C 26 Jan 2022 22:56:23.819 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
16999:C 26 Jan 2022 22:56:23.819 # Redis version=6.2.1, bits=64, commit=00000000, modified=0, pid=16999, just started
16999:C 26 Jan 2022 22:56:23.819 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
16999:M 26 Jan 2022 22:56:23.820 * monotonic clock: POSIX clock_gettime
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 6.2.1 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 16999
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

16999:M 26 Jan 2022 22:56:23.820 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
16999:M 26 Jan 2022 22:56:23.820 # Server initialized
16999:M 26 Jan 2022 22:56:23.820 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
16999:M 26 Jan 2022 22:56:23.820 * Loading RDB produced by version 6.2.1

# 检查Linux 中是否有Redis 线程存活：
ps -ef|grep redis
# 存在：检查到6379...
root     26537     1  0 00:28 ?        00:00:00 redis-server *:6379
root     26576 17279  0 00:28 pts/2    00:00:00 grep --color=auto redis
# 不存在：没有找到运行端口
root     26467 17279  0 00:27 pts/2    00:00:00 grep --color=auto redis

-------------------------------------------------------------
# 测试连接 返回pong 连接成功
	ping
# 切换数据库,Redis 初始化具有16个数据库,默认使用第 0 个库,可以通过 select index 进行切换
	select index 		# index 	指0-15 16个库下标
# 查看当前下标库大小
	dbsize
# 清空当前数据库所有数据
	flushdb
# 清空Redis所有数据库数据 (16个数据库
	flushall

-------------------------key操作：增删改查...------------------------------
# 查看所有的key
	keys *
# 查看指定key 是否存在
	exsist 	k			# 1存在 0不存在
# 查看当然key 是什么类型
	type 	k
# 设置指定key 的存活时间 单位秒;
	expire	k	s
# 让设置了定时的key 还未死亡,重新设置永久存活
	persist k
# 查询指定key 的存活时间
	ttl		k			# -1表示永不过期，-2表示已过期|不存在，返回剩余秒数
	
# 添加一组 k v 存储数据,对相同的key多次设置值，会直接覆盖 
	set 	k 	v
# 查看指定 k 的 v
	get 	k
# 当前数据库中删除
	del 	k	
# 仅将key 从keyspace元数据中删除，真正的删除会在后续异步操作(非阻塞删除
	unlink	key
# 修改一个 k 的名字	
	rename 	k1	k2		# 更改k1 的名字为k2
						# 如果试图修改一个不存在的key 将会报出错误
						# 要更改的 k2 已经存在,拥有一个v值, 会将 k1 的值赋值给 k2 k1消失
						
# renamenx 安全性修改: 只有要修改的 k名不存在,才可以进行修改 1成功 0失败
	renamenx k1  k2
# 随机返回Redis一个key
	randomkey

# 新增一个元素 
set 		<k> 	<v> 	[NX|XX|EX|PX]				#添加一对 k v 结构数据,如果相同的k 后面会覆盖前面的数据
														# NX：当数据库中key不存在时，可以将key-value添加数据库
                                            			# XX：必须key存在!不然无效命令,可以将原先 k v 覆盖)与NX参数相反;
			                                            # EX：key的超时秒数
			                                            # PX：key的超时毫秒数，与EX互斥
			                                            ....  省略参数....配置
# 只有key不存在的时候才可以设置值			                                            
sernx		<k>		<过期时间>		<v>
# 设置key同时设置过期时间
setex		<k>		<v>
# 设置更新key的值,并返回旧的数据: k必须是实现存在的,进行修改;
getset		<k>		<v>
# 查询一个key 的值，不存在返回 nil Redis的空标识不存在;
get 		<k>

-------------------------字符功能命令：-----------------------------------------
# 获得值的范围数据，类似java中的substring 前包 后包
getrange	<k>		<起始位置>	<结束位置>				   #参数必须得填,且是数值类型... 第一个位置0 最后一个位置-1(倒数第二位置-2)
# 用 <value>  覆写 <key> 所储存的字符串值.
setrange	<k>		<起始位置>	<value>					  #从字符 起始位置开始,到 value 字符长度的一段都被覆盖...
# 给指定key的字符串值,追加一下字符数据;
append 		<k> 	<v>
# 获取key的字符长度
strlen		<k>	
-------------------------原子性操作：-------------------------------
# 只能对数字值操作将 key 中储存的数字值增1 如果为空，新增值为1 (原子性)
incr 		<k>
# 只能对数字值操作将 key 中储存的数字值减1 如果为空，新增值为-1 (原子性)
decr		<k>
# 将 key 中储存的数字值增减自定义步长,步长要是数值类型,且必须得写！
incrby		<k>		<步长>
decrby		<k>		<步长>
# 同时设置一个或多个 k-v 数据 (原子性:一个失败都失败！)
mset		<k1>	<v1>	<k2><v2><k3><v3>...
# 同时设置一个或多个 k-v 数据,且所有的key都是实现不存在的 (原子性:一个失败都失败！)
msetnx		<k1>	<v1>	<k2><v2><k3><v3>...
# 同时获取多个 k 的值 (原子性:一个失败都失败！)
mget		<k1><k2><k3>...

# 从左边插入一个或多个值
lpush			<k>		<v>		<v2><v3>...
# 从右边插入一个或多个值
rpush			<k>		<v>		<v2><v3>...
# 从左边获取一个值
lpop 			<k>
# 从右边获取一个值,当一个list 中所有的值获取完了,redis对应的k 也就消失了(值在键在,值亡键亡) 
rpop			<k>
# 从k1(list) 右边获取一个值,往 k2(list) 左边插入~ 只有 rpoplpush 没有 lpoprpush...
rpoplpush		<k1> 	<k2>

-----------------------------功能命令：--------------------------------
# 根据下标显示 k(list) 中多个元素 start stop都是数值类型(0起始 -1倒数第一个下标 -2倒二) 该指令查看并不会移除元素; 
lrange			<k>		<start>		<stop>		
# 根据下标显示 k(list) 中元素,并不会删除元素... (index数值类型)
lindex			<k>		<index>
# 获取 k(list) 中元素数量
llen			<k>
# 在指定的 k(list) 某个元素 'Before之前|After之后' 插入新的值:
linsert			<k>		Before|After	<v1>	<v2>		# 在 v1 的前面或后面插入v2 相同的值,以最左边为准
# 移除 K(list) 中 指定数量count 的 v 匹配的元素, 从左往右移除...
lrem			<k>		<count>			<v>					# 返回移除的数量: count>0从头往下找匹配删除 count<0从下往上匹配 count=0全部匹配的删除
# 将 k(list) 指定下标index 的元素,替换成 v
lset			<k>		<index>			<v>					# 下标长度存在回报错.

-----------------------------增删改查----------------------------------
# 将一个或多个元素v 加入到集合 k 中，已经存在的元素将被忽略
sadd				<k>		<v1>	<v2><v3>...
# 查看该集合 k(set) 的所有值, set 并不会删除值
smembers 			<k>		
# 随机从集合 k(set) 获取count个值,并不会删除值
srandmember			<k>		<count>
# 随机从集合 k(set) 中获取(吐)一个值, 会移除一个元素
spop 				<k>
# 删除集合k(set) 中的 一个|多个指定 v 返回删除成功的元素个数;
srem				<k>		<v1>	<v2><v3>...

-----------------------------功能命令：--------------------------------
# 判断该 k(set) 是否存在该 value 值：(存在1) (不存在0)
sismember			<k>		<v>
# 返回该集合元素个数 k(set), 不存在的k 回返回0, 类型不是set的k 会报错;
scard				<k>
# 把集合元素从一个集合 k1(set) 中一个值移动到另外一个 k2(set)集合;
smove				<k1>	<k2>	<v>				# 将k1中的v移动到 k2中去,k1中没有v 则0失败
# 返回两个|多个集合中的交集: 多个集合中都有的元素
sinter				<k1>	<k2>	<k3>...
# 返回两个|多个集合中的并集: 多个集合中所有的元素,但相同的值只出现一次
sunion				<k1>	<k2>	<k3>...
# 返回两个|多个集合中的差集: 多个集合互相没有重复的元素
sdiff				<k1>	<k2>	<k3>...

# 创建一个 k(HashMap<s,o>) 并设置一个|多个 field-value
hset			<k>		<f1>		<v1>	<f2><v2>...		# 返回新增行数,已经存在的 f 会覆盖之前的数据,不会返回新增行数
# 批量设置 k(HashMap<s,o>) 的值
hmset			<k>		<f1>		<v1>	<f2><v2>...		# 返回执行ok|失败	
# 根据 k 和 fieid 获取到集合 并根据k 获取到对应的value
hget			<k>		<f>									# 并不会移除元素,如果k 或 f不对返回 nil
# 根据 k 的 fieid 批量获取 k 集合中对应数据
hmget			<k>		<f1>		<f2>	<f3><f4>...		# 如果f 在k 中没有对应的值,则只是该 fieid列返回nil

# 查看一个 k(HashMap<s,o>) 的所有 fieid
hkeys			<k>
# 查看一个 k(HashMap<s,o>) 的所有 value
hvals			<k>
# 对指定的 k(HashMap<s,o>) 某一个fieid 数值类型进行 + - 增量;
hincrby  		<k>		<f>			<number>				# f number 必须是一个数值类型：number是正数就+ 负数就-
# 设置 k(HashMap<s,o>) 中的 fieid 必须事先不存在,才能创建成功: 以前都是直接覆盖,现在就可以避免值被随便覆盖;
hsetnx			<k>		<f>			<v>

# 添加一个|多个元素.... 并设置评分 score 简称 s
zadd 			<k>		<s>		<v>		<s2>	<v2>...
# 返回有序集合中指定评分范围的数据, witchscores 简写 ws
zrange			<k>		<start>	<stop>	[ws]					# start stop 都是数值类型,起始|结束评分 [ws] 可选返回数据value同事返回对应的score
# 查看所有的数据,从小到大排序,[limit offset count] 分页展示
zrangebyscore 	<k>		<min><max>	[ws][limit offset count]	# min max 都是数值类型,评分的范围~
# 查看所有的数据,从大到小排序
zrevrangebyscore<k>		<max><min>	[ws][limit offset count]

# 为某个元素的 v 添加评分 score
zincrby			<k>		<number>	<v>							# number 是添加的评分数
# 根据value 删除集合的元素
zrem			<k>		<v>
# 统计该集合，分数区间内的元素个数
zcount			<k>		<min><max>								# min~max 区间的评分数据合
# 返回该值在集合中的排名,从0开始 从小到大排序;
zrank			<k>		<v>

k					v
key名				"01100001011000100"  		#本质上就是一个字符串,但Redis可以对每个"位" 进行操作; 
# 可能这样还是很懵,可以把它当作一个int数组,只允许存储 0|1 而且长度无限...
# 这就是BitMaps的数据结构,而这个 0|1 通过某些场景定义可以解决很多业务场景... 签到打卡

# 设置一个key zhangsan20220201 张三2022年2月1日打卡报表;
# v 每一位默认都是0张三第一天打卡就会 setbit 设置数组下标0值1 表示打卡成功！每天如此: 打卡设置对应天数-1 数组下标赋值;
# 假设一个月后这个key: 0110001011000... 
# 只需要统计这个 key 中有多少次 1 就知道张三这个月打了多少次卡! 节省内存空间,而且Redis对于BitMaps 还有和很多这种方法;

# 用户id: 1 3 5 7 2022年2月1日登录系统设置 1
127.0.0.1:6379> setbit unique:users:20220201 1 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20220201 3 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20220201 5 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20220201 7 1
(integer) 0
# 查看2022年2月1日 id1 id2 用户有没有登录系统 
127.0.0.1:6379> getbit unique:users:20220201 1			# id1登录系统
(integer) 1
127.0.0.1:6379> getbit unique:users:20220201 2			# id2没有登录系统
(integer) 0

# 统计当天一共有多少个用户登录系统 2022年2月1日
127.0.0.1:6379> bitcount unique:users:20220201
(integer) 4												# 一共有四个用户访问系统

# 计算出两天都访问过网站的用户数量,使用 and交集：A B 集合中共同的元素;
# 用户id: 1 2 3 4 2022年2月2日登录系统设置 1
127.0.0.1:6379> setbit unique:users:20220202 1 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20220202 2 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20220202 3 1 
(integer) 0
127.0.0.1:6379> setbit unique:users:20220202 4 1 
# 查看这两天的集合的交集,得知这两天都登录的用户放到 20220201_02 集合中;
127.0.0.1:6379> bitop and  20220201_02 unique:users:20220201 unique:users:20220202
(integer) 1
127.0.0.1:6379> bitcount 20220201_02					# bitcount 查看集合中元素和,得知这两天一共有两个人登录系统;
(integer) 2
# 而且还可以查看具体是拿些用户进行了系统登录;
127.0.0.1:6379> getbit 20220201_02 0
(integer) 0
127.0.0.1:6379> getbit 20220201_02 1
(integer) 1
127.0.0.1:6379> getbit 20220201_02 2
(integer) 0
127.0.0.1:6379> getbit 20220201_02 3
(integer) 1												# 得用户id 1 3 这两天都登录了系统;

<!-- 引入环境依赖 -->
<dependencies>
    <!-- redis的操作依赖: 类似于数据库的JDBC -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.2.0</version>
    </dependency>

    <!-- Junit 测试依赖 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

public class JedisTest {
    /** 测试连接 */
    public static void main(String[] args) {
        // 创建一共Jedis Redis的连接对象...
        Jedis jedis = new Jedis("47.243.109.199",6379);		// 这里的ip 是个人的服务器,本人学习完毕可能会关闭建议切换自己的ip...
        // 设置密码的Redis 第一个命令是需要登录,不然什么操作都做不了...
        jedis.auth("540707!@#wsm");
        // 测试连接
        String pong = jedis.ping();
        System.out.println("测试连接"+pong+"返回PONG连接成功~");
        // 处理完毕之后关闭连接.
        jedis.close();
    }
}

/** Redis常用方法使用: */
@Test
public void test1(){
    // 创建一共Jedis Redis的连接对象...
    Jedis jedis = new Jedis("47.243.109.199",6379);
    jedis.auth("540707!@#wsm");

    /**常用命令使用**/
    jedis.flushAll();       //清空所有数据库;
    jedis.set("k1", "v1");
    jedis.set("k2", "v2");
    jedis.set("k3", "v3");
    // 查看所有的 keys
    Set<String> keys = jedis.keys("*");
    System.out.println(keys.size());
    for (String key : keys) {
        System.out.println(key);
    }
    // 判断数据库中是否存在k1
    System.out.println(jedis.exists("k1"));
    // 判断数据库中k1的过期时间: -1永久存在
    System.out.println(jedis.ttl("k1"));
    // 获取k1的值
    System.out.println(jedis.get("k1"));

    //切换数据库...
    //jedis.select(1);
    // 处理完毕之后关闭连接.
    jedis.close();
}

/** 五大基本数据类型，基本使用: */
@Test
public void test2(){
    // 创建一共Jedis Redis的连接对象...
    Jedis jedis = new Jedis("47.243.109.199",6379);
    jedis.auth("540707!@#wsm");
    jedis.flushAll();
    /** String类型 **/
    // mset 批量新增k-v 数据
    jedis.mset("k1","v1","k2","v2","k3","v3");
    // mget 批量获取结果集
    List<String> mget = jedis.mget("k1", "k2", "k3");
    System.out.println("String类型:"+mget);

    /** List类型 **/
    // 创建 k(list) 并从右添加三个数据
    jedis.rpush("Klist", "list1","list2","list3");
    List<String> klist = jedis.lrange("Klist", 0, -1);
    System.out.println("List类型:"+klist);

    /** set类型 **/
    jedis.sadd("kset", "set1");
    jedis.sadd("kset", "set2");
    jedis.sadd("kset", "set3");
    Set<String> kset = jedis.smembers("kset");
    System.out.println("set类型:"+kset);

    /** zset类型 **/
    jedis.zadd("kzset", 1, "1");
    jedis.zadd("kzset", 3, "3");
    jedis.zadd("kzset", 2, "2");
    Set<String> zrange = jedis.zrange("kzset", 0, -1);  // 会默认从小往大排序
    System.out.println("zset类型:"+zrange);

    /** hash类型 **/
    System.out.println("Hash类型:");
    jedis.hset("khash", "name","zhangsan");
    jedis.hset("khash", "age","18");
    System.out.println("张三的age"+jedis.hget("khash", "age"));
    // Jedis 支持参数传递 Map
    HashMap<String,String> lisimap = new HashMap<>();
    lisimap.put("name","lisi");
    lisimap.put("age","18");
    lisimap.put("weight","120");
    jedis.hmset("Klisi", lisimap);
    // 输出李四个人信息
    System.out.println("李四的个人信息: "+jedis.hmget("Klisi", "name","age","weight"));

    // 处理完毕之后关闭连接.
    jedis.close();
}

<!-- redis依赖配置 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

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

@RestController
@RequestMapping("/redisTest")
public class Redistest {
    // SpringBoot 提供的redisTemplate 配置类;
    @Autowired
    private RedisTemplate redisTemplate;

    // 发送请求REST 风格要 {param} 要发送redis 消息
    @GetMapping("/demo1/{param}")
    public void demo1(@PathVariable("param")String param){
        // 向Redis 存一共k-v 字符类型
        String key = "wsm";
        redisTemplate.opsForValue().set(key,param);
        // 根据key 获取该值
        // redisTemplate是一个<Object,Object> 返回数据需要强转;
        String  strval = (String) redisTemplate.opsForValue().get(key);
        System.out.println("获取Redis消息:"+strval);
    }
}

# RedisTemplate 对五种数据结构分别定义了操作
RedisTemplate.opsForValue();			# 操作字符串 BitMaps的方法也在这里面...
RedisTemplate.opsForHash();				# 操作hash
RedisTemplate.opsForList();				# 操作list
RedisTemplate.opsForSet();				# 操作set
RedisTemplate.opsForZSet();				# 操作有序set
RedisTemplate.opsForGeo();				# 操作Geo
RedisTemplate.opsForHyperLogLog();		# 操作HyperLogLog

# 除了数据类型的操作，我们对于Redis 常用的基本操作方法也可以通过获取连接对象来操作:
# 获取到连接对象之后，就可以像Jedis 一样直接操作Redis... 大量的命令方法也可以直接调用; 
RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
connection.flushDb();					# 清空数据库

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }
   	/** 内部定义了两个 RedisTemplate StringRedisTemplate用于操作Redis **/
    
    @Bean
    // 当Spring容器中没有 redisTemplate 就将该配置注入到Spring中.也就是说：只要自定义 RedisTemplate 注入这个方法就会失效;
    @ConditionalOnMissingBean(name = {"redisTemplate"})				
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)		
    // 参数RedisConnectionFactory连接工厂SpringBoot2 使用了Lettuce
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);			// 默认采用 JDk的序列化方式,所以会产生 乱码;
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return new StringRedisTemplate(redisConnectionFactory);			// 默认采用 StringRedisSerializer 类序列化
    }
}

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
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.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import java.net.UnknownHostException;
@Configuration
public class RedisConfig {
    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")		// 为了方便使用 泛型定义为 <S,O>
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)throws UnknownHostException {
		// JSON序列化类配置对象
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String序列化配置对象
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // RedisTemplate配置
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        // 将RedisTemplate 的传输方式都更改为 JSON传输方式
        // key 采用String序列化
        template.setKeySerializer(stringRedisSerializer);
        // 值采用JSON序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // Hashkey 采用String序列化
        template.setHashKeySerializer(stringRedisSerializer);
        // 值采用JSON序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);       // 因为,很多时候公司都是使用对象转JSON 来进行存储... 很少直接发送对象,所以使用JSON序列化配置
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    @ConditionalOnMissingBean(StringRedisTemplate.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}