# 商品的基本信息
	名称、价格、商家信息
	关系型数据库就可以解决了 MySQL/Oracle 
 	淘宝早年去 IOE：王坚：推荐文章- 阿里云的这群疯子 https://www.huxiu.com/article/267100.html
 	淘宝内部使用的MySQL是AliSQL
# 商品的描述、评论（文字比较多）
	文档型数据库：MongoDB
# 图片
	分布式文件系统：FastDFS
	- 淘宝自己的 TFS
	- Google的 GFS
	- Hadoop HDFS
	- 阿里云的 OSS
# 商品的关键字（搜索）
	- 搜索引擎 solr ElasticSearch
	- ISearch 多隆
	所有nb的人都有一段苦逼的岁月，但是要向SB一样去坚持
# 商品热门的波段信息
	- 内存数据库
	- Redis Tair Memache
# 商品的交易、外部的接口
	- 第三方应用

127.0.0.1:6379> select 3 # 切换数据库
OK
127.0.0.1:6379[3]> DBSIZE # 查看大小
(integer) 0
127.0.0.1:6379[3]>

127.0.0.1:6379[3]> FLUSHDB # 清除当前数据库
OK
127.0.0.1:6379[3]> FLUSHALL # 清除所有的数据库
OK

 # 移除命令 move 字段名 1  （1指的是当前数据库）
 
 127.0.0.1:6379> move name 1
 
 # 设置过期时间 EXPIRE 字段名 时间 （时间单位是秒）
 
127.0.0.1:6379> EXPIRE age 10

# 查看所有的信息
keys *

# 查看当前的key是否存在
EXISTS name 

# set k v 
# get v

# ttl name 查看时间

# 查看 key 类型 
type key

# 后面遇到不会的命令就在官网查看

127.0.0.1:6379> FLUSHALL # 清除所有的值
OK
127.0.0.1:6379> clear
127.0.0.1:6379> set key1 v1 # 设置
OK
127.0.0.1:6379> get key1 # 获取
"v1"
127.0.0.1:6379> EXISTS key1 # 判断是否存储
(integer) 1
127.0.0.1:6379> type key1 # 判断类型
string
127.0.0.1:6379> APPEND key1 "hello" # 追加字符串，如果当前的 key 不存在，相当于创建一个值
(integer) 7
127.0.0.1:6379> get key1 # 获取 key
"v1hello"
127.0.0.1:6379> STRLEN key1 # 获取长度
(integer) 7
################################################################################
127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> get views
"0"
127.0.0.1:6379> incr views # 自增1 打印在页面上
(integer) 1
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> incr views
(integer) 3
127.0.0.1:6379> incr views
(integer) 4
127.0.0.1:6379> incr views
(integer) 5
127.0.0.1:6379> incr views 
(integer) 6
127.0.0.1:6379> decr views#  自减1 打印在页面上
(integer) 5

127.0.0.1:6379> INCRBY views 10 # 自增的步长 10
(integer) 15
127.0.0.1:6379> DECRBY views 10 # 自减的步长 10
(integer) 5
127.0.0.1:6379>
################################################################################
# 字符串的范围  range
127.0.0.1:6379> set k "hello,demo"
OK
127.0.0.1:6379> get k
"hello,demo"
127.0.0.1:6379> GETRANGE k 0 3 # 获取0到3下标，包含0和3 [0,3]
"hell"
127.0.0.1:6379> GETRANGE k 0 -1 #  获取全部的数据
"hello,demo"

127.0.0.1:6379> set k2 "asdasdasfre"
OK
127.0.0.1:6379> get k2
"asdasdasfre"
127.0.0.1:6379> SETRANGE k2 1 xx  # 替换指定位置的字符串
(integer) 11
127.0.0.1:6379> get k2
"axxasdasfre"
127.0.0.1:6379>
################################################################################
# setex (set with expire) # 设置过期时间

# setnx (set if not exist) # 不存在在设置 (在分布式锁中会使用)

127.0.0.1:6379> setex k3 30 "leoooo" #  设置k3的值，在30秒之后过期
OK
127.0.0.1:6379> ttl k3
(integer) 27
127.0.0.1:6379> setnx k4 "redis" # 如果不存在会创建，如果存在设置失败
(integer) 1
127.0.0.1:6379> keys *
1) "k4"
2) "k2"
3) "k"
127.0.0.1:6379> setnx k4 "hashmap"
(integer) 0
127.0.0.1:6379> get k4
"redis"
127.0.0.1:6379>
################################################################################

# mset 创建多个 k-v
# gset 获取多个 k 的值
# msetnx 如果有就设置失败 是一个原子性的操作

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 k4 v4
OK
127.0.0.1:6379> mget k1 k2 k3 k4
1) "v1"
2) "v2"
3) "v3"
4) "v4"
127.0.0.1:6379> msetnx k1 v11 k2 v22
(integer) 0
127.0.0.1:6379> keys *
1) "k3"
2) "k1"
3) "k4"
4) "k2"
127.0.0.1:6379> mget k1 k2 k3 k4
1) "v1"
2) "v2"
3) "v3"
4) "v4"
127.0.0.1:6379>

# 设置对象
set user:1{name:zhangsan,age:3} # 设置一个user:1对象，值为json来保存一个对象

127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
OK
127.0.0.1:6379> mget user:1:name
1) "zhangsan"
127.0.0.1:6379> mget user:1:age
1) "2"
127.0.0.1:6379>
################################################################################
getset #  先获取在赋值  如果不存在则返回 nil 如果存在值就设置值

127.0.0.1:6379> set k1 k2
OK
127.0.0.1:6379> get k1
"k2"
127.0.0.1:6379> getset k1 9999
"k2"
127.0.0.1:6379> get k1
"9999"

################################################################################
127.0.0.1:6379> keys * 
(empty list or set)
127.0.0.1:6379> lpush list one # 将一个值或者多个值插入到列表的头部 (左)
(integer) 1
127.0.0.1:6379> lpush list two
(integer) 2
127.0.0.1:6379> lpush list three
(integer) 3 
127.0.0.1:6379> lrange list 0 -1  # 获取 list 中的值，通过区间获得具体的值
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> lrange list 0 1
1) "three"
2) "two"
127.0.0.1:6379>
################################################################################
127.0.0.1:6379> rpush list hello # 将一个值或者多个值插入到列表的尾部 (右)
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "hello"

127.0.0.1:6379> lrange list 0 0 # 获取某个单独的值
1) "three"
127.0.0.1:6379>

################################################################################
# Lpop 左边移除
# Rpop 右边移除

127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "hello"
127.0.0.1:6379> lpop list # 移除 list 的第一个元素
"three"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
3) "hello"
127.0.0.1:6379> rpop list # 移除 list 的最后一个元素
"hello"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
127.0.0.1:6379>
################################################################################
# Lindex 获取某一个值 通过下标获取一个值
127.0.0.1:6379> lindex list 2
(nil)
127.0.0.1:6379> lindex list 1
"one"
127.0.0.1:6379>
# Llen 获取 list 长度

127.0.0.1:6379> llen list
(integer) 2
127.0.0.1:6379>
################################################################################
# 移除指定的值
# 取关 就是取出指定的值 uid

127.0.0.1:6379> lrange list 0 -1
1) "six"
2) "two"
3) "one"
4) "two"
5) "one"
127.0.0.1:6379> lrem list 1 one   # 移除list集合中指定个数的 value 精确匹配
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "six"
2) "two"
3) "two"
4) "one"
127.0.0.1:6379> lrem list 2 three
(integer) 0
127.0.0.1:6379> lrange list 0 -1
1) "six"
2) "two"
3) "two"
4) "one"
127.0.0.1:6379> lrem list 2 two
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "six"
2) "one"
127.0.0.1:6379>
################################################################################
trim 修剪 ：list 截断元素

127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello1"
2) "hello2"
3) "hello"
4) "hell2"
5) "hell3"
127.0.0.1:6379> ltrim mylist 1 2 # 通过下标截取指定的长度，这个list已经被改变了，截断了只剩下截取的元素
OK
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello2"
2) "hello"
127.0.0.1:6379>
################################################################################
rpoplpush # 移除列表最后一个，并移除到新的列表中

127.0.0.1:6379> rpush myli hello
(integer) 1
127.0.0.1:6379> rpush myli hell1
(integer) 2
127.0.0.1:6379> rpush myli hell2
(integer) 3
127.0.0.1:6379> rpush myli hell3
(integer) 4
127.0.0.1:6379> rpush myli hell4
(integer) 5
127.0.0.1:6379> rpoplpush myli myotherlist
"hell4"
127.0.0.1:6379> lrange myli 0 -1 # 查看原来的列表
1) "hello"
2) "hell1"
3) "hell2"
4) "hell3"
127.0.0.1:6379> lrange myotherlist 0 -1 # 移除之后的列表
1) "hell4"
127.0.0.1:6379>
#################################################################################
lset # 相当于是一个更新操作 

127.0.0.1:6379> EXISTS list # 判断列表是不是存在
(integer) 0
127.0.0.1:6379> lset list 0 item # 如果不存在更新就会报错
(error) ERR no such key
127.0.0.1:6379> lpush list value1
(integer) 1
127.0.0.1:6379> lset list 0 item  # 如果存在，替换list下标为目标的值
OK
127.0.0.1:6379> LRANGE list 0 -1
1) "item"
127.0.0.1:6379>
#################################################################################
linsert  # 将某个元素插入到某个具体的位置前后

127.0.0.1:6379> rpush list 12
(integer) 1
127.0.0.1:6379> linsert list before 12 qwe
(integer) 2
127.0.0.1:6379> LRANGE list 0 -1
1) "qwe"
2) "12"
127.0.0.1:6379> linsert list after 12 qwe
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1
1) "qwe"
2) "12"
3) "qwe"
127.0.0.1:6379>

#################################################################################
127.0.0.1:6379> sadd myset "hello" # 集合中添加元素
(integer) 1 
127.0.0.1:6379> sadd myset "hello"
(integer) 0
127.0.0.1:6379> sadd myset "hello1"
(integer) 1
127.0.0.1:6379> sadd myset "hello2"
(integer) 1
127.0.0.1:6379> sadd myset "hello3"
(integer) 1
127.0.0.1:6379> sadd myset "hello4"
(integer) 1
127.0.0.1:6379>

127.0.0.1:6379> smembers myset # 查看所有的集合元素
1) "hello2"
2) "hello1"
3) "hello"
4) "hello3"
5) "hello4"
127.0.0.1:6379> sismember myset hello4 # 查看集合中是不是有此元素
(integer) 1
127.0.0.1:6379> sismember myset hello34
(integer) 0
127.0.0.1:6379>
#################################################################################
scard myset # 获取set集合中的元素和个数

127.0.0.1:6379> scard myset
(integer) 5
127.0.0.1:6379>
#################################################################################
srem # 移除set的元素

127.0.0.1:6379> srem myset hello
(integer) 1
127.0.0.1:6379> smembers myset
1) "hello1"
2) "hello3"
3) "hello4"
4) "hello2"
127.0.0.1:6379>

#################################################################################
set 无序不重复 #  RANDMEMBER myset 随机抽出一个元素
127.0.0.1:6379> SRANDMEMBER myset
"hello3"
127.0.0.1:6379> SRANDMEMBER myset
"hello1"
127.0.0.1:6379> SRANDMEMBER myset
"hello4"
127.0.0.1:6379> SRANDMEMBER myset
"hello1"
127.0.0.1:6379>
#################################################################################
随机移除一个元素

127.0.0.1:6379> smembers myset
1) "hello1"
2) "hello3"
3) "hello4"
4) "hello2"
127.0.0.1:6379> spop myset # 随机移除一个元素
"hello4"
127.0.0.1:6379> smembers myset
1) "hello1"
2) "hello3"
3) "hello2"
127.0.0.1:6379>
#################################################################################
将一个指定的值移到另外一个set集合中
初始化两个集合
smove # 移动

127.0.0.1:6379> smembers myset2
1) "c"
2) "d"
3) "a"
4) "b"
5) "e"
6) "f"
127.0.0.1:6379> smembers myset1
1) "12"
2) "13"
3) "14"
4) "15"
5) "16"
6) "17"
7) "18"
127.0.0.1:6379>


127.0.0.1:6379> smove myset1  myset2 13 # 移动元素 ，将一个指定的set集合的值移动到另一个集合
(integer) 1
127.0.0.1:6379> smembers myset1
1) "12"
2) "14"
3) "15"
4) "16"
5) "17"
6) "18"
127.0.0.1:6379> smembers myset2
1) "d"
2) "a"
3) "b"
4) "13"
5) "c"
6) "e"
7) "f"
127.0.0.1:6379>
#################################################################################
微博，B站，共同关注（并集）
数字集合类：
- 差集
- 并集 
- 交集

127.0.0.1:6379> sadd key1 a
(integer) 1
127.0.0.1:6379> sadd key1 b
(integer) 1
127.0.0.1:6379> sadd key1 c
(integer) 1
127.0.0.1:6379> sadd key1 d
(integer) 1
127.0.0.1:6379> sadd key2 c
(integer) 1
127.0.0.1:6379> sadd key2 d
(integer) 1
127.0.0.1:6379> sadd key2 e
(integer) 1
127.0.0.1:6379> sadd key2 f
(integer) 1
127.0.0.1:6379> sdiff key1 key2 # 差集
1) "b"
2) "a"
127.0.0.1:6379> sinter key1 key2 # 交集 共同好友
1) "c"
2) "d"
127.0.0.1:6379> sunion key1 key2 # 并集
1) "b"
2) "c"
3) "a"
4) "e"
5) "f"
6) "d"
127.0.0.1:6379>

127.0.0.1:6379> hset myhash f1 ic # 设置一个具体的值
(integer) 1
127.0.0.1:6379> hget myhash f1 # 打印一个具体的值
"ic"
127.0.0.1:6379> hmset myhash i1 v1 i2 v2 i3 v3 # 设置多个字段的值
OK
127.0.0.1:6379> hmget myhash i1 i2 i3 # 获取多个值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> hgetall myhash # 获取所有的值
1) "f1"
2) "ic"
3) "i1"
4) "v1"
5) "i2"
6) "v2"
7) "i3"
8) "v3"
127.0.0.1:6379> hdel myhash f1 # 删除一个
(integer) 1
127.0.0.1:6379>
#################################################################################
hlen # 获取hash表的长度

127.0.0.1:6379> hlen myhash
(integer) 3
127.0.0.1:6379>
#################################################################################
127.0.0.1:6379> hexists myhash i1 # 判断是否有某个元素
(integer) 1
127.0.0.1:6379> hexists myhash i7 # 判断是否有某个元素
(integer) 0
127.0.0.1:6379>
#################################################################################
只获得所有的字段 和 左右的值

127.0.0.1:6379> hkeys myhash # 获取所有的 key
1) "i1"
2) "i2"
3) "i3"
127.0.0.1:6379> hvals myhash # 获取所有的值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379>
#################################################################################
incr # 自增
decr # 自减

127.0.0.1:6379> hset myhash file 4 # 指定增量
(integer) 1
127.0.0.1:6379> hincrby myhash file 1 # 自增1
(integer) 5
127.0.0.1:6379> hincrby myhash file -2 # 自增 -2
(integer) 3
127.0.0.1:6379> hsetnx myhash file3 he #  如果没有就创建
(integer) 1
127.0.0.1:6379> hsetnx myhash file3 he # 如果有就创建失败
(integer) 0
127.0.0.1:6379>

#################################################################################
127.0.0.1:6379> zadd myset 1 one
(integer) 1
127.0.0.1:6379> zadd myset 2 two 3 three
(integer) 2
127.0.0.1:6379> zrange myset 0 -1
1) "one"
2) "two"
3) "three"
127.0.0.1:6379>

#################################################################################
127.0.0.1:6379> zadd salary 2000 xiaohong
(integer) 1
127.0.0.1:6379> zadd salary 2400 zhangsan
(integer) 1
127.0.0.1:6379> zadd salary 2100 ic
(integer) 1
#################################################################################
127.0.0.1:6379> zrangebyscore salary -inf +inf
1) "xiaohong"
2) "ic"
3) "zhangsan"
#################################################################################
127.0.0.1:6379> zrangebyscore salary -inf +inf withscores
1) "xiaohong"
2) "2000"
3) "ic"
4) "2100"
5) "zhangsan"
6) "2400"
#################################################################################

127.0.0.1:6379> zadd salary 2000 xiaohong # 添加三个用户
(integer) 1
127.0.0.1:6379> zadd salary 2400 zhangsan
(integer) 1
127.0.0.1:6379> zadd salary 2100 ic
(integer) 1
127.0.0.1:6379>
127.0.0.1:6379> zrangebyscore salary -inf +inf # 从小到大排列 
1) "xiaohong"
2) "ic"
3) "zhangsan"
127.0.0.1:6379> zrangebyscore salary -inf +inf withscores # 从小到大排列，并且附带成绩
1) "xiaohong"
2) "2000"
3) "ic"
4) "2100"
5) "zhangsan"
6) "2400"

127.0.0.1:6379> ZREVRANGE salary 0 -1 # 从大到小排序
1) "zhangsan"
2) "xiaohong"
127.0.0.1:6379>

#################################################################################
移除 rem 中的元素
zrem 

127.0.0.1:6379> zrange salary 0 -1
1) "xiaohong"
2) "ic"
3) "zhangsan"
127.0.0.1:6379> zrange salary 0 -1
1) "xiaohong"
2) "zhangsan"
127.0.0.1:6379>
#################################################################################
获取有序集合中的个数

127.0.0.1:6379> zcard salary # 获取有序集合中的个数
(integer) 2
127.0.0.1:6379>
#################################################################################

127.0.0.1:6379> zadd myset 1 2
(integer) 1
127.0.0.1:6379> zadd myset 1 4
(integer) 1
127.0.0.1:6379> zadd myset 3 world 4 hello
(integer) 2
127.0.0.1:6379> zcount myset 1 3 # 获取指定区间的的成员的数量
(integer) 3
127.0.0.1:6379>

# 使用bitmap来记录周一到周日的打开
127.0.0.1:6379> setbit sign 0 0
(integer) 0
127.0.0.1:6379> setbit sign 1 1
(integer) 0
127.0.0.1:6379> setbit sign 2 1
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 4 0
(integer) 0
127.0.0.1:6379> setbit sign 5 0
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0
127.0.0.1:6379>

127.0.0.1:6379> getbit sign 4
(integer) 0
127.0.0.1:6379> getbit sign 3
(integer) 1
127.0.0.1:6379> getbit sign 6
(integer) 0
127.0.0.1:6379> getbit sign 5
(integer) 0
127.0.0.1:6379> getbit sign 1
(integer) 1
127.0.0.1:6379>

127.0.0.1:6379> BITCOUNT sign # 统计打卡的天数
(integer) 3
127.0.0.1:6379>

----- 队列 set set set 执行 ------

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 k2
QUEUED
127.0.0.1:6379> discard
OK
127.0.0.1:6379> exec'
Invalid argument(s)
127.0.0.1:6379> exec
(error) ERR EXEC without MULTI
127.0.0.1:6379>

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> watch money # 监视 money对象
OK
127.0.0.1:6379> multi # 事务正常结束，数据期间没有发生变动，这个时候就正常执行成功
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> incrby out 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 80
2) (integer) 20
127.0.0.1:6379>

<!-- 导入Jedis的包 -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>
<!-- 导入 阿里的 fastjson 包 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.70</version>
</dependency>

public class TestRedis {
    public static void main(String[] args) {
        // 1. new 一个 Jedis 对象
        Jedis jedis = new Jedis("127.0.0.1",6379);
        // 2. redis 所有的命令都在 jedis 就是之前学习的命令
        System.out.println(jedis.ping());
    }
}
// 输出：PONG

public class TestTx {
    public static void main(String[] args) {
        // 1. new 一个 Jedis 对象
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushAll();
        Transaction multi = jedis.multi();
        String res = new JSONObject().toJSONString();
        jedis.watch(res);
        try {
            multi.set("user1", "passw1");
            int i = 1 / 0;
            multi.set("user2", "passw2");
            multi.set("user3", "passw3");

            // 执行事务
            multi.exec();
        } catch (Exception e) {
            // 放弃事务
            multi.discard();
            e.printStackTrace();
        } finally {
            // 关闭连接
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            System.out.println(jedis.get("user3"));
            jedis.close();
        }
    }
}

<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>
</dependency>

// 如果不存在这个bean才生效，说明我们可以自定义一个
@EnableConfigurationProperties(RedisProperties.class) 
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
    @Bean
    // 默认的RedisTemple没有很多的设置，redis对象都是需要序列化
    // 两个泛型都是Object类型，使用之后需要强转
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
        throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    // 由于String是redis最常用的数据结构，所以就直接加入
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
        throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
}

# 配置 Redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.database=1

@SpringBootTest
class RedisBootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        // redisTemp 点出来，封装的 api 和原生操作是一样的
        // opsForValue 操作字符串 类似String
        // opsForSet 操作集合 类似set
        // opsForList 操作列表 类似 list
        // opsForHash 操作哈希 类似Hash
        System.out.println(redisTemplate);
        redisTemplate.opsForValue().set("ic",12);
        Object ic = redisTemplate.opsForValue().get("ic");
        System.out.println(ic);
        redisTemplate.opsForSet();
        redisTemplate.opsForList();
        redisTemplate.opsForHash();
        // 除了基本的操作 我们常用的方法都可以直接通过 redisTemplate 操作，
        // 比如事务和基本的CURD操作

        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushDb();
        connection.flushAll();
        redisTemplate.multi();
        redisTemplate.exec();
    }
}

// RedisTemplate 序列化配置
@Nullable
private RedisSerializer keySerializer = null;
@Nullable
private RedisSerializer valueSerializer = null;
@Nullable
private RedisSerializer hashKeySerializer = null;
@Nullable
private RedisSerializer hashValueSerializer = null;

public void afterPropertiesSet() {
    super.afterPropertiesSet();
    boolean defaultUsed = false;
    if (this.defaultSerializer == null) {
        this.defaultSerializer = new JdkSerializationRedisSerializer(this.classLoader != null ? this.classLoader : this.getClass().getClassLoader());
    }
}
// 默认的序列化方法是通过 JDK 的方式序列化的
// 我们可能会使用JSON的方式来序列化

// Redis 配置类
@Configuration
public class RedisConfig {
    // 编写我们自己的配置 redisTemplate
    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
        throws UnknownHostException {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

@Test
void test2() throws Exception{
    // 真实的开发一般都使用json来传递对象
    User user = new User("ic", "哈哈哈");
    // String res = new ObjectMapper().writeValueAsString(user);
    redisTemplate.opsForValue().set("user",user);
    System.out.println(redisTemplate.opsForValue().get("user"));
}
// 如果这个时候 User 没有实现 Serializable 接口，这个时候就会报错，如下
// Caused by: org.springframework.core.serializer.support.SerializationFailedException: Failed to serialize object using 

// 所以此处使用JSON传递数据就没问题
// 在企业中，我们的所有的 pojo 都会序列化

public interface RedisSerializer<T> {
	// Redis支持的序列化接口
}

@Configuration
public class RedisConfig {

    /**
     * 编写我们自己的配置 redisTemplate
     * 这是写好的一个固定模板，拿到企业中就直接使用
     *
     * @param factory
     * @return
     * @throws UnknownHostException
     */
    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
        throws UnknownHostException {
        // 为了开发方便，一般直接使用 <String,Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 配置具体序列化规则
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        // 设置
        serializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key 采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash 的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value 序列化方式采用jackson
        template.setValueSerializer(serializer);
        // hash 的value序列化方法采用jackson
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}

package cn.icanci.redis.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @Author: icanci
 * @ProjectName: ic-redis
 * @PackageName: cn.icanci.redis.utils
 * @Date: Created in 2020/7/16 10:12
 * @ClassAction: 在我们真实的分发中，或者你们在公司，一般都可以看到一个公司自己封装RedisUtil
 */
@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }


    // ============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */

    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */

    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }


    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }


    // ================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }


    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }


    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 获取set缓存的长度
     *
     * @param key 键
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */

    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 获取list缓存的长度
     *
     * @param key 键
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */

    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */

    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

@SpringBootTest
class RedisBootApplicationTests {

    @Autowired
    @Qualifier("redisTemplate")
    private RedisTemplate redisTemplate;

    @Autowired
    private RedisUtil redisUtil;
    @Test
    void contextLoads() {

        // 在企业开发的过程中，我们80%的情况下，都不会使用原生的方式去编写代码
        // 一般我们都去自己封装方法 RedisUtils


        // redisTemp 点出来，封装的 api 和原生操作是一样的
        // opsForValue 操作字符串 类似String
        // opsForSet 操作集合 类似set
        // opsForList 操作列表 类似 list
        // opsForHash 操作哈希 类似Hash
        System.out.println(redisTemplate);
        redisTemplate.opsForValue().set("ic",12);
        Object ic = redisTemplate.opsForValue().get("ic");
        System.out.println(ic);
        redisTemplate.opsForSet();
        redisTemplate.opsForList();
        redisTemplate.opsForHash();
        // 除了基本的操作 我们常用的方法都可以直接通过 redisTemplate 操作，
        // 比如事务和基本的CURD操作

        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushDb();
        connection.flushAll();
        redisTemplate.multi();
        redisTemplate.exec();
    }

    @Test
    void test2() throws Exception{
        // 真实的开发一般都使用json来传递对象
        User user = new User("ic", "哈哈哈");
//        String res = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("user",user);
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

    @Test
    void test3() throws Exception{
        redisUtil.set("ic","iiii");
        System.out.println(redisUtil.get("ic"));
    }
}

bind 127.0.0.1 # 绑定的 ip 地址

protected-mode yes # 保护模式

port 6379 # 默认端口

daemonize yes # 后台守护进程 以守护进程运行，默认是 no

pidfile /var/run/redis_6379.pid # 配置文件的 pid 文件 如果以后台方式运行 ，就要指定一个 pid 文件

# 日志

# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably) 生产环境
# warning (only very important / critical messages are logged)
loglevel notice

# 日志的输出文件
# Specify the log file name. Also the empty string can be used to force
# Redis to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null
logfile "" 

# 默认有16个数据库 数据库的数量
databases 16

# 是否显示 开启的 logo 
always-show-logo yes

持久化操作 在规定的时间内，执行了多少次操作，就会持久化到文件 .rdb文件和.aof文件

持久化规则 Redis 是内存数据库，如果没有持久化，则断电就失去数据
# 如何900秒之内，如果至少有 1 个key进行了修改，就会执行持久化操作
save 900 1
# 如果在300秒之内，如果如果至少有 10 个key进行了修改，就会执行持久化操作
save 300 10
# 如果在60秒之内，如果如果至少有 10000 个key进行了修改，就会执行持久化操作
save 60 10000
# 之后会自定义进行测试

stop-writes-on-bgsave-error yes  # 持久化如果出错，是否还需要继续工作

rdbcompression yes # 是否压缩 rdb 文件，需要消耗一些 cpu 资源

rdbchecksum yes # 保存 rdb 文件的时候，进行错误的校验检查

dir ./ # rdb 文件的保存目录

maxclients 10000 # 最大的客户端连接数

maxmemory <bytes> # Redis 设置的最大内存 单位是 bytes

maxmemory-policy noeviction # 内存到达上限的操作

volatile-lru:从已设置过期时间的内存数据集中挑选最近最少使用的数据 淘汰；
volatile-ttl: 从已设置过期时间的内存数据集中挑选即将过期的数据 淘汰；
volatile-random:从已设置过期时间的内存数据集中任意挑选数据 淘汰；
allkeys-lru:从内存数据集中挑选最近最少使用的数据 淘汰；
allkeys-random:从数据集中任意挑选数据 淘汰；
noeviction(驱逐)：禁止驱逐数据。（默认淘汰策略。当redis内存数据达到maxmemory，在该策略下，直接返回OOM错误）

appendonly no # 默认是不开启 aof 模式的，默认双击哦是使用rdb方式持久化的，在大部分情况下，rdb完全够用
appendfilename "appendonly.aof" # 持久化文件的名字

# appendfsync always # 每次修改都 sync 消耗性能
appendfsync everysec # 每秒执行一次 可能会丢失一秒的数据
# appendfsync no #  不执行同步 这个时候操作系统速度最快

127.0.0.1:6379> config get dir
1) "dir"
2) "/usr/local/bin" # 如果在这个目录下存在 dump.rdb 文件，那么在启动的时候就会恢复此文件的数据
127.0.0.1:6379>

# 订阅者
127.0.0.1:6379> SUBSCRIBE ic # 订阅一个频道 ic
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "ic"
3) (integer) 1 # 等待读取信息
1) "message" # 消息
2) "ic" # 哪个频道
3) "hello" # 消息的具体内容
1) "message"
2) "ic"
3) "hello2"
1) "message"
2) "ic"
3) "hello3"

# 发送者
[root@ali-icanci bin]# redis-cli -p 6379 # 发送消息到频道
127.0.0.1:6379> PUBLISH ic hello
(integer) 1
127.0.0.1:6379> PUBLISH ic hello2
(integer) 1
127.0.0.1:6379> PUBLISH ic hello3
(integer) 1
127.0.0.1:6379>

127.0.0.1:6379> info replication  # 获取 当前库的信息
# Replication
role:master # 角色
connected_slaves:0 # 没有从机
master_replid:07094272497183fdc2392884bb2111fe70654996
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
127.0.0.1:6379>

SLAVEOF host port # 设置主机和端口

下图是主机信息：

# 主机的信息

127.0.0.1:6379> info replication
# Replication
role:master # 当前角色
connected_slaves:2 # 从机个数
slave0:ip=127.0.0.1,port=6380,state=online,offset=126,lag=0 # 从机1的信息
slave1:ip=127.0.0.1,port=6381,state=online,offset=126,lag=0 # 从机2的信息
master_replid:2aff04d8d964c198fcceb423f6168658353cea13
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:126
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:126
127.0.0.1:6379>

#从机的信息

127.0.0.1:6380> info replication
# Replication 
role:slave # 机器信息
master_host:127.0.0.1 # 主机地址
master_port:6379 # 主机 端口
master_link_status:up
master_last_io_seconds_ago:0
master_sync_in_progress:0
slave_repl_offset:14
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:2aff04d8d964c198fcceb423f6168658353cea13
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:14
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:14
127.0.0.1:6380>

SLAVEOF no one