1、NoSQL

1.1 什么是NoSQL

NoSQL（Not Only SQL）：泛指非关系型数据库，区别与关系型数据库，且保持了关系型数据库的ACID原则；NoSQL数据库的产生就是为了解决大规模数据集合、多重数据种类带来的挑战，特别是大数据应用难题。

1.2 NoSQL特点

  • 方便扩展（数据之间没有关系、很好扩展）

  • 大数据量高性能（Redis一秒写8万、读11万）

  • 数据类型是多样型的（不需要事先设计数据库）

  • 传统的RDBMS和NoSQL ``` 传统的 RDBMS(关系型数据库)

  • 结构化组织
  • SQL
  • 数据和关系都存在单独的表中 row col
  • 操作，数据定义语言
  • 严格的一致性
  • 基础的事务

Nosql

  • 不仅仅是数据
  • 没有固定的查询语言
  • 键值对存储，列存储，文档存储，图形数据库（社交关系）
  • 最终一致性
  • CAP定理和BASE
  • 高性能，高可用，高扩展 ```

1.3 3V、3高

大数据时代的3V ：主要是描述问题的

  • 海量Velume
  • 多样Variety
  • 实时Velocity

大数据时代的3高 ： 主要是对程序的要求

  • 高并发
  • 高可扩
  • 高性能

1.4 NoSQl的分类

KV键值对：

  • 新浪：Redis
  • 美团：Redis+Tair
  • 阿里、百度：Redis+memeache

文档型数据库（bson、json）

  • MongoDB

    • MongoDB是一个基于分布式文件存储的数据库，C++编写，主要用于存储大量的文档
    • MongoDB是一个介于关系型数据库和非关系型数据库之间的产品
  • CouchDb

列存储型数据库：

  • HBase
  • 分列式文件系统

图关系型数据库：

  • Neo4j、infoGrid

  • 不是存图片，放的是图关系 如社交关系

总结：

2、Redis安装与测试

2.1 Windows下安装

Redis官网：https://redis.io

github下载链接：https://github.com/tporadowski/redis/releases

菜鸟安装教程：https://www.runoob.com/redis/redis-install.html

下载zip压缩包并解压到指定目录

解压完成后，分别打开服务端和客户端。

在客户端输入ping命令，可以检测连接是否成功，成功会显示PONG

Redis按KV键值对存储数据，使用set get

2.2 Linux安装（重要）

1.去官网下载Linux的安装包

2.将压缩包移动到opt文件夹下并解压

  1. yum install gcc-c++  #安装gcc编译
  2. make  #解压之后进入redis目录使用make指令进行编译
  3. make install #make后进入src目录进行安装

3.在/usr/local目录下创建一个redis目录，并创建一个myconf子目录

  1. mkdir -p/usr/local/redis

4.将redis的默认配置文件复制到/usr/local/redis/myconf/目录下：redis.conf，以后就使用此目录下的redis.conf配置文件，这样就可以随时还原

  1. mv /opt/redis-5.0.13/redis.conf /usr/local/redis/myconf/
  2. cd /opt/redis-5.0.13/src
  3. mv mkreleasdhdr.sh redis-benchmark redis-check-aof redis-check-dump redis-cli redis-server /usr/local/redis/

4.Redis后台默认不启动，需要进入redis.conf配置文件修改daemonize为yes，默认后台启动

5.在/usr/local/redis/bin目录路径下启动redis服务端：./redis-server myconf/redis.conf

6.在/usr/local/redis/bin目录路径下使用redis-cli -p 6379 命令启动Redis客户端 使用ping检测是够连通

7.在/bin/src目录下进行性能测试：./redis-benchmark -h 127.0.0.1 -p 6379 -c 100 -n 100000

注：测试时必须退出shell指令，如下图

7.退出：shutdowm->exit

3、Redis基础知识

redis有16个数据库，默认使用的是第0号数据库（0-15）

  1. DBSIZE：查看当前数据库中的数据个数
  3. select index：选择使用第几个数据库
  5. keys *：查看所有的Key
  7. flushdb：清空当前数据库
  9. flushall：清空所有数据库

Redis是单线程的，基于内存操作，CPU不是Redis的性能瓶颈，Redis的瓶颈是基于机器的内存和网络的带宽

4、五大数据类型

4.1 Redis-Key

  1. 127.0.0.1:6379> set name qing  #set添加键值对【name：qing】 默认为String类型
  2. OK
  3. 127.0.0.1:6379> set age 1
  4. OK
  5. 127.0.0.1:6379> keys *      #查看当前数据库的所有键值对
  6. 1) "age"
  7. 2) "name"
  8. 127.0.0.1:6379> EXISTS name  #exists判断指定键是否存在 存在显示1，不存在显示0
  9. (integer) 1
  10. 127.0.0.1:6379> EXISTS name1
  11. (integer) 0
  12. 127.0.0.1:6379> move name 1  #move移除指定键 1表示确定执行
  13. (integer) 1
  14. 127.0.0.1:6379> keys *
  15. 1) "age"
  16. 127.0.0.1:6379> get age      #get 获取指定键的值
  17. "1"
  18. 127.0.0.1:6379> EXPIRE age 5 #EXPIRE设置指定键的存活时间 后面跟秒
  19. (integer) 1
  20. 127.0.0.1:6379> ttl age      #ttl 查看指定键的存活时间
  21. (integer) 1
  22. 127.0.0.1:6379> ttl age
  23. (integer) -2
  24. 127.0.0.1:6379> keys *
  25. (empty array)
  26. 127.0.0.1:6379> type age     #type 查看指定键的数据类型
  27. string
  28. 127.0.0.1:6379> type name
  29. string

4.2 String

  1. 127.0.0.1:6379> append name fan  #append 指定键值追加字符串
  2. (integer) 7
  3. 127.0.0.1:6379> get name
  4. "qingfan"
  5. 127.0.0.1:6379> keys *
  6. 1) "age"
  7. 2) "name"
  8. 127.0.0.1:6379> APPEND name2 shuai  #append时，若指定键不存在，则相当于set新建键值对
  9. (integer) 5
  10. 127.0.0.1:6379> keys * 
  11. 1) "name2"
  12. 2) "age"
  13. 3) "name"
  15. 127.0.0.1:6379> strlen name  #strlen 获取指定键值的长度
  16. (integer) 7
  18. 127.0.0.1:6379> get age
  19. "1"
  20. 127.0.0.1:6379> incr age     #incr：使指定键值+1
  21. (integer) 2
  22. 127.0.0.1:6379> get age
  23. "2"
  24. 127.0.0.1:6379> decr age     #decr：使指定键值-1
  25. (integer) 1
  26. 127.0.0.1:6379> get age
  27. "1"
  28. 127.0.0.1:6379> incrby age 10  #incrby：使指定键值增加指定值
  29. (integer) 11
  30. 127.0.0.1:6379> get age
  31. "11"
  33. 127.0.0.1:6379> getrange name 0 1  #getrange 截取指定字符串 start end：0-1 前2个字符  0-0 第一个字符  0~-1 整个字符串
  34. "qi"
  35. 127.0.0.1:6379> getrange name 0 0
  36. "q"
  37. 127.0.0.1:6379> getrange name 0 -1
  38. "qingfan"
  40. 127.0.0.1:6379> setrange name 1 xx    #setrange 替换指定字符串的值 1：从第一个字符开始 xx：将第一个字符后的两个字符替换成xx
  41. (integer) 7
  42. 127.0.0.1:6379> get name
  43. "qxxgfan"
  45. 127.0.0.1:6379> setex key1 30 "qing"    #setex：设置键的过期时间（秒），如果键不存在，则设置成功，若键已存在则设置失败
  46. OK
  48. 127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3  # mset 设置多个键值对
  49. OK
  50. 127.0.0.1:6379> mget k1 k2 k3    # mget 获取多个键值对
  51. 1) "v1"
  52. 2) "v2"
  53. 3) "v3"
  54. 127.0.0.1:6379> msetnx k1 v1 k4 v4   #msetnx：设置多个键值对，是一个原子性操作，因为k1已经存在，所有导致k4也设置失败
  55. (integer) 0    
  56. 127.0.0.1:6379> mset user:1:name qing user:1:age 5 user:2:name fan user:2:age 6 #mset设置对象 user的2个对象user：1和user：2
  57. OK
  58. 127.0.0.1:6379> mget user:1:name user:1:age user:2:name  #mget对象
  59. 1) "qing"
  60. 2) "5"
  61. 3) "fan"
  63. 127.0.0.1:6379> getset k4 v4  #getset：若果键不存在则返回nil并创建键值
  64. (nil)
  65. 127.0.0.1:6379> get k4
  66. "v4"
  67. 127.0.0.1:6379> getset k4 v44 #如果键存在，则返回旧值，并设置指定的新值
  68. "v4"

4.3 List

Redis中可以用List来实现栈、队列、阻塞队列

  1. #Lpush、Rpush、Lrange
  2. 127.0.0.1:6379> LPUSH list1 one  #Lpush：将元素插入到list的头部（左）
  3. (integer) 1
  4. 127.0.0.1:6379> LPUSH list1 two
  5. (integer) 2
  6. 127.0.0.1:6379> LPUSH list 7 8 9 #添加多个值
  7. (integer) 5
  8. 127.0.0.1:6379> LRANGE list1 0 -1 #LRANGE:显示list中的值，0~1 从左到右的两个元素，0~-1 所有元素
  9. 1) "two"
  10. 2) "one"
  11. 127.0.0.1:6379> Rpush list2 one two #Rpush：将一个或多个元素插入到list的尾部（右）
  12. (integer) 2
  13. 127.0.0.1:6379> LRANGE list2 0 -1
  14. 1) "one"
  15. 2) "two"
  17. #Lpop Rpop
  18. 127.0.0.1:6379> LRANGE list1 0 -1
  19. 1) "5"
  20. 2) "two"
  21. 3) "one"
  22. 127.0.0.1:6379> Lpop list1  #Lpop：将list头部第一个元素移除
  23. "5"
  24. 127.0.0.1:6379> Rpop list1  #Rpop：将list尾部的第一个元素移除
  25. "one"
  27. #Lindex
  28. 127.0.0.1:6379> LRANGE list2 0 -1
  29. 1) "one"
  30. 2) "two"
  31. 127.0.0.1:6379> Lindex list2 0  #Lindex 通过下标获取list的值，从头部开始，起始下标为0
  32. "one"
  34. #Llen 
  35. 127.0.0.1:6379> Llen list2 #Llen：返回指定list的长度
  36. (integer) 2
  38. #Lrem
  39. 127.0.0.1:6379> Lrem list2 1 one #Lrem：移除list中的指定值，1代表移除1个one
  40. (integer) 1
  42. #Ltrim
  43. 127.0.0.1:6379> Lpush list 1 2 3 4
  44. (integer) 4
  45. 127.0.0.1:6379> Ltrim list 0 1  #Ltrim：根据指定下标和上标截断list，0~1代表第一个和第二个元素
  46. OK
  47. 127.0.0.1:6379> LRANGE list 0 -1
  48. 1) "4"
  49. 2) "3"
  51. #RpopLpush
  52. 127.0.0.1:6379> LRANGE list 0 -1
  53. 1) "4"
  54. 2) "3"
  55. 127.0.0.1:6379> RpopLpush list list2  #RpopLpush：将前一个list的尾部元素移到另一个list的头部
  56. "3"
  58. #Lset
  59. 127.0.0.1:6379> LRANGE list 0 -1
  60. 1) "4"
  61. 127.0.0.1:6379> Lset list 0 5  #Lset：替换list指定下标的元素 0：将第一个元素替换为5
  62. OK
  63. 127.0.0.1:6379> LRANGE list 0 -1
  64. 1) "5"
  66. #Linsert
  67. 127.0.0.1:6379> LRANGE list 0 -1
  68. 1) "5"
  69. 2) "6"
  70. 3) "7"
  71. 4) "8"
  72. 127.0.0.1:6379> Linsert list before 6 50  #在指定值的前面或后面插入值  在元素6的前面插入50
  73. (integer) 5
  74. 127.0.0.1:6379> Linsert list after 8 90
  75. (integer) 6
  76. 127.0.0.1:6379> LRANGE list 0 -1
  77. 1) "5"
  78. 2) "50"
  79. 3) "6"
  80. 4) "7"
  81. 5) "8"
  82. 6) "90"

4.4 Set

  1. 127.0.0.1:6379> sadd myset "qing"  #sadd：向set集合中添加指定值
  2. (integer) 1
  3. 127.0.0.1:6379> sadd myset "fan"
  4. (integer) 1
  5. 127.0.0.1:6379> sadd myset "chen"
  6. (integer) 1
  7. 127.0.0.1:6379> smembers myset   #smembers：查看指定set的所有值
  8. 1) "qing"
  9. 2) "chen"
  10. 3) "fan"
  11. 127.0.0.1:6379> sismember myset qing     #sismember：判断指定值是否存在，返回1表示存在，0 不存在
  12. (integer) 1
  13. 127.0.0.1:6379> sismember myset qing2
  14. (integer) 0
  15. 127.0.0.1:6379> scard myset        #scard：查看set中的数据个数
  16. (integer) 3
  17. 127.0.0.1:6379> srem myset qing    #srem：删除set中的指定值
  18. (integer) 1
  19. 127.0.0.1:6379> smembers myset
  20. 1) "chen"
  21. 2) "fan"
  23. 127.0.0.1:6379> SRANDMEMBER myset   #SRANDMEMBER：从set中随机抽取一个值
  24. "fan"
  25. 127.0.0.1:6379> SRANDMEMBER myset
  26. "chen"
  27. 127.0.0.1:6379> spop myset    #spop：随机移除一个元素
  28. "1"
  30. 127.0.0.1:6379> sadd myset 1 2 3 4
  31. (integer) 4
  32. 127.0.0.1:6379> smove myset myset2 3  #smove：将一个set中的值移动到另外一个set中
  33. (integer) 1
  34. 127.0.0.1:6379> SMEMBERS myset2
  35. 1) "3"
  37. 127.0.0.1:6379> sdiff myset myset2   #sdiff：查看两个集合的差集，set1中不包含set2的值
  38. 1) "2"
  39. 2) "4"
  40. 127.0.0.1:6379> sinter myset myset2  #sinter：交集
  41. 1) "1"
  42. 2) "5"
  43. 127.0.0.1:6379> sunion myset myset2  #sunion：并集
  44. 1) "1"
  45. 2) "2"
  46. 3) "3"
  47. 4) "4"
  48. 5) "5"
  49. 6) "6"

4.5 Hash

Map集合，键值对存储，key-value

  1. 127.0.0.1:6379> Hset myhash name qing  #Hset：向集合中添加键值对
  2. (integer) 1
  3. 127.0.0.1:6379> Hget myhash name      #Hget：根据键获取指定值
  4. "qing"
  5. 127.0.0.1:6379> Hset myhash name qing name2 qing2  #Hset：同时添加多个键值对
  6. (integer) 1
  7. 127.0.0.1:6379> Hget myhash name2
  8. "qing2"
  9. 127.0.0.1:6379> hmset myhash age1 50 age2 80  #Hmset：同时添加多个键值对
  10. OK
  11. 127.0.0.1:6379> hmget myhash age1 age2 name name2  #Hmget：同时获取多个键的值
  12. 1) "50"
  13. 2) "80"
  14. 3) "qing"
  15. 4) "qing2"
  17. 127.0.0.1:6379> Hgetall myhash   #获取集合中所有键值对，下标单数为键 偶数为值
  18. 1) "name"
  19. 2) "qing"
  20. 3) "name2"
  21. 4) "qing2"
  22. 5) "age1"
  23. 6) "50"
  24. 7) "age2"
  25. 8) "80"
  27. 127.0.0.1:6379> Hdel myhash name2  #Hdel：删除集合中指定键值对
  28. (integer) 1
  29. 127.0.0.1:6379> Hlen myhash   #Hlen：获取集合的长度-键值对的个数
  30. (integer) 3
  31. 127.0.0.1:6379> Hexists myhash name #Hexists：判断指定的键是否存在 存在返回1，不存在返回0
  32. (integer) 1
  33. 127.0.0.1:6379> Hexists myhash name2
  34. (integer) 0
  35. 127.0.0.1:6379> Hkeys myhash     #Hkeys：获取集合中的所有键
  36. 1) "name"
  37. 2) "age1"
  38. 3) "age2"
  39. 127.0.0.1:6379> Hvals myhash    #Hvals：获取集合中的所有值
  40. 1) "qing"
  41. 2) "50"
  42. 3) "80"
  44. 127.0.0.1:6379> hget myhash age1   
  45. "50"
  46. 127.0.0.1:6379> Hincrby myhash age1 1  #Hincrby：给指定键的值增加指定值，若键不存在则会直接创建
  47. (integer) 51
  48. 127.0.0.1:6379> Hincrby myhash age1 10
  49. (integer) 61
  50. 127.0.0.1:6379> Hsetnx myhash age3 10  #Hsetnx：增加指定键值对，如果不存在则添加成功
  51. (integer) 1
  52. 127.0.0.1:6379> Hsetnx myhash age3 9   #若键已存在则添加失败
  53. (integer) 0

4.6 Zset（有序集合）

在set的基础上增加了一个字段，可以理解为排序数，可以根据此字段的大小进行排序

  1. 127.0.0.1:6379> Zadd myset 2 two 1 one   #Zadd：增加一个值
  2. (integer) 2
  3. 127.0.0.1:6379> ZRANGE myset 0 -1    #Zrange：会根据具体值前面的数进行升序排序
  4. 1) "one"
  5. 2) "two"
  6. 127.0.0.1:6379> Zrevrange salary 0 -1  #Zrevrange：按降序排列
  7. 1) "chen"
  8. 2) "qing"
  9. 127.0.0.1:6379> Zadd salary 1000 qing
  10. (integer) 1
  11. 127.0.0.1:6379> Zadd salary 10000 fan
  12. (integer) 1
  13. 127.0.0.1:6379> Zadd salary 8000 chen
  14. (integer) 1
  15. 127.0.0.1:6379> Zrange salary 0 -1
  16. 1) "qing"
  17. 2) "chen"
  18. 3) "fan"
  20. 127.0.0.1:6379> ZRANGEBYSCORE salary -0 +10000    #ZrangeByScore：可以指定排序的范围 -1~10000  负无穷~正无穷：-inf~+inf
  21. 1) "qing"
  22. 2) "chen"
  23. 3) "fan"
  24. 127.0.0.1:6379> ZRANGEBYSCORE salary -0 +10000 withscores #ZrangeByScore-withscores 打印排序的值和排序数大小
  25. 1) "qing"
  26. 2) "1000"
  27. 3) "chen"
  28. 4) "8000"
  29. 5) "fan"
  30. 6) "10000"
  31. 127.0.0.1:6379> Zrem salary fan  #Zrem：移除集合中的指定元素
  32. (integer) 1
  33. 127.0.0.1:6379> ZRANGE salary 0 -1
  34. 1) "qing"
  35. 2) "chen"
  37. 127.0.0.1:6379> Zcard salary  #Zcard：查询集合中的元素个数
  38. (integer) 2
  39. 127.0.0.1:6379> Zcount myset 1 2  #Zcount：获取指定区间的元素个数
  40. (integer) 3

5、三种特殊类型

5.1 geospatial

地理位置，可以推算地理位置的信息，计算两地之间的距离

  1. #geoadd：添加key，一般使用java一键导入 城市经纬度 有效经度范围：-180~180 纬度范围：-85~85
  2. 127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing  
  3. (integer) 1
  4. 127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
  5. (integer) 1
  6. 127.0.0.1:6379> geoadd china:city 106.50 29.53 shanghai
  7. (integer) 0
  8. 127.0.0.1:6379> geoadd china:city 106.50 29.53 shenzhen 120.16 30.24 hangzhou
  9. (integer) 2
  11. #geopos：获取指定城市的经纬度
  12. 127.0.0.1:6379> geopos china:city beijing  
  13. 1) 1) "116.39999896287918091"
  14.    2) "39.90000009167092543"
  16. #geodist：查看两个城市的直线距离  可切换单位：千米km、英里mi、英尺ft
  17. 127.0.0.1:6379> geodist china:city beijing shanghai km  
  18. "1464.0708"
  20. #georadius：返回以指定经纬度为中心 指定半径内的城市  #withdist：显示直线距离 withcoord：显示经纬度参数 count:显示多少个城市
  21. 127.0.0.1:6379> georadius china:city 110 30 1000 km  
  22. 1) "shanghai"
  23. 2) "shenzhen"
  24. 3) "hangzhou"
  25. 127.0.0.1:6379> georadius china:city 110 30 1000 km withdist withcoord count 1
  26. 1) 1) "shanghai"
  27.    2) "341.9374"
  28.    3) 1) "106.49999767541885376"
  29.       2) "29.52999957900659211"
  31. #georadiusbymember:返回指定城市周围的城市
  32. 127.0.0.1:6379> georadiusbymember china:city shanghai 1000 km
  33. 1) "shanghai"
  34. 2) "shenzhen
  36. #其余命令与set类似：Zrange、Zrem
  37. 127.0.0.1:6379> Zrange china:city 0 -1
  38. 1) "shanghai"
  39. 2) "shenzhen"
  40. 3) "hangzhou"
  41. 4) "beijing"

5.2 Hyperloglog

基数：不重复的元素，如：

A{1，2,，3，5，8} B{1，3，5,8} A、B集合的基数就是2

Reis Hyperloglog数据结构用于统计基数，允许有容错

  1. 127.0.0.1:6379> Pfadd key1 a b c d e f g    #Pfadd：创建一组元素
  2. (integer) 1
  3. 127.0.0.1:6379> PFcount key1                #Pfcount：统计一组元素中的基数数量
  4. (integer) 7
  5. 127.0.0.1:6379> pFadd key2 b c d e h i      
  6. (integer) 1
  7. 127.0.0.1:6379> PFmerge key3 key1 key2      #Pfmerge：合并两组数到一个新数组，求出对应的基数
  8. OK
  9. 127.0.0.1:6379> Pfcount key3
  10. (integer) 9

5.3 Bitmaps（位图）

统计用户的信息，活跃、不活跃，打卡信息等

  1. #例：统计用户一周的打卡信息  
  2. 127.0.0.1:6379> setbit sign 0 1  #星期一 打卡
  3. (integer) 0
  4. 127.0.0.1:6379> setbit sign 1 0  #星期二 未打卡
  5. (integer) 0
  6. 127.0.0.1:6379> setbit sign 2 0 
  7. (integer) 0
  8. 127.0.0.1:6379> setbit sign 3 0 
  9. (integer) 0
  10. 127.0.0.1:6379> setbit sign 4 1 
  11. (integer) 0
  12. 127.0.0.1:6379> setbit sign 5 1 
  13. (integer) 0
  14. 127.0.0.1:6379> setbit sign 6 0 
  15. (integer) 0
  16. 127.0.0.1:6379> getbit sign 5   #getbit 获取某天的打卡记录
  17. (integer) 1
  18. 127.0.0.1:6379> getbit sign 6
  19. (integer) 0
  20. 127.0.0.1:6379> bitcount sign   #bitcount：统计打卡天数
  21. (integer) 3

6、事务

Redis单条命令保证原子性，但事务不保证原子性，Redis事务没有隔离级别的概念

Redis事务有一次性、顺序性、排他性

流程：

  • 开启事务（multi）：事务开启后，会形成一个队列
  • 命令入队：所有命令会按照先后顺序进入队列，等待统一执行命令
  • 执行事务（exec）：
  1. 127.0.0.1:6379> multi     #multi：开启事务
  2. OK
  3. 127.0.0.1:6379> set k1 v1 #命令入队
  4. QUEUED
  5. 127.0.0.1:6379> set k2 v2
  6. QUEUED
  7. 127.0.0.1:6379> get k2
  8. QUEUED
  9. 127.0.0.1:6379> set k3 v3
  10. QUEUED
  11. 127.0.0.1:6379> exec   #exec：执行事务
  12. 1) OK
  13. 2) OK
  14. 3) "v2"
  15. 4) OK
  16. 127.0.0.1:6379> discard -  #discard：取消事务

编译型异常：如get命令 后面不加指定键，命令出错导致报错，事务队列中的所有命令都不会执行！

  1. 127.0.0.1:6379> get
  2. (error) ERR wrong number of arguments for 'get' command

运行时异常：如1/0，事务队列中存在语法性错误，则执行事务时，该条命令不会执行，其他正确的命令仍然会执行！

Redis实现事务监控：

乐观锁、悲观锁

Redis中使用 watch 来实现乐观锁，可以监控一个对象，在执行一个事务时，如果在当前事务没有提交（exec）之前有另外一个线程插入，修改了监控对象的数据，那么本事务一定会执行失败。 如果发现事务执行失败，就先使用unwatch解锁，再次使用watch加锁，重新监视

  1. 127.0.0.1:6379> watch money   #watch：加锁
  2. OK
  3. 127.0.0.1:6379> unwatch       #unwatch解锁
  4. OK

7、Jedis

Jedis是Redis官网推荐的java连接工具

7.1 导入依赖

  1. <dependency>
  2.     <groupId>redis.clients</groupId>
  3.     <artifactId>jedis</artifactId>
  4.     <version>3.6.1</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>com.alibaba</groupId>
  8.     <artifactId>fastjson</artifactId>
  9.     <version>1.2.76</version>
  10. </dependency>

7.2 idea连接redis

1> 修改redis.conf配置文件，将“bind 127.0.0.1”注释掉并添加“bind 0.0.0.0”，并将“protect-mode yes”修改为：protect-mode no

2> 将reids端口加入防火墙： firewall-cmd —zone=public —add-port=6379/tcp —permanent

重启防火墙：systemctl restart firewalld ！（也可以直接关闭防火墙，一劳永逸）

如果使用的云服务器，则需要在云服务器上打开6379端口

3> “./redis-server myconf/redis.conf ” 启动云服务器的Redis服务端

4> idea测试连接

  1. public class TestRedis {
  2.     public static void main(String[] args) {
  3.         //创建Jedis对象
  4.         //host:我的阿里云ip地址，如使用的是本地redis，则用127.0.0.1即可
  5.         Jedis jedis = new Jedis("47.108.59.58",6379);
  6.         System.out.println(jedis.ping());
  7.         System.out.println(jedis.get("money"));
  8.         System.out.println(jedis.keys("*"));
  9.     }
  10. }

8、SpringBoot集成Redis

在SpringBoot2.x之后，将Redis替换为了lettuce

jedis：采用的直连，多个线程操作的话，是不安全的。如果要避免不安全，使用jedis pool连接池！更像BIO模式

lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全的情况！可以减少线程数据了，更像NIO模式

8.1 集成测试

启动reids服务端

1> 导包

  1. <!--Redis导入依赖-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-data-redis</artifactId>
  5. </dependency>

2> 配置连接

  1. spring.redis.host=47.128.59.58
  2. #spring.redis.host=127.0.0.1  本地redis
  3. spring.redis.port=6379

3> 测试

  1. @SpringBootTest
  2. class Redis02SpringbootApplicationTests {
  4.     //导入redisTemplate模板
  5.     @Autowired
  6.     private RedisTemplate redisTemplate;
  8.     @Test
  9.     void contextLoads() {
  10.         //获取redis的连接对象，可对redis数据库进行操作
  11.         RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
  12.         connection.flushDb();
  13.         connection.flushAll();
  15.         //opsForValue:封装了所有操作字符串的方法
  16.         //opsForList:封装了所有操作list的方法
  17.         //...
  18.         ValueOperations valueOperations = redisTemplate.opsForValue();
  19.         valueOperations.set("name","qing");
  20.         System.out.println(valueOperations.get("name"));
  21.     }
  23. }

8.2 出现问题

当在idea中操作了Redis数据库后，再去Redis远程端查询时，出现乱码，如下图：

出现乱码原因：Redis源码中，自动进行了JDK序列化，我们需要使用Json来序列化，见8.3

8.3 自定义RedisTemplate

自定义redsiTemplate来实现对应的序列化，解决乱码

  1. @Configuration
  2. public class RedisConfig {
  4.     //编写自己的redsiTemplate 固定模板
  5.     @Bean
  6.     @SuppressWarnings("all")
  7.     public RedisTemplate<String, Object> myRedisTemplate(RedisConnectionFactory factory) {
  9.         RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
  10.         template.setConnectionFactory(factory);
  12.         // 序列化配置 解析任意对象
  13.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  14.         // json序列化利用ObjectMapper进行转义
  15.         ObjectMapper om = new ObjectMapper();
  16.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  17.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  18.         jackson2JsonRedisSerializer.setObjectMapper(om);
  19.         // 2.序列化String类型
  20.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  22.         // key采用String的序列化方式
  23.         template.setKeySerializer(stringRedisSerializer);
  24.         // hash的key也采用String的序列化方式
  25.         template.setHashKeySerializer(stringRedisSerializer);
  26.         // value序列化方式采用jackson
  27.         template.setValueSerializer(jackson2JsonRedisSerializer);
  28.         // hash的value序列化方式采用jackson
  29.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  30.         template.afterPropertiesSet();
  32.         return template;
  33.     }
  34. }
  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. //在企业开发中，所有的pojo实体类都需要序列化！
  5. public class User implements Serializable {
  7.     private String name;
  8.     private Integer age;
  9. }

8.4 自定义Redis工具类

  1. /*
  2.  *File Name: RedisUtil
  3.  *Created By: QingFan
  4.  *Created Time:2021/9/22 12:42
  5.  *Desc: null
  6.  */
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.data.redis.core.RedisTemplate;
  9. import org.springframework.stereotype.Component;
  10. import org.springframework.util.CollectionUtils;
  11. import java.util.List;
  12. import java.util.Map;
  13. import java.util.Set;
  14. import java.util.concurrent.TimeUnit;
  16. @Component
  17. public final class RedisUtil {
  19.     @Autowired
  20.     private RedisTemplate<String, Object> redisTemplate;
  22.     // =============================common============================
  24.     /**
  25.      * 指定缓存失效时间
  26.      *
  27.      * @param key  键
  28.      * @param time 时间(秒)
  29.      */
  30.     public boolean expire(String key, long time) {
  31.         try {
  32.             if (time > 0) {
  33.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  34.             }
  35.             return true;
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.             return false;
  39.         }
  40.     }
  42.     /**
  43.      * 根据key 获取过期时间
  44.      *
  45.      * @param key 键 不能为null
  46.      * @return 时间(秒) 返回0代表为永久有效
  47.      */
  48.     public long getExpire(String key) {
  49.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  50.     }
  53.     /**
  54.      * 判断key是否存在
  55.      *
  56.      * @param key 键
  57.      * @return true 存在 false不存在
  58.      */
  59.     public boolean hasKey(String key) {
  60.         try {
  61.             return redisTemplate.hasKey(key);
  62.         } catch (Exception e) {
  63.             e.printStackTrace();
  64.             return false;
  65.         }
  66.     }
  69.     /**
  70.      * 删除缓存
  71.      *
  72.      * @param key 可以传一个值 或多个
  73.      */
  74.     @SuppressWarnings("unchecked")
  75.     public void del(String... key) {
  76.         if (key != null && key.length > 0) {
  77.             if (key.length == 1) {
  78.                 redisTemplate.delete(key[0]);
  79.             } else {
  80.                 redisTemplate.delete(String.valueOf(CollectionUtils.arrayToList(key)));
  81.             }
  82.         }
  83.     }
  86.     // ============================String=============================
  88.     /**
  89.      * 普通缓存获取
  90.      *
  91.      * @param key 键
  92.      * @return 值
  93.      */
  94.     public Object get(String key) {
  95.         return key == null ? null : redisTemplate.opsForValue().get(key);
  96.     }
  98.     /**
  99.      * 普通缓存放入
  100.      *
  101.      * @param key   键
  102.      * @param value 值
  103.      * @return true成功 false失败
  104.      */
  106.     public boolean set(String key, Object value) {
  107.         try {
  108.             redisTemplate.opsForValue().set(key, value);
  109.             return true;
  110.         } catch (Exception e) {
  111.             e.printStackTrace();
  112.             return false;
  113.         }
  114.     }
  116.     /**
  117.      * 普通缓存放入并设置时间
  118.      *
  119.      * @param key   键
  120.      * @param value 值
  121.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  122.      * @return true成功 false 失败
  123.      */
  125.     public boolean set(String key, Object value, long time) {
  126.         try {
  127.             if (time > 0) {
  128.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  129.             } else {
  130.                 set(key, value);
  131.             }
  132.             return true;
  133.         } catch (Exception e) {
  134.             e.printStackTrace();
  135.             return false;
  136.         }
  137.     }
  139.     /**
  140.      * 递增
  141.      *
  142.      * @param key   键
  143.      * @param delta 要增加几(大于0)
  144.      */
  145.     public long incr(String key, long delta) {
  146.         if (delta < 0) {
  147.             throw new RuntimeException("递增因子必须大于0");
  148.         }
  149.         return redisTemplate.opsForValue().increment(key, delta);
  150.     }
  152.     /**
  153.      * 递减
  154.      *
  155.      * @param key   键
  156.      * @param delta 要减少几(小于0)
  157.      */
  158.     public long decr(String key, long delta) {
  159.         if (delta < 0) {
  160.             throw new RuntimeException("递减因子必须大于0");
  161.         }
  162.         return redisTemplate.opsForValue().increment(key, -delta);
  163.     }
  166.     // ================================Map=================================
  168.     /**
  169.      * HashGet
  170.      *
  171.      * @param key  键 不能为null
  172.      * @param item 项 不能为null
  173.      */
  174.     public Object hget(String key, String item) {
  175.         return redisTemplate.opsForHash().get(key, item);
  176.     }
  178.     /**
  179.      * 获取hashKey对应的所有键值
  180.      *
  181.      * @param key 键
  182.      * @return 对应的多个键值
  183.      */
  184.     public Map<Object, Object> hmget(String key) {
  185.         return redisTemplate.opsForHash().entries(key);
  186.     }
  188.     /**
  189.      * HashSet
  190.      *
  191.      * @param key 键
  192.      * @param map 对应多个键值
  193.      */
  194.     public boolean hmset(String key, Map<String, Object> map) {
  195.         try {
  196.             redisTemplate.opsForHash().putAll(key, map);
  197.             return true;
  198.         } catch (Exception e) {
  199.             e.printStackTrace();
  200.             return false;
  201.         }
  202.     }
  204.     /**
  205.      * HashSet 并设置时间
  206.      *
  207.      * @param key  键
  208.      * @param map  对应多个键值
  209.      * @param time 时间(秒)
  210.      * @return true成功 false失败
  211.      */
  212.     public boolean hmset(String key, Map<String, Object> map, long time) {
  213.         try {
  214.             redisTemplate.opsForHash().putAll(key, map);
  215.             if (time > 0) {
  216.                 expire(key, time);
  217.             }
  218.             return true;
  219.         } catch (Exception e) {
  220.             e.printStackTrace();
  221.             return false;
  222.         }
  223.     }
  226.     /**
  227.      * 向一张hash表中放入数据,如果不存在将创建
  228.      *
  229.      * @param key   键
  230.      * @param item  项
  231.      * @param value 值
  232.      * @return true 成功 false失败
  233.      */
  234.     public boolean hset(String key, String item, Object value) {
  235.         try {
  236.             redisTemplate.opsForHash().put(key, item, value);
  237.             return true;
  238.         } catch (Exception e) {
  239.             e.printStackTrace();
  240.             return false;
  241.         }
  242.     }
  244.     /**
  245.      * 向一张hash表中放入数据,如果不存在将创建
  246.      *
  247.      * @param key   键
  248.      * @param item  项
  249.      * @param value 值
  250.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  251.      * @return true 成功 false失败
  252.      */
  253.     public boolean hset(String key, String item, Object value, long time) {
  254.         try {
  255.             redisTemplate.opsForHash().put(key, item, value);
  256.             if (time > 0) {
  257.                 expire(key, time);
  258.             }
  259.             return true;
  260.         } catch (Exception e) {
  261.             e.printStackTrace();
  262.             return false;
  263.         }
  264.     }
  266.     /**
  267.      * 删除hash表中的值
  268.      *
  269.      * @param key  键 不能为null
  270.      * @param item 项 可以使多个 不能为null
  271.      */
  272.     public void hdel(String key, Object... item) {
  273.         redisTemplate.opsForHash().delete(key, item);
  274.     }
  276.     /**
  277.      * 判断hash表中是否有该项的值
  278.      *
  279.      * @param key  键 不能为null
  280.      * @param item 项 不能为null
  281.      * @return true 存在 false不存在
  282.      */
  283.     public boolean hHasKey(String key, String item) {
  284.         return redisTemplate.opsForHash().hasKey(key, item);
  285.     }
  287.     /**
  288.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  289.      *
  290.      * @param key  键
  291.      * @param item 项
  292.      * @param by   要增加几(大于0)
  293.      */
  294.     public double hincr(String key, String item, double by) {
  295.         return redisTemplate.opsForHash().increment(key, item, by);
  296.     }
  298.     /**
  299.      * hash递减
  300.      *
  301.      * @param key  键
  302.      * @param item 项
  303.      * @param by   要减少记(小于0)
  304.      */
  305.     public double hdecr(String key, String item, double by) {
  306.         return redisTemplate.opsForHash().increment(key, item, -by);
  307.     }
  310.     // ============================set=============================
  312.     /**
  313.      * 根据key获取Set中的所有值
  314.      *
  315.      * @param key 键
  316.      */
  317.     public Set<Object> sGet(String key) {
  318.         try {
  319.             return redisTemplate.opsForSet().members(key);
  320.         } catch (Exception e) {
  321.             e.printStackTrace();
  322.             return null;
  323.         }
  324.     }
  326.     /**
  327.      * 根据value从一个set中查询,是否存在
  328.      *
  329.      * @param key   键
  330.      * @param value 值
  331.      * @return true 存在 false不存在
  332.      */
  333.     public boolean sHasKey(String key, Object value) {
  334.         try {
  335.             return redisTemplate.opsForSet().isMember(key, value);
  336.         } catch (Exception e) {
  337.             e.printStackTrace();
  338.             return false;
  339.         }
  340.     }
  342.     /**
  343.      * 将数据放入set缓存
  344.      *
  345.      * @param key    键
  346.      * @param values 值 可以是多个
  347.      * @return 成功个数
  348.      */
  349.     public long sSet(String key, Object... values) {
  350.         try {
  351.             return redisTemplate.opsForSet().add(key, values);
  352.         } catch (Exception e) {
  353.             e.printStackTrace();
  354.             return 0;
  355.         }
  356.     }
  358.     /**
  359.      * 将set数据放入缓存
  360.      *
  361.      * @param key    键
  362.      * @param time   时间(秒)
  363.      * @param values 值 可以是多个
  364.      * @return 成功个数
  365.      */
  366.     public long sSetAndTime(String key, long time, Object... values) {
  367.         try {
  368.             Long count = redisTemplate.opsForSet().add(key, values);
  369.             if (time > 0)
  370.                 expire(key, time);
  371.             return count;
  372.         } catch (Exception e) {
  373.             e.printStackTrace();
  374.             return 0;
  375.         }
  376.     }
  378.     /**
  379.      * 获取set缓存的长度
  380.      *
  381.      * @param key 键
  382.      */
  383.     public long sGetSetSize(String key) {
  384.         try {
  385.             return redisTemplate.opsForSet().size(key);
  386.         } catch (Exception e) {
  387.             e.printStackTrace();
  388.             return 0;
  389.         }
  390.     }
  392.     /**
  393.      * 移除值为value的
  394.      *
  395.      * @param key    键
  396.      * @param values 值 可以是多个
  397.      * @return 移除的个数
  398.      */
  400.     public long setRemove(String key, Object... values) {
  401.         try {
  402.             Long count = redisTemplate.opsForSet().remove(key, values);
  403.             return count;
  404.         } catch (Exception e) {
  405.             e.printStackTrace();
  406.             return 0;
  407.         }
  408.     }
  410.     // ===============================list=================================
  412.     /**
  413.      * 获取list缓存的内容
  414.      *
  415.      * @param key   键
  416.      * @param start 开始
  417.      * @param end   结束 0 到 -1代表所有值
  418.      */
  419.     public List<Object> lGet(String key, long start, long end) {
  420.         try {
  421.             return redisTemplate.opsForList().range(key, start, end);
  422.         } catch (Exception e) {
  423.             e.printStackTrace();
  424.             return null;
  425.         }
  426.     }
  429.     /**
  430.      * 获取list缓存的长度
  431.      *
  432.      * @param key 键
  433.      */
  434.     public long lGetListSize(String key) {
  435.         try {
  436.             return redisTemplate.opsForList().size(key);
  437.         } catch (Exception e) {
  438.             e.printStackTrace();
  439.             return 0;
  440.         }
  441.     }
  444.     /**
  445.      * 通过索引 获取list中的值
  446.      *
  447.      * @param key   键
  448.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  449.      */
  450.     public Object lGetIndex(String key, long index) {
  451.         try {
  452.             return redisTemplate.opsForList().index(key, index);
  453.         } catch (Exception e) {
  454.             e.printStackTrace();
  455.             return null;
  456.         }
  457.     }
  460.     /**
  461.      * 将list放入缓存
  462.      *
  463.      * @param key   键
  464.      * @param value 值
  465.      */
  466.     public boolean lSet(String key, Object value) {
  467.         try {
  468.             redisTemplate.opsForList().rightPush(key, value);
  469.             return true;
  470.         } catch (Exception e) {
  471.             e.printStackTrace();
  472.             return false;
  473.         }
  474.     }
  477.     /**
  478.      * 将list放入缓存
  479.      *
  480.      * @param key   键
  481.      * @param value 值
  482.      * @param time  时间(秒)
  483.      */
  484.     public boolean lSet(String key, Object value, long time) {
  485.         try {
  486.             redisTemplate.opsForList().rightPush(key, value);
  487.             if (time > 0)
  488.                 expire(key, time);
  489.             return true;
  490.         } catch (Exception e) {
  491.             e.printStackTrace();
  492.             return false;
  493.         }
  495.     }
  498.     /**
  499.      * 将list放入缓存
  500.      *
  501.      * @param key   键
  502.      * @param value 值
  503.      * @return
  504.      */
  505.     public boolean lSet(String key, List<Object> value) {
  506.         try {
  507.             redisTemplate.opsForList().rightPushAll(key, value);
  508.             return true;
  509.         } catch (Exception e) {
  510.             e.printStackTrace();
  511.             return false;
  512.         }
  514.     }
  517.     /**
  518.      * 将list放入缓存
  519.      *
  520.      * @param key   键
  521.      * @param value 值
  522.      * @param time  时间(秒)
  523.      * @return
  524.      */
  525.     public boolean lSet(String key, List<Object> value, long time) {
  526.         try {
  527.             redisTemplate.opsForList().rightPushAll(key, value);
  528.             if (time > 0)
  529.                 expire(key, time);
  530.             return true;
  531.         } catch (Exception e) {
  532.             e.printStackTrace();
  533.             return false;
  534.         }
  535.     }
  538.     /**
  539.      * 根据索引修改list中的某条数据
  540.      *
  541.      * @param key   键
  542.      * @param index 索引
  543.      * @param value 值
  544.      * @return
  545.      */
  547.     public boolean lUpdateIndex(String key, long index, Object value) {
  548.         try {
  549.             redisTemplate.opsForList().set(key, index, value);
  550.             return true;
  551.         } catch (Exception e) {
  552.             e.printStackTrace();
  553.             return false;
  554.         }
  555.     }
  558.     /**
  559.      * 移除N个值为value
  560.      *
  561.      * @param key   键
  562.      * @param count 移除多少个
  563.      * @param value 值
  564.      * @return 移除的个数
  565.      */
  567.     public long lRemove(String key, long count, Object value) {
  568.         try {
  569.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  570.             return remove;
  571.         } catch (Exception e) {
  572.             e.printStackTrace();
  573.             return 0;
  574.         }
  576.     }
  578. }

9、Redis.conf

10、Redis持久化

10.1 RDB

  • redis 是内存数据库，数据断电及失，因此需要持久化，默认使用RDB，一般情况下我们无需修改RDB配置，即可使用
  • RDB的缺点就是最后一次持久化后的数据可能丢失
  • Redis会单独创建一个fork子进程来进行持久化，子进程中循环所有的数据，将数据写入到二进制文件中，会先将数据 写入到一个临时文件中，待持久化过程都结束了，在用这个临时文件替换上次持久化好了的文件
  • RDB保存的文件就是：dump.rdb

触发机制：

  • 在配置文件中的save，例如60秒内修改了5个key就会触发RDB，生成一个dump.rdb文件
  • 执行flushall 命令，也会触发我们的RDB规则
  • 退出redis，输入命令shutdown，就会关闭redis服务，这个时候也会生成RDB文件。

恢复数据：

  • 只需要将rdb文件放在我们redis启动目录就可以，redis启动的时候会自动检查demp.rdb恢复其中的数据
  • 查看rdb文件保存的位置，输入命令config get dir 如果在该目录下存在，就会自动恢复其中的数据

10.2 AOF

  • aof是将我们所有的命令都记录下来，然后在恢复的时候再重新执行一次，并且只记录写操作的命令，读命令不会记录

  • aof只追加文件，因此aof的速度会慢一些

  • aof保存的文件是： appendonly.aof

  • aof默认不开启aof，修改appendonly no为yes后 重启Redis开启aof持久化

  • 如果aof文件出错：redis提供了一个持久化文件修复工具，一个是redis-chech-rdb，另一个是redis-chech-aof ，因此如果出现这种情况，我们就可以使用这两个工具修复文件

    1. ./redis-check-aof --fix appendonly.aof