尚硅谷课程redis学习笔记

1.在linux下安装redis数据库

这篇文章介绍安装

redis介绍：

  • Redis是一个开源的key-value存储系统。
  • 和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。
  • 这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。
  • 在此基础上，Redis支持各种不同方式的排序。
  • 与memcached一样，为了保证效率，数据都是缓存在内存中。
  • 区别的是Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件。

并且在此基础上实现了master-slave(主从)同步。

2.Redis键(key)

在redisz中一共有0-15个数据库，进入到redis之后默认是在第0号数据库

切换数据库，后面是数据的索引下标

select 1

设置key-value

set key value

keys *查看当前库所有key    (匹配：keys *1)

keys *
keys k*

查看你的key是什么类型

type k1

删除指定的key数据

del k1

unlink key   根据value选择非阻塞删除

仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。

 unlink k3

为给定的key设置过期时间 已存在的key（{key} [时间]）

expire k1 20

查看还有多少秒过期 -1表示永不过期，-2表示已过期

ttl key

dbsize查看当前数据库的key的数量

flushdb清空当前库

flushall通杀全部库

3.redis字符串

get   <key>查询对应键值

append  <key><value>将给定的<value> 追加到原值的末尾

strlen  <key>获得值的长度

setnx  <key><value>只有在 key 不存在时    设置 key 的值

incr  <key>

将 key 中储存的数字值增1

只能对数字值操作，如果为空，新增值为1

decr  <key>

将 key 中储存的数字值减1

只能对数字值操作，如果为空，新增值为-1

incrby / decrby  <key><步长>将 key 中储存的数字值增减。自定义步长。

127.0.0.1:6379> key *
(error) ERR unknown command `key`, with args beginning with: `*`,
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> set k2 v2
OK
127.0.0.1:6379> set k3 v3
OK
127.0.0.1:6379> get k2
"v2"
127.0.0.1:6379> append k2 dfp02
(integer) 7
127.0.0.1:6379> get k2
"v2dfp02"
127.0.0.1:6379> strlen k2
(integer) 7
127.0.0.1:6379> setbx k1 v1CCC
(error) ERR unknown command `setbx`, with args beginning with: `k1`, `v1CCC`,
127.0.0.1:6379> set k1 v1ccc
OK
127.0.0.1:6379> get k1
"v1ccc"
127.0.0.1:6379> set kn 1999
OK
127.0.0.1:6379> incr kn
(integer) 2000
127.0.0.1:6379> get kn
"2000"
127.0.0.1:6379> decr kn
(integer) 1999
127.0.0.1:6379> get kn
"1999"
127.0.0.1:6379> incrby kn 1000
(integer) 2999
127.0.0.1:6379> get kn
"2999"
127.0.0.1:6379>

mset  <key1><value1><key2><value2>  .....

同时设置一个或多个 key-value对

mget  <key1><key2><key3> .....

同时获取一个或多个 value

msetnx <key1><value1><key2><value2>  .....

同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。

原子性，有一个失败则都失败

getrange  <key><起始位置><结束位置>

获得值的范围，类似java中的substring，前包，后包

setrange  <key><起始位置><value>

用 <value>  覆写<key>所储存的字符串值，从<起始位置>开始(索引从0开始)。

（注意下面的演示，key不够长替换原字符串长度的内容，足够长则覆盖<起始位置>到末尾的长度）

setex  <key><过期时间><value>

设置键值的同时，设置过期时间，单位秒。

getset <key><value>

以新换旧，设置了新值同时获得旧值。

127.0.0.1:6379> keys *
1) "k1"
2) "kn"
3) "k3"
4) "k2"
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3
OK
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"
127.0.0.1:6379> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v1 k11 v11 k12 v12
(integer) 0
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"
127.0.0.1:6379> msetnx k13 v13 k11 v11 k12 v12
(integer) 1
127.0.0.1:6379> keys *
1) "k11"
2) "k2"
3) "k1"
4) "k13"
5) "k12"
6) "k3"
127.0.0.1:6379> set name hellodfp
OK
127.0.0.1:6379> getrange name 0 3127.0.0.1:6379> set name hellodfp
OK
127.0.0.1:6379> setrange name1 0  hellodfp
(integer) 8
127.0.0.1:6379> get name1
"hellodfp"
127.0.0.1:6379> setrange name1 4  hellodfp
(integer) 12
127.0.0.1:6379> get name1
"hellhellodfp"
127.0.0.1:6379> setrange name 4  love
(integer) 8
127.0.0.1:6379> get name
"helllove"
127.0.0.1:6379> set name3 dfp456789
OK
127.0.0.1:6379> setrange name3 4  1
(integer) 9
127.0.0.1:6379> get name3
"dfp416789"
127.0.0.1:6379> setrange name3 5 11111
(integer) 10
127.0.0.1:6379> get name3
"dfp4111111"
127.0.0.1:6379>127.0.0.1:6379> setex kk 20 kkttl
OK
127.0.0.1:6379> ttl kk
(integer) 18
127.0.0.1:6379> ttl kk
(integer) 17
127.0.0.1:6379>127.0.0.1:6379> get k1
"v1"
127.0.0.1:6379> getset k1 newk1v1
"v1"
127.0.0.1:6379> get k1
"newk1v1"
127.0.0.1:6379>

4.Redis列表(List)

概念：

单键多值

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差。

命令：

lpush/rpush  <key><value1><value2><value3> .... 从左边/右边插入一个或多个值。

lpop/rpop  <key>从左边/右边吐出一个值。值在键在，值光键亡。吐出来之后这个值会消失

rpoplpush  <key1><key2>从<key1>列表右边吐出一个值，插到<key2>列表左边。

lrange <key><start><stop>

按照索引下标获得元素(从左到右)

lrange mylist 0 -1   0左边第一个，-1右边第一个，（0-1表示获取所有）

lindex <key><index>按照索引下标获得元素(从左到右)

llen <key>获得列表长度

linsert <key>  before <value><newvalue>在<value>的后面插入<newvalue>插入值

lrem <key><n><value>从左边删除n个value(从左到右)

lset<key><index><value>将列表key下标为index的值替换成value

127.0.0.1:6379> lpush k1 v1 v2 v3 v4
(integer) 4
127.0.0.1:6379> lrange k1 0 -1
1) "v4"
2) "v3"
3) "v2"
4) "v1"
127.0.0.1:6379> lrange k1 0 -1
1) "v4"
2) "v3"
3) "v2"
4) "v1"
127.0.0.1:6379> lindex k1 1
"v3"
127.0.0.1:6379> llen k1
(integer) 4
127.0.0.1:6379> lpop k1
"v4"
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> rpop k1
"v1"
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "v2"
127.0.0.1:6379> lpush k2 wyt dfp wp zsr
(integer) 4
127.0.0.1:6379> lrange k2 0 -1
1) "zsr"
2) "wp"
3) "dfp"
4) "wyt"
127.0.0.1:6379> rpoplpush k1 k2
"v2"
127.0.0.1:6379> lrange k21 0 -1
(empty array)
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
127.0.0.1:6379> lrange k2 0 -1
1) "v2"
2) "zsr"
3) "wp"
4) "dfp"
5) "wyt"
127.0.0.1:6379>
127.0.0.1:6379> lset k2 0 myname
OK
127.0.0.1:6379> lrange k2 0 -1
1) "myname"
2) "zsr"
3) "wp"
4) "dfp"
5) "wyt"
127.0.0.1:6379> linsert k2 before zsr zsr2
(integer) 6
127.0.0.1:6379> lrange k2 0 -1
1) "myname"
2) "zsr2"
3) "zsr"
4) "wp"
5) "dfp"
6) "wyt"
127.0.0.1:6379> linsert k2 after zsr zsr3
(integer) 7
127.0.0.1:6379> lrange k2 0 -1
1) "myname"
2) "zsr2"
3) "zsr"
4) "zsr3"
5) "wp"
6) "dfp"
7) "wyt"
127.0.0.1:6379> lrem k2 4
(error) ERR wrong number of arguments for 'lrem' command
127.0.0.1:6379> lrem k2 4 zsr*
(integer) 0
127.0.0.1:6379> lrange k2 0 -1
1) "myname"
2) "zsr2"
3) "zsr"
4) "zsr3"
5) "wp"
6) "dfp"
7) "wyt"
127.0.0.1:6379> lrem k2 4 zsr
(integer) 1
127.0.0.1:6379> lrange k2 0 -1
1) "myname"
2) "zsr2"
3) "zsr3"
4) "wp"
5) "dfp"
6) "wyt"

5.Redis集合(Set)

简介

Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。

Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。

一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变

常用命令

sadd <key><value1><value2> .....

将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略

smembers <key>取出该集合的所有值。

sismember <key><value>判断集合<key>是否为含有该<value>值，有1，没有0

scard<key>返回该集合的元素个数。

srem <key><value1><value2> .... 删除集合中的某个元素。

spop <key>随机从该集合中吐出一个值。

srandmember <key><n>随机从该集合中取出n个值。不会从集合中删除 。

smove <source><destination>value把集合中一个值从一个集合移动到另一个集合

sinter <key1><key2>返回两个集合的交集元素。

sunion <key1><key2>返回两个集合的并集元素。

sdiff <key1><key2>返回两个集合的差集元素(key1中的，不包含key2中的)

127.0.0.1:6379> sadd ka v1 v2 v3 v4 v4 v5
(integer) 5
127.0.0.1:6379> smembers ka
1) "v4"
2) "v3"
3) "v2"
4) "v1"
5) "v5"
127.0.0.1:6379> sismember ka v6
(integer) 0
127.0.0.1:6379> sismember ka v5
(integer) 1
127.0.0.1:6379> sadd kb v1 v2 v3 v4 v5
(integer) 5
127.0.0.1:6379> smembers kb
1) "v1"
2) "v4"
3) "v3"
4) "v2"
5) "v5"
127.0.0.1:6379> scard ka
(integer) 5
127.0.0.1:6379> srem ka v1
(integer) 1
127.0.0.1:6379> scard ka
(integer) 4
127.0.0.1:6379> smembers ka
1) "v2"
2) "v3"
3) "v5"
4) "v4"
127.0.0.1:6379>
127.0.0.1:6379> spop ka
"v5"
127.0.0.1:6379> smembers ka
1) "v2"
2) "v3"
3) "v4"
127.0.0.1:6379> srandmember kb 4
1) "v1"
2) "v2"
3) "v3"
4) "v4"
127.0.0.1:6379> srandmember kb 4
1) "v1"
2) "v2"
3) "v3"
4) "v4"
127.0.0.1:6379> srandmember kb 4
1) "v1"
2) "v2"
3) "v3"
4) "v5"
127.0.0.1:6379> smembers ka
1) "v2"
2) "v3"
3) "v4"
127.0.0.1:6379> smembers kb
1) "v1"
2) "v4"
3) "v3"
4) "v2"
5) "v5"
127.0.0.1:6379> smove ka kb v2
(integer) 1
127.0.0.1:6379> smembers ka
1) "v3"
2) "v4"
127.0.0.1:6379> smembers kb
1) "v4"
2) "v3"
3) "v2"
4) "v1"
5) "v5"
127.0.0.1:6379> smove kb ka v1
(integer) 1
127.0.0.1:6379> smembers ka
1) "v1"
2) "v3"
3) "v4"
127.0.0.1:6379> smembers kb
1) "v2"
2) "v3"
3) "v5"
4) "v4"
127.0.0.1:6379> sinter ka kb
1) "v3"
2) "v4"
127.0.0.1:6379> sdiff ka kb
1) "v1"
127.0.0.1:6379> sdiff kb ka
1) "v5"
2) "v2"
127.0.0.1:6379>

6.Redis哈希(Hash)

简介

Redis hash 是一个键值对集合。

Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。

类似Java里面的Map<String,Object>

用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息，如果用普通的key/value结构来存储。

常用命令

hset <key><field><value>给<key>集合中的  <field>键赋值<value>

hget <key1><field>从<key1>集合<field>取出 value

hmset <key1><field1><value1><field2><value2>... 批量设置hash的值

hexists<key1><field>查看哈希表 key 中，给定域 field 是否存在。

hkeys <key>列出该hash集合的所有field

hvals <key>列出该hash集合的所有value

hincrby <key><field><increment>为哈希表 key 中的域 field 的值加上增量 1   -1

hsetnx <key><field><value>将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在 。

127.0.0.1:6379> hset user1 id 1 name dfp age 22
(integer) 3
127.0.0.1:6379> hkeys user1
1) "id"
2) "name"
3) "age"
127.0.0.1:6379> havls user1
(error) ERR unknown command `havls`, with args beginning with: `user1`,
127.0.0.1:6379> hvals user1
1) "1"
2) "dfp"
3) "22"
127.0.0.1:6379> hget user1 name
"dfp"
127.0.0.1:6379> hmset user2 id 2 name dfp2 age 33 user3 id 3 name dfp3 age 44
(error) ERR wrong number of arguments for 'hmset' command
127.0.0.1:6379> hmset user2 id 2 name dfp2 age 33 user3
(error) ERR wrong number of arguments for 'hmset' command
127.0.0.1:6379> hmset user2 id 2 name dfp2 age 2
OK
127.0.0.1:6379> hmset user2 id 2 name dfp2 age 2 user3 id 3 name 333 age 13
(error) ERR wrong number of arguments for 'hmset' command
127.0.0.1:6379> hkeys user2
1) "id"
2) "name"
3) "age"
127.0.0.1:6379> hvals user2
1) "2"
2) "dfp2"
3) "2"
127.0.0.1:6379> hexists user1 name
(integer) 1
127.0.0.1:6379> hexists user1 wx
(integer) 0
127.0.0.1:6379> hsetnx user1 school zsdx
(integer) 1
127.0.0.1:6379> hkeys user1
1) "id"
2) "name"
3) "age"
4) "school"
127.0.0.1:6379>
127.0.0.1:6379> hincrby user1 age 2
(integer) 24
127.0.0.1:6379> hkeys user1
1) "id"
2) "name"
3) "age"
4) "school"
127.0.0.1:6379> hvals user1
1) "1"
2) "dfp"
3) "24"
4) "zsdx"
127.0.0.1:6379>

7.Redis有序集合Zset(sorted set)

简介

Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。

不同之处是有序集合的每个成员都关联了一个评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但是评分可以是重复了 。

因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。

访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。

常用命令

zadd  <key><score1><value1><score2><value2>…

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。

zrange <key><start><stop>  [WITHSCORES]   

返回有序集 key 中，下标在<start><stop>之间的元素

带WITHSCORES，可以让分数一起和值返回到结果集。

zrangebyscore key minmax [withscores] [limit offset count]

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

zrevrangebyscore key maxmin [withscores] [limit offset count]

同上，改为从大到小排列。

zincrby <key><increment><value>      为元素的score加上增量

zrem  <key><value>删除该集合下，指定值的元素

zcount <key><min><max>统计该集合，分数区间内的元素个数

zrank <key><value>返回该值在集合中的排名，从0开始。

127.0.0.1:6379> zadd salary 16000 dfp 6666 zsr 9800 wyt 8000 pzj 8000 lzx
(integer) 5
127.0.0.1:6379> zrange salary 5000 20000
(empty array)
127.0.0.1:6379> zrange salary 0 -1
1) "zsr"
2) "lzx"
3) "pzj"
4) "wyt"
5) "dfp"
127.0.0.1:6379> zrange salary 0 -1 withscores1) "zsr"2) "6666"3) "lzx"4) "8000"5) "pzj"6) "8000"7) "wyt"8) "9800"9) "dfp"
10) "16000"
127.0.0.1:6379> zrange salary 3 4
1) "wyt"
2) "dfp"
127.0.0.1:6379> zrangebyscore salary 6000 20000
1) "zsr"
2) "lzx"
3) "pzj"
4) "wyt"
5) "dfp"
127.0.0.1:6379> zrangebyscore salary 6000 20000 withscores1) "zsr"2) "6666"3) "lzx"4) "8000"5) "pzj"6) "8000"7) "wyt"8) "9800"9) "dfp"
10) "16000"
127.0.0.1:6379> zrangebyscore salary 6000 20000 withscores1) "zsr"2) "6666"3) "lzx"4) "8000"5) "pzj"6) "8000"7) "wyt"8) "9800"9) "dfp"
10) "16000"
127.0.0.1:6379> zincrby salary 3000 dfb
"3000"
127.0.0.1:6379> zrangebyscore salary 6000 20000 withscores1) "zsr"2) "6666"3) "lzx"4) "8000"5) "pzj"6) "8000"7) "wyt"8) "9800"9) "dfp"
10) "16000"
127.0.0.1:6379> zrank salary 8000
(nil)
127.0.0.1:6379> zrank salary 16000
(nil)
127.0.0.1:6379> zrank salary dfp
(integer) 5
127.0.0.1:6379> zincrby salary 3000 dfp
"19000"
127.0.0.1:6379> zcount salary 8000 20000
(integer) 4
127.0.0.1:6379> zrem salary wyt
(integer) 1127.0.0.1:6379> zrange 0 -1
(error) ERR wrong number of arguments for 'zrange' command
127.0.0.1:6379> zrange salary  0 -1
1) "dfb"
2) "zsr"
3) "lzx"
4) "pzj"
5) "dfp"
127.0.0.1:6379>

8.发布订阅命令行实现

  1. 打开一个客户端订阅channel1

SUBSCRIBE channel1

2、打开另一个客户端，给channel1发布消息hello

publish channel1 hello

返回的1是订阅者数量

3、打开第一个客户端可以p看到发送的消息

注：发布的消息没有持久化，如果在订阅的客户端收不到hello，只能收到订阅后发布的消息

9.Bitmaps

简介

现代计算机用二进制（位） 作为信息的基础单位， 1个字节等于8位， 例如“abc”字符串是由3个字节组成， 但实际在计算机存储时将其用二进制表示， “abc”分别对应的ASCII码分别是97、 98、 99， 对应的二进制分别是01100001、 01100010和01100011，如下图

合理地使用操作位能够有效地提高内存使用率和开发效率。

Redis提供了Bitmaps这个“数据类型”可以实现对位的操作：

  1. Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作。
  2. Bitmaps单独提供了一套命令， 所以在Redis中使用Bitmaps和使用字符串的方法不太相同。 可以把Bitmaps想象成一个以位为单位的数组， 数组的每个单元只能存储0和1， 数组的下标在Bitmaps中叫做偏移量。

命令

1、setbit

（1）格式

setbit<key><offset><value>设置Bitmaps中某个偏移量的值（0或1）

*offset:偏移量从0开始

（2）实例

每个独立用户是否访问过网站存放在Bitmaps中， 将访问的用户记做1， 没有访问的用户记做0， 用偏移量作为用户的id。

设置键的第offset个位的值（从0算起） ， 假设现在有20个用户，userid=1， 6， 11， 15， 19的用户对网站进行了访问， 那么当前Bitmaps初始化结果如图

unique:users:20201106代表2020-11-06这天的独立访问用户的Bitmaps

注：

很多应用的用户id以一个指定数字（例如10000） 开头， 直接将用户id和Bitmaps的偏移量对应势必会造成一定的浪费， 通常的做法是每次做setbit操作时将用户id减去这个指定数字。

在第一次初始化Bitmaps时， 假如偏移量非常大， 那么整个初始化过程执行会比较慢， 可能会造成Redis的阻塞。

2、getbit

（1）格式

getbit<key><offset>获取Bitmaps中某个偏移量的值

获取键的第offset位的值（从0开始算）

（2）实例

获取id=8的用户是否在2020-11-06这天访问过， 返回0说明没有访问过：

注：因为100根本不存在，所以也是返回0

3、bitcount

统计字符串被设置为1的bit数。一般情况下，给定的整个字符串都会被进行计数，通过指定额外的 start 或 end 参数，可以让计数只在特定的位上进行。start 和 end 参数的设置，都可以使用负数值：比如 -1 表示最后一个位，而 -2 表示倒数第二个位，start、end 是指bit组的字节的下标数，二者皆包含。

（1）格式

bitcount<key>[start end] 统计字符串从start字节到end字节比特值为1的数量

（2）实例

计算2022-11-06这天的独立访问用户数量

start和end代表起始和结束字节数， 下面操作计算用户id在第1个字节到第3个字节之间的独立访问用户数， 对应的用户id是11， 15， 19。

10.HyperLogLog

  • 简介

在工作当中，我们经常会遇到与统计相关的功能需求，比如统计网站PV（PageView页面访问量）,可以使用Redis的incr、incrby轻松实现。

但像UV（UniqueVisitor，独立访客）、独立IP数、搜索记录数等需要去重和计数的问题如何解决？这种求集合中不重复元素个数的问题称为基数问题。

解决基数问题有很多种方案：

（1）数据存储在MySQL表中，使用distinct count计算不重复个数

（2）使用Redis提供的hash、set、bitmaps等数据结构来处理

以上的方案结果精确，但随着数据不断增加，导致占用空间越来越大，对于非常大的数据集是不切实际的。

能否能够降低一定的精度来平衡存储空间？Redis推出了HyperLogLog

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。

在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。

但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。

什么是基数?

比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。

  • 命令

1、pfadd

（1）格式

pfadd <key>< element> [element ...]   添加指定元素到 HyperLogLog 中

将所有元素添加到指定HyperLogLog数据结构中。如果执行命令后HLL估计的近似基数发生变化，则返回1，否则返回0。


127.0.0.1:6379> pfadd k1 c++
(integer) 1
127.0.0.1:6379> pfadd k1 c
(integer) 1
127.0.0.1:6379> pfadd k1 java
(integer) 1
127.0.0.1:6379> pfadd k1 python
(integer) 1
127.0.0.1:6379> pfadd k1 c
(integer) 0
127.0.0.1:6379>

2、pfcount

（1）格式

pfcount<key> [key ...] 计算HLL的近似基数，可以计算多个HLL，比如用HLL存储每天的UV，计算一周的UV可以使用7天的UV合并计算即可


127.0.0.1:6379> pfcount k1
(integer) 4
127.0.0.1:6379>

3、pfmerge

（1）格式

pfmerge<destkey><sourcekey> [sourcekey ...]  将一个或多个HLL合并后的结果存储在另一个HLL中，比如每月活跃用户可以使用每天的活跃用户来合并计算可得

127.0.0.1:6379> pfadd k2 mysql redis java
(integer) 1
127.0.0.1:6379> pfcount k2
(integer) 3
127.0.0.1:6379> pfmerge k3 k1 k2
OK
127.0.0.1:6379> pfcount k3
(integer) 6
127.0.0.1:6379>

11.Geospatial

  • 简介

Redis 3.2 中增加了对GEO类型的支持。GEO，Geographic，地理信息的缩写。该类型，就是元素的2维坐标，在地图上就是经纬度。redis基于该类型，提供了经纬度设置，查询，范围查询，距离查询，经纬度Hash等常见操作。

  • 命令

1、geoadd

（1）格式

geoadd<key>< longitude><latitude><member> [longitude latitude member...]   添加地理位置（经度，纬度，名称）

127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 106.50 29.53 chongqing 114.05 22.52 shenzhen 116.38 39.90 beijing
(integer) 3
127.0.0.1:6379>

两极无法直接添加，一般会下载城市数据，直接通过 Java 程序一次性导入。

有效的经度从 -180 度到 180 度。有效的纬度从 -85.05112878 度到 85.05112878 度。

当坐标位置超出指定范围时，该命令将会返回一个错误。

已经添加的数据，是无法再次往里面添加的。

2、geopos

（1）格式

geopos  <key><member> [member...]  获得指定地区的坐标值


127.0.0.1:6379> geopos china:city shanghai
1) 1) "121.47000163793563843"2) "31.22999903975783553"
127.0.0.1:6379>

3、geodist

（1）格式

geodist<key><member1><member2>  [m|km|ft|mi ]  获取两个位置之间的直线距离

获取两个位置之间的直线距离


127.0.0.1:6379> geodist china:city beijing shanghai m
"1068153.5181"
127.0.0.1:6379>

单位：

m 表示单位为米[默认值]。

km 表示单位为千米。

mi 表示单位为英里。

ft 表示单位为英尺。

如果用户没有显式地指定单位参数， 那么 GEODIST 默认使用米作为单位

4、georadius

（1）格式

georadius<key>< longitude><latitude>radius  m|km|ft|mi   以给定的经纬度为中心，找出某一半径内的元素 （经度 纬度 距离 单位）


127.0.0.1:6379> georadius china:city 110 30 1000 km
1) "chongqing"
2) "shenzhen"
127.0.0.1:6379>

12.Redis_Jedis 整合操作

引入依赖

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.2.0</version>
</dependency>

禁用Linux的防火墙：Linux(CentOS7)里执行命令

systemctl stop/disable firewalld.service   

redis.conf中注释掉bind 127.0.0.1 ,然后 protected-mode no

Jedis常用操作

springboot工程或者普通的maven工程都可以在测试类下进行测试

12.1 key操作

    @Testvoid Key (){Jedis jedis=new Jedis("192.168.1.111",6379);jedis.auth("123456"); //redis连接密码，如果没有可以省略jedis.set("k1","v1");jedis.set("name","new dfp");Set<String>keys=jedis.keys("*");for (String key:keys) {System.out.println(key);}System.out.println(jedis.exists("k1"));System.out.println(jedis.ttl("name"));System.out.println(jedis.get("name"));}

结果

12.2 string操作

    @Testvoid string(){Jedis jedis=new Jedis("192.168.1.111",6379);jedis.auth("123456"); //redis连接密码，如果没有可以省略
//        jedis.mset("str1","v1","str2","v2","str3","v3");
//        System.out.println(jedis.mget("str1","str2","str3"));jedis.setex("dfp",20,"过期ttl");System.out.println("过期的"+jedis.ttl("dfp"));jedis.close();}

12.3 set操作

    @Testvoid set(){Jedis jedis=new Jedis("192.168.1.111",6379);jedis.auth("123456"); //redis连接密码，如果没有可以省略
//        jedis.sadd("order","phone");
//        jedis.sadd("order","xx");
//        jedis.sadd("order","app");
//        jedis.sadd("order","air");
//        jedis.sadd("order","snake");Set<String> smembers = jedis.smembers("order");for(String order:smembers){System.out.println("有："+order);}
//        jedis.srem("order", "order");System.out.println("个数:"+jedis.scard("order"));System.out.println("随机吐出"+jedis.spop("order"));System.out.println("吐出后个数:"+jedis.scard("order"));jedis.close();}

12.4 list操作

    void list(){Jedis jedis=new Jedis("192.168.1.111",6379);jedis.auth("123456"); //redis连接密码，如果没有可以省略jedis.lpush("listType","dfp","wyt","zsr","wp","cccc");System.out.println("打印第4个："+jedis.lindex("listType",4));System.out.println("打印长度："+jedis.llen("listType"));jedis.close();}

12.5 hash操作

    @Testvoid hash(){Jedis jedis=new Jedis("192.168.1.111",6379);jedis.auth("123456"); //redis连接密码，如果没有可以省略Map<String,String> key=new HashMap<>();key.put("id","011");key.put("name","DFP");key.put("age","16");key.put("school","qinghuaDax");jedis.hset("user1",key);System.out.println("查看名称："+jedis.hget("user1","name"));Set<String> hkeys = jedis.hkeys("user1");List<String> hvals = jedis.hvals("user1");System.out.println("所有的键："+hkeys);System.out.println("所有的值："+hvals);jedis.close();}

12.6  redis实现手机发送验证码案例

由于发送短信要整合第三方的业务这里简单讲一下思路

package com.redisdemo.redisdemo.phoneCode;import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;import java.util.Random;public class phoneCode {public static void main(String[] args) {String sixCode = getSixCode();saveCode("1008611",sixCode);//        getRedisCode("1008611",sixCode);//正确getRedisCode("1008611","4444");//错误}//判断输入的验证码和，系统生成的验证码是否一致public static void getRedisCode(String phone,String code){Jedis jedis=new Jedis("192.168.1.111",6379);jedis.auth("123456"); //redis连接密码，如果没有可以省略//验证码的keyString codeKey="save"+phone+":code";String codeSystem = jedis.get(codeKey);if (codeSystem.equals(code)){System.out.println("成功");}else {System.out.println("不成功");}jedis.close();}//每个手机每天发送3次，验证码放到redispublic static void saveCode(String phone,String code){Jedis jedis=new Jedis("192.168.1.111",6379);jedis.auth("123456"); //redis连接密码，如果没有可以省略//拼接key 设置我们的key//手机发送次数的keyString countKey="save"+phone+":count";//验证码的keyString codeKey="save"+phone+":code";//获取这个手机号的String count = jedis.get(countKey);if (StringUtils.isEmpty(count)){//非空为第一次/*** 1,保存的key* 2，过期时间* 3,，保存的值*/jedis.setex(countKey,24*60*60,"1");}else if(Integer.parseInt(count)<=2){//在规定次数内，进行增加jedis.incr(countKey);}else {System.out.println("超出规定次数");jedis.close();return ;}//设置code进redis/*** 1,保存的key* 2，过期时间* 3,，保存的值*/jedis.setex(codeKey,120,code);jedis.close();}//生成验证码public static String getSixCode(){Random random=new Random();String code="";for (Integer i=0;i<6;i++){int nextInt = random.nextInt(10);code+=nextInt;}return code;}
}

大家可以去测一下。

13 redis整合springboot

引入依赖

<!-- redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency><!-- spring2.X集成redis所需common-pool2-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.6.0</version>
</dependency>

配置文件设置

# 应用名称
spring.application.name=redisdemo
#服务地址
spring.redis.host=192.168.1.111
#端口号
spring.redis.port=6379
#服务密码
spring.redis.password=123456
#数据库索引（0-15）默认是0
spring.redis.database=1
#服务超时时间
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

配置信息复制直接用，用来定义系列化规则等等信息

@EnableCaching//开启缓存注解
@Configuration
public class RedisConfig extends CachingConfigurerSupport {@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {RedisTemplate<String, Object> template = new RedisTemplate<>();RedisSerializer<String> redisSerializer = new StringRedisSerializer();Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);ObjectMapper om = new ObjectMapper();om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);jackson2JsonRedisSerializer.setObjectMapper(om);template.setConnectionFactory(factory);
//key序列化方式template.setKeySerializer(redisSerializer);
//value序列化template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化template.setHashValueSerializer(jackson2JsonRedisSerializer);return template;}@Beanpublic CacheManager cacheManager(RedisConnectionFactory factory) {RedisSerializer<String> redisSerializer = new StringRedisSerializer();Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//解决查询缓存转换异常的问题ObjectMapper om = new ObjectMapper();om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）,过期时间600秒RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(600)).serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer)).serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)).disableCachingNullValues();RedisCacheManager cacheManager = RedisCacheManager.builder(factory).cacheDefaults(config).build();return cacheManager;}
}

@RestController
@RequestMapping("/api/redisTest")
public class RedisTestController {@Autowiredprivate RedisTemplate redisTemplate;@GetMapping("/test1")public String testRedis() {//设置值到redisredisTemplate.opsForValue().set("name","lucy");//从redis获取值String name = (String)redisTemplate.opsForValue().get("name");return name;}
}

14.Redis_事务_锁机制_秒杀

14.1 定义

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

Redis事务的主要作用就是串联多个命令防止别的命令插队。

14.2 Multi、Exec、discard

从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。

组队的过程中可以通过discard来放弃组队。

  • 正常执行
  • 127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set v1 k1
QUEUED
127.0.0.1:6379(TX)> set v2 k2
QUEUED
127.0.0.1:6379(TX)> set v3 k3
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set v4 k4
QUEUED
127.0.0.1:6379(TX)> get v4
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) "k4"
127.0.0.1:6379>

    我们发现每次设置的set放进队列中 exec后批量处理 并且我们的设置操作和读取操作都是一致，好比是排队 但是每个人做什么事情是自己定的。

  • 操作错误情况


127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set m1 v1
QUEUED
127.0.0.1:6379(TX)> set m2 v2
QUEUED
127.0.0.1:6379(TX)> set m3
(error) ERR wrong number of arguments for 'set' command
127.0.0.1:6379(TX)> set m4 v4
QUEUED
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379>

我们发现我的set m3操作是错误的，这样就会导致我们整个队列的所有操作提交都失败了


127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 va
QUEUED
127.0.0.1:6379(TX)> set k2 vb
QUEUED
127.0.0.1:6379(TX)> set k3 vc
QUEUED
127.0.0.1:6379(TX)> incr k3
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) OK
4) (error) ERR value is not an integer or out of range
127.0.0.1:6379>

我们在设置k3的vc是string类型但是我们对k3进行的incr操作室要对int类型说明这个操作是错误的但是 我们最终exec队列是可以执行的并且执行到第四个操作会给我报错。

总结：这样看起来就是说在组建队列的时候语法上没有错误是可以进行提交的，但是对提交的操作错误的最终还是会报错

  • 主动取消
  • 
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set ka v1
QUEUED
127.0.0.1:6379(TX)> set kb v2
QUEUED
127.0.0.1:6379(TX)> discard
OK
127.0.0.1:6379> exec
(error) ERR EXEC without MULTI

    14.3事务冲突的问题

  • 例子

一个请求想给金额减8000

一个请求想给金额减5000

一个请求想给金额减1000

  • 悲观锁

悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

  • 乐观锁

乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。

  • WATCH key [key ...]

在执行multi之前，先执行watch key1 [key2],可以监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

  • unwatch

取消 WATCH 命令对所有 key 的监视。

如果在执行 WATCH 命令之后，EXEC 命令或DISCARD 命令先被执行了的话，那么就不需要再执行UNWATCH 了。

案例

设置第一题服务器

127.0.0.1:6379> set monoey 100
OK
127.0.0.1:6379> get monoey
"100"
127.0.0.1:6379> watch monoey
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incrby monoey 50
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 150
127.0.0.1:6379>

设置第二台服务器

127.0.0.1:6379> watch monoey
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> decrby balance 100
QUEUED
127.0.0.1:6379(TX)> exec
(nil)

注意：同时在服务器1 2 设置事物，然后先进行服务器1的提交，再进行服务器2的提交我们发现服务器2 的提交失败，是加入了锁的原因 。在服务器1的操作后我们对key monoey的版本好进行修改了，但是服务器2的进行组队的操作的key monoey的版本停留在之前的版本。

EXEC — Redis 命令参考

14.4Redis事务三特性

  • 单独的隔离操作

    1. 事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
  • 没有隔离级别的概念
    1. 队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行
  • 不保证原子性
    1. 事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚

14.5秒杀案例

新建一个简单的web页面附带源码

链接：https://pan.baidu.com/s/1UjGTaYUH258_s6Tt2PMn4g?pwd=77vv 
提取码：77vv


/****/
public class SecKill_redis {public static void main(String[] args) {Jedis jedis =new Jedis("192.168.1.111",6379);System.out.println(jedis.ping());jedis.close();}//秒杀过程public static boolean doSecKill(String uid,String prodid) throws IOException {//1 uid和prodid非空判断if (uid==null && prodid==null){return false;}//2 连接redisJedis jedis=new Jedis("192.168.1.111",6379);jedis.auth("123456");//3 拼接key// 3.1 库存keyString kcKey="sk:"+prodid+":kc";// 3.2 秒杀成功用户keyString userKey="sk:"+prodid+":user";//监视库存 加上乐观锁jedis.watch(kcKey);//4 获取库存，如果库存null，秒杀还没有开始String kc=jedis.get(kcKey);if (kc==null){System.out.println("秒杀没有开始！！！");jedis.close();return false;}// 5 判断用户是否重复秒杀操作Boolean sismember = jedis.sismember(userKey, uid);if (sismember){System.out.println("成功秒杀不能重复！！！");jedis.close();return false;}//6 判断如果商品数量，库存数量小于1，秒杀结束if(Integer.parseInt(kc)<=0){System.out.println("秒杀结束，库存不足！！");jedis.close();return false;}//7 秒杀过程//使用事务Transaction multi = jedis.multi();//组队操作//执行//7.1 库存-1jedis.decr(kcKey);//7.2 把秒杀成功用户添加清单里面jedis.sadd(userKey,uid);return true;}
}

现在展示的案例流程，现在redis设置库存数量，然后运行程序，进行逻辑操作后更新数据，库存没了结束秒杀

我们在linux安装一个插件模拟 多用互通式访问并发的过程

使用工具ab模拟测试

yum install httpd-tools

测试及结果

通过ab测试

vim postfile 模拟表单提交参数,以&符号结尾;存放当前目录。

-n xxx  请求数量

-c xxx 并发数量

-p 配置文件

ab -n 2000 -c 200-k-p /postfile -T application/x-www-form-urlencoded http://ip:8081/Seckill/doseckill

虚拟机根目录下创建文本文件添加内容：prodid=0101&

成功演示但是我看看控制台和数据库，库存的数据是对不上的

如果加大并发数量这个值将会更加离谱

对于这种简单的数据的更新（秒杀案例）在面对大数据并发的时候就会出现这样的，过度操作和链接超时问题

这就回归我们上面将的到的乐观锁和悲观锁的运用解决这类问题了

添加连接池配置文件，解决超时问题

/*** 连接池*/
public class JedisPoolUtil {private static volatile JedisPool jedisPool = null;private JedisPoolUtil() {}public static JedisPool getJedisPoolInstance() {if (null == jedisPool) {synchronized (JedisPoolUtil.class) {if (null == jedisPool) {JedisPoolConfig poolConfig = new JedisPoolConfig();poolConfig.setMaxTotal(200); //最大连接数poolConfig.setMaxIdle(32);//资源池允许的最大空闲连接数poolConfig.setMaxWaitMillis(100*1000);//当资源池连接用尽后，调用者的最大等待时间（单位为毫秒）。-1永不超时poolConfig.setBlockWhenExhausted(true);//当资源池用尽后，调用者是否要等待poolConfig.setTestOnBorrow(true);  // ping  PONG/*** 1.配置文件* 2.连接地址* 3.端口* 4.最大超时时间*/jedisPool = new JedisPool(poolConfig, "192.168.1.111", 6379, 60000,"123456" );}}}return jedisPool;}public static void release(JedisPool jedisPool, Jedis jedis) {if (null != jedis) {jedisPool.returnResource(jedis);}}}

更改一部分代码加上乐观锁

采用连接池创建jedis对象

对库存进行监听

将操作放入到事物

演示，我们在虚拟机上继续执行高并发的操作

结果

现在是正常的库存了

但是这样操作后会出现新的问题 在多次测试之后

正常执行高并发测试

发现有数据遗留 正常情况应该是0

原因是虽然乐观锁可以帮助我们管理，每个用户的操作防止系统错误但是，一但出现错误锁住的版本对应不上了，那么剩下的操作都不能进行。

14.6 LUA脚本解决库存遗留问题

      

Lua 是一个小巧的脚本语言，Lua脚本可以很容易的被C/C++ 代码调用，也可以反过来调用C/C++的函数，Lua并没有提供强大的库，一个完整的Lua解释器不过200k，所以Lua不适合作为开发独立应用程序的语言，而是作为嵌入式脚本语言。

很多应用程序、游戏使用LUA作为自己的嵌入式脚本语言，以此来实现可配置性、可扩展性。

这其中包括魔兽争霸地图、魔兽世界、博德之门、愤怒的小鸟等众多游戏插件或外挂。

Lua 教程_w3cschool

LUA脚本在Redis中的优势

将复杂的或者多步的redis操作，写为一个脚本，一次提交给redis执行，减少反复连接redis的次数。提升性能。

LUA脚本是类似redis事务，有一定的原子性，不会被其他命令插队，可以完成一些redis事务性的操作。

但是注意redis的lua脚本功能，只有在Redis 2.6以上的版本才可以使用。

利用lua脚本淘汰用户，解决超卖问题。

redis 2.6版本以后，通过lua脚本解决争抢问题，实际上是redis 利用其单线程的特性，用任务队列的方式解决多任务并发问题。

框架图

代码方法演示秒杀案例，我们要在SecKillServlet类中选择这个方法的入口

/*** 脚本方法*/
public class SecKill_redisByScript {private static final  org.slf4j.Logger logger =LoggerFactory.getLogger(SecKill_redisByScript.class) ;public static void main(String[] args) throws IOException {JedisPool jedispool =  JedisPoolUtil.getJedisPoolInstance();Jedis jedis=jedispool.getResource();System.out.println(jedis.ping());Set<HostAndPort> set=new HashSet<HostAndPort>();doSecKill("201","sk:0101");}static String secKillScript ="local userid=KEYS[1];\r\n" + "local prodid=KEYS[2];\r\n" + "local qtkey='sk:'..prodid..\":kc\";\r\n" +"local usersKey='sk:'..prodid..\":user\";\r\n" +"local userExists=redis.call(\"sismember\",usersKey,userid);\r\n" + "if tonumber(userExists)==1 then \r\n" + "   return 2;\r\n" + "end\r\n" + "local num= redis.call(\"get\" ,qtkey);\r\n" + "if tonumber(num)<=0 then \r\n" + "   return 0;\r\n" + "else \r\n" + "   redis.call(\"decr\",qtkey);\r\n" + "   redis.call(\"sadd\",usersKey,userid);\r\n" + "end\r\n" + "return 1" ;static String secKillScript2 = "local userExists=redis.call(\"sismember\",\"{sk}:0101:usr\",userid);\r\n" +" return 1";public static boolean doSecKill(String uid,String prodid) throws IOException {JedisPool jedispool =  JedisPoolUtil.getJedisPoolInstance();Jedis jedis=jedispool.getResource();String sha1=  jedis.scriptLoad(secKillScript);Object result= jedis.evalsha(sha1, 2, uid,prodid);String reString=String.valueOf(result);if ("0".equals( reString )  ) {System.err.println("已抢空！！");}else if("1".equals( reString )  )  {System.out.println("抢购成功！！！！");}else if("2".equals( reString )  )  {System.err.println("该用户已抢过！！");}else{System.err.println("抢购异常！！");}jedis.close();return true;}
}

多次测试的结果 就不会有数据遗留的问题了

到此基本的redis入门已经介绍完毕

redis安装到熟练整合springboot（篇幅较长内容详细）相关推荐

  1. rabbitmq消息队列入门到整合springboot（篇幅较长内容详细）

    1.安装rabbitmq服务器 我们选择在linux下安装 安装的前提需要在虚拟机下安装docker docker pull rabbitmq:management(拉去镜像) docker run ...

  2. MongoDB安装及实战(整合springboot)

    MongoDB简介 1.NoSQL简介 NoSQL(NoSQL = Not Only SQL),意即反SQL运动,指的是非关系型的数据库,是一项全新的数据库革命性运动,早期就有人提出,发展至2009年 ...

  3. 使用DockerCompose部署Redis分片集群——整合SpringBoot

    今天来记录一下使用DockerCompose部署Redis分片集群的过程,前面写了几篇关于redis的博客了,这里就不再过多介绍了,直接上配置就好了 version: "3.0"s ...

  4. Redis 安装配置开机启动整合SpringBoot以及配置文件详解

    安装 Redis # 下载Redis wget https://download.redis.io/releases/redis-6.0.9.tar.gz# 解压 redis tar -zxvf re ...

  5. 10分钟解决Redis安装和Springboot整合

    1.Redis安装 for Windows https://github.com/microsoftarchive/redis/releases 下载完成后双击安装,一直下一步 然后打开Redis安装 ...

  6. redis序列化_实例讲解Springboot以Template方式整合Redis及序列化问题

    1 简介 之前讲过如何通过Docker安装Redis,也讲了Springboot以Repository方式整合Redis,建议阅读后再看本文效果更佳: (1) Docker安装Redis并介绍漂亮的可 ...

  7. redis安装，redis项目以来，redis和spring整合，redis的service，redis的service实现类

    一．redis安装: Redis-3.2.6.tar.gz安装,参考方式: (这里也可以用于安装redis-4.0.9.tar.gz :     wget http://download.redis. ...

  8. Spring Boot——Redis安装配置与应用整合

    引言 Spring Boot默认以ConcurrentHashMap作为缓存容器,但默认的缓存容器在简单的场景使用还是可以的,而作为NoSQL的代表,Redis可以做内存数据库.消息中间件都是不错的, ...

  9. mac xampp redis php,MAC XAMPP 整合使用Redis 及 安装php redis扩展

    (环境: MAC + XAMPP + redis) [本期概要:] 1.安装整合的准备工作 2.Redis服务的安装 3.PHP Redis扩展的安装 4.整合调试 复制代码 一.准备工作 1.安装 ...

最新文章

  1. Javascript刷题 》 查找数组元素位置
  2. retinaface mnn
  3. 零基础学python需要多久-零基础学Python要多久
  4. .netcore 极速接入第三方登录
  5. 【牛客 - 297C】little w and Segment Coverage（差分数组，区间差分，思维，卡线段树）☆
  6. bat文件获取当前时间并格式化输出
  7. 定义一个list对象数组 java_javascript定义一个list
  8. 51单片机的音乐盒设计
  9. win10 linux efi分区大小,EFI模式 win10+Ubuntu16.04双系统
  10. 鼠标右键反应慢的可能原因
  11. 马斯克、李彦宏、姚期智等云端纵论AI，他们都说了什么？
  12. 关于对MIDlet套件进行数字签名
  13. 【证明题】（一）微分中值定理
  14. el-table 表格内容多一根线的解决办法
  15. 绿芯GreenChip电容式触控触摸IC型号性能介绍
  16. wps如何放大导航窗格字体
  17. 脑残定义，超级经典！
  18. mysql上机试题_mysql上机试题
  19. cmd调取windows组件的dos命令大全和常用网络工具，及Linux系统下命令大全
  20. 收集的十个高清无版权图片网站

热门文章

  1. 在N1小钢炮下部署甜糖的过程
  2. wordpress运行php代码,怎么在wordpress的文章或页面中运行PHP代码
  3. 【炉石传说】砰砰计划 斩杀 最后一关 通关攻略
  4. template.js模板引擎下载和实例
  5. 什么是帕累托图？有什么用？
  6. net， 哥已心灰意冷
  7. 【Android】应用数据和文件#存储空间概览
  8. 怎样修改图片大小？如何编辑照片尺寸大小？
  9. SEO发包技术深度揭秘
  10. 留言“说出你对中国乒乓的祝福”，60字左右