Redis基础详解_怎么判断redis是否有客户端连接-程序员宅基地

127.0.0.1:6379>select 3    #切换数据库
OK
127.0.0.1:6379[3]>DBSIZE   #查看DB大小
(integer) 0
127.0.0.1:6379[3]>set name qq  #3号数据库添加一条内容
OK
127.0.0.1:6379[3]>DBSIZE   #查看DB大小
(integer)1
127.0.0.1:6379[3]>select 7  
0K
127.0.0.1:6379[7]>DBSIZE
( integer)0
i27.0.0.1:6379[7]>get name
(nil)
127.0.0.1:6379[7]>select 3
OK
127.0.0.1:6379[3]>get name
"qq"

keys * 查看所有的key

127.0.0.1:6379[3]> keys * #查看数据库所有的key

1)"name"

清除当前数据库flushdb

清除全部数据库的内容FLUSHALL

127.0.0.1:6379[3]> flushdb

OK
127.0.0.1:6379[3]> keys *

(empty list or set)

为什么Redis是单线程的？

因为Redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。在单线程的情况下，就不用去考虑各种锁的问题，不存在加锁、释放锁操作，没有因为可能出现死锁而导致的性能消耗。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了。

既然是单线程，那怎么监听大量的客户端连接呢？

Redis 通过IO 多路复用程序 来监听来自客户端的大量连接（或者说是监听多个 socket），它会将感兴趣的事件及类型(读、写）注册到内核中并监听每个事件是否发生。这样的好处非常明显： I/O 多路复用技术的使用让 Redis 不需要额外创建多余的线程来监听客户端的大量连接，降低了资源的消耗（和 NIO 中的 Selector 组件很像）。

Redis的高并发和快速原因？

1.redis是基于内存的，内存的读写速度非常快（纯内存）; 数据存在内存中，数据结构用HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)。

2.redis是单线程的，省去了很多上下文切换线程的时间（避免线程切换和竞态消耗）。

3.redis使用IO多路复用技术（IO multiplexing, 解决对多个I/O监听时,一个I/O阻塞影响其他I/O的问题），可以处理并发的连接（非阻塞IO）。

Redis6.0 之后为何引入了多线程？

Redis6.0 引入多线程主要是为了提高网络 IO 读写性能，因为这个算是 Redis 中的一个性能瓶颈（Redis 的瓶颈主要受限于内存和网络）。虽然，Redis6.0 引入了多线程，但是 Redis 的多线程只是在网络数据的读写这类耗时操作上使用了，在核心的消费模块执行命令仍然是单线程顺序执行。因此，不需要担心线程安全问题。Redis6.0 的多线程默认是禁用的，只使用主线程。如需开启需要修改 redis 配置文件 redis.conf

io-threads-do-reads yes

开启多线程后，还需要设置线程数，否则是不生效的。同样需要修改 redis 配置文件 redis.conf

io-threads 4 #官网建议4核的机器建议设置为2或3个线程，8核的建议设置为6个线程

三、Redis五大数据类型，三种特殊数据类型

Redis是一个开源（BSD许可)的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。它支持多种类型的数据结构，如字符串 ( strings ）)，散列 ( hashes )，列表( lists )，集合( sets )，有序集合( sorted sets）与范围查询bitmaps ， hyperloglogs和地理空间(geospatial）索引半径查询。Redis内置了复制( replication )，LUA脚本(Luascripting)，LRU驱动事件( LRU eviction )，事务 ( transactions ）和不同级别的磁盘持久化 ( persistence)，并通过Redis哨兵( Sentinel )和自动分区( Cluster )提供高可用性( high availability )。

启动Redis

1、启动Redis

建议通过配置文件来启动Redis。
> redis-server xx/xx/redis.conf
2、连接Redis
> redis-cli -p 6379
3、测试连通性
127.0.0.1:6379> ping
PONG
确保redis运行
ps -ef|grep redis
4、停止Redis
> redis-cli shutdown

> kill redis-pid
以上两条停止Redis命令效果一样。

Redis-Key

127.0.0.1:6379> set age 1 #设置值

127.0.0.1:6379> get age # 根据 key 获得对应的 value

127.0.0.1:6379> keys * #查看所有key值

127.0.0.1:6379> EXISTS age #判断某个 key 是否存在

127.0.0.1:6379> move age 1 #在当前库移除age，1代表当前库

127.0.0.1:6379> expire age 60 #设置过期时间数据在 60s 后过期

127.0.0.1:6379> ttl age # 查看数据还有多久过期

127.0.0.1:6379> type age # 查看当前key的类型

String（字符串）

127.0.0.1:6379> set key1 v1 #设置值
127.0.0.1:6379> get key1 #获得值
127.0.0.1:6379> keys * #获得所有的key
127.0.0.1:6379> EXISTS key1 #判断某一个key是否存在
127.0.0.1:6379>APPEND key1 "hello" #追加字符串，如果当前key不存在，就相当setkey
127.0.0.1:6379> get key1

"v1hello"
127.0.0.1:6379>STRLEN key1 #获取字符串的长度!

#########################################################################

i++

i+=

127.0.0.1:6379> incr number # 自增1 将 key 中储存的数字值增一

127.0.0.1:6379> decr number # 自减1 将 key 中储存的数字值减一

127.0.0.1:6379>INCRBY views 10 # 可以设置步长，指定增量!
127.0.0.1:6379>DECRBY views 10 # 可以设置步长，指定减量!

####################################################################

字符串范围range
127.0.0.1:6379> GETRANGE key1 0 3 #截取字符串[0,3]
127.0.0.1:6379>GETRANGE key1 0 -1 #获取全部的字符串和 get key是一样的
127.0.0.1:6379>SETRANGE key2 1 xx #替换从指定位置开始的字符串!

####################################################################### setex (set with expire)#设置过期时间
setnx (set if not exist)#不存在在设置（在分布式锁中会常常使用!)
127.0.0.1:6379> setex key3 30 "he11o" #设置key3 的值为hello,30秒后过期
127.0.0.1:6379> setnx mykey "redis" #如果mykey 不存在，创建mykey

(integer) 1
127.0.0.1:6379> setnx mykey "MongoDB" #如果mykey存在，创建失败!

(integer) 0
127.0.0.1:6379> get mykey

"redis"
######################################################################

批量设置mset mget
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 #同时设置多个值
127.0.0.1:6379> mget k1 k2 k3 #同时获取多个值
127.0.0.1:6379> msetnx k1 v k4 v4 #msetnx是一个原子性的操作，要么一起成功，要么一起失败!

(integer) 0
127.0.0.1:6379> get k4

(nil)
#对象
set user:1 {name:zhangsan , age:3]#设置一个user:1对象值为json字符来保存一个对象!
# 这里的key是一个巧妙的设计: user:{id}:{filed} ,如此设计在Redis中是完全oK了!
127.0.0.1:6379> mset user: 1:name zhangsan user:1:age 2
127.0.0.1:6379> mget user: 1:name user: 1:age

1) "zhangsan"
2) "2"
##################################################################

getset # 先get然后在set
127.0.0.1:6379> getset db redis # 如果不存在值，则返回 nil

(nil)
127.0.0.1:6379> get db

"redis"
127.0.0.1:6379> getset db mongodb #如果存在值，获取原来的值，并设置新的值

"redis"
127.0.0.1:6379> get db

"mongodb"

应用场景

1、缓存功能：部分数据第一次查询查询数据库，查询完后存入redis中，后续再获取可以从redis中获取
2、验证码：网站登录中常有验证码，我们可以用此数据类型，手机号作为key，验证码作为value存储在redis中，设置过期时间，后续如果用户输入验证码，我们从redis中取值对比，如果过期则无效
3、数字计数：点赞数、访问量、关注数等
4、存储对象
5、共享session 分布式服务会将用户信息的访问均衡到不同服务器上，用户刷新一次访问可能会需要重新登录，为避免这个问题可以用redis将用户session集中管理，每次获取用户更新或查询登录信息都直接从redis中集中获取
6、分布式锁 string类型的setnx的作用是“当key不存在时，设值并返回1，当key已经存在时，不设值并返回0”，“判断key是否存在"和"设值"两个操作是原子性地执行的，因此可以用string类型作为分布式锁，返回1表示获得锁，返回0表示没有获得锁。适用场景：在一个集群环境下，多个web应用时对同一个商品进行抢购和减库存操作时，可能出现超卖时会用到分布式锁

LIst（列表）

Redis 的 list 的实现为一个 双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销。在redis里面，我们可以把list，用作栈、队列、消息队列，所有list命令都是以l开头的

###################################################################

LPUSH 、Rpush、 LRANGE

127.0.0.1:6379>LPUSH list one # 将一个值或者多个值，插入到列表头部（左)
127.0.0.1:6379> LPUSH list two # two one
127.0.0.1:6379> LPUSH list three # three two one
127.0.0.1:6379> LRANGE list 0 1 # 查看对应下标的list列表， 0 为 start,1为 end

1) "three"
2)"two"
127.0.0.1:6379> Rpush list righr #将一个值或者多个值，插入到列表位部(右)
127.0.0.1:6379>LRANGE list 0 -1   # three two one  righr

1) "three"
2)"two"

3) "one"

4) "righr"

###################################################################

LPOP 、 RPOP
127.0.0.1:6379> Lpop list #移除list的第一个元素"three"
127.0.0.1:6379> Rpop list #移除list的最后一个元素"righr"

Lindex
127.0.0.1:6379> lindex list 1 # 通过下标获得list中的某一个值
Llen
127.0.0.1:6379> llen list  # 返回列表的长度

Lrem

127.0.0.1:6379> Lrem list 3 one # 移除list集合中指定个数的value，精确匹配移除三个one
Ltrim

127.0.0.1:6379>ltrim mylist 1 2 #通过下标截取指定的长度，这个list已经被改变了，截断了只剩下截取的元素!

###################################################################
rpoplpush
127.0.0.1:6379> rpush mylist "hello"
127.0.0.1:6379> rpush mylist "hello1"
127.0.0.1:6379> rpush my1ist "hello2" # hello hello1 hello2

127.0.0.1:6379>rpoplpush mylist myotherlist #移除列表的最后一个元素，将他移动到新的列表中!
127.0.0.1:6379> lrange mylist 0 -1 # 查看原来的列表

1) "hello"
2) "hello1"
127.0.0.1:6379> lrange myotherlist 0 -1 #查看目标列表中，确实存在改值!

1) "hello2"

###################################################################
Lset  将列表中指定下标的值替换为另外一个值，更新操作

127.0.0.1:6379> EXISTS list #判断这个列表是否存在
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> LRANGE list 0 0

1) "value1"
127.0.0.1:6379> lset list 0 item #如果存在，更新当前下标0的值，为item
127.0.0.1:6379> LRANGE list 0 0

1) "item"
127.0.0.1:6379> lset list 1 other #如果列表元素不存在，也会报错!

(error) ERR index out of range

###################################################################

LINSERT #将某个具体的value插入到列表中某个元素的前面或者后面!
127.0.0.1:6379> Rpush mylist "hello"
127.0.0.1:6379> Rpush mylist "world"
127.0.0.1:6379> LINSERT mylist before "world" "other"
127.0.0.1:6379> LRANGE mylist 0 -1

1)"hel1o"
2) "other"

3)"wor1d"
127.0.0.1:6379>LINSERT mylist after world new
127.0.0.1:6379> LRANGE mylist 0 -1

1) "he1lo"
2) "other"

3) "world"

4) "new"

应用场景

1. 消息队列 list类型的lpop和rpush（或者反过来，lpush和rpop）能实现队列的功能，不过我不推荐在实战中这么使用，因为现在已经有Kafka、NSQ、RabbitMQ等成熟的消息队列了，它们的功能已经很完善了。
2. 排行榜 list类型的lrange命令可以分页查看队列中的数据。可将每隔一段时间计算一次的排行榜存储在list类型中，如京东每日的手机销量排行、学校每次月考学生的成绩排名、斗鱼年终盛典主播排名等，每计算一次，存储在list类型中，接口访问时，通过page和size分页获取打擂金曲。只有定时计算的排行榜才适合使用list类型存储，与定时计算的排行榜相对应的是实时计算的排行榜，list类型不能支持实时计算的排行榜
3. 最新列表 list类型的lpush命令和lrange命令能实现最新列表的功能，每次通过lpush命令往列表里插入新的元素，然后通过lrange命令读取最新的元素列表，如朋友圈的点赞列表、评论列表。只有不需要分页（比如每次都只取列表的前5个元素）或者更新频率低（比如每天凌晨更新一次）的列表才适合用list类型实现。对于需要分页并且会频繁更新的列表，需用使用有序集合sorted set类型实现。另外，需要通过时间范围查找的最新列表，list类型也实现不了，也需要通过有序集合sorted set类型实现，如以成交时间范围作为条件来查询的订单列表。

对于排行榜和最新列表两种应用场景，list类型能做到的sorted set类型都能做到，list类型做不到的sorted set类型也能做到，那为什么还要使用list类型去实现排行榜或最新列表呢，直接用sorted set类型不是更好吗？原因是sorted set类型占用的内存容量是list类型的数倍之多

Set(集合)

set 类似于 Java 中的 HashSet 。Redis 中的 set 类型是一种无序集合，集合中的元素没有先后顺序。当你需要存储一个列表数据，又不希望出现重复数据时，set 是一个很好的选择，并且 set 提供了判断某个成员是否在一个 set 集合内的重要接口，这个也是 list 所不能提供的。可以基于 set 轻易实现交集、并集、差集的操作。比如：你可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。Redis 可以非常方便的实现如共同关注、共同粉丝、共同喜好等功能。这个过程也就是求交集的过程。

sadd

127.0.0.1:6379> sadd mySet value1 value2 # 添加元素进去
(integer) 2
127.0.0.1:6379> sadd mySet value1 # 不允许有重复元素
(integer) 0

smembers
127.0.0.1:6379> smembers mySet # 查看 set 中所有的元素
1) "value1"
2) "value2"

scard
127.0.0.1:6379> scard mySet # 查看 set 的长度
(integer) 2

sismember
127.0.0.1:6379> sismember mySet value1 # 检查某个元素是否存在set 中，只能接收单个元素

srem

127.0.0.1:6379>srem myset value1 #移除set集合中的指定元素

SRANDMEMBER
127.0.0.1:6379>SRANDMEMBER myset #随机抽选出一个元素

127.0.0.1:6379>SRANDMEMBER myset 2 #随机抽选出指定个数的元素

spop

127.0.0.1:6379>spop myset #随机删除一些set集合中的元素!

smove
127.0.0.1:6379> smove myset myset2 "asdf" # 将一个指定的值，移动到另外一个set集合!

SDIFF 差集 SINTER 交集 SUNION 并集
127.0.0.1:6379> sinterstore mySet3 mySet mySet2 # 获取 mySet 和 mySet2 的交集并存放在 mySet3 中

127.0.0.1:6379>SDIFF key1 key2 #差集不同的
127.0.0.1:6379> SINTER key1 key2 #交集共有的
127.0.0.1:6379>SUNION key1 key2 #并集

应用场景

1. 标签 比如我们博客网站常常使用到的兴趣标签，把一个个有着相同爱好，关注类似内容的用户利用一个标签把他们进行归并。
2、关注好友//粉丝/感兴趣的人集合 共同好友功能，共同喜好，或者可以引申到二度好友之类的扩展应用。
3、统计网站的独立IP 利用set集合当中元素不唯一性，可以快速实时统计访问网站的独立IP。
4、随机展示 通常，app首页的展示区域有限，但是又不能总是展示固定的内容，一种做法是先确定一批需要展示的内容，再从中随机获取。
5、黑名单/白名单 经常有业务出于安全性方面的考虑，需要设置用户黑名单、ip黑名单、设备黑名单等，set类型适合存储这些黑名单数据，sismember命令可用于判断用户、ip、设备是否处于黑名单之中。

Hash（哈希）

hash 类似于 JDK1.8 前的 HashMap，内部实现也差不多(数组 + 链表)。不过，Redis 的 hash 做了更多优化。另外，hash 是一个 string 类型的 field 和 value 的映射表，特别适合用于存储对象，后续操作的时候，你可以直接仅仅修改这个对象中的某个字段的值。比如我们可以 hash 数据结构来存储用户信息，商品信息等等。

hset、hget

127.0.0.1:6379> hset myhash field1 hello # set 一个具体的key-value

127.0.0.1:6379> hget myhash field1 # 获取存储在哈希表中指定字段的值。

hmset、 hmget

127.0.0.1:6379> hmset myhash field1 hello field2 world # set多个 key-vlaue
127.0.0.1:6379> hmget myhash field1 field2 #获取多个字段值

1) "hello"
2)"world"

hgetall
127.0.0.1:6379> hgetall myhash # 获取在哈希表中指定 key 的所有字段和值

1)"field1"

2) "hello"
3)"field2"

4)"world"

hdel

127.0.0.1:6379> hdel myhash field1 #删除hash指定key字段!对应的value值也就消失了!

hlen
127.0.0.1:6379> hlen myhash #获取hash表的字段数量!

hexists

127.0.0.1:6379> hexists myhash field1 # 查看 hash中指定的字段是否存在。

hkeys、 hvals

127.0.0.1:6379> hkeys myhash # 获取 key 列表

127.0.0.1:6379> hvals myhash # 获取 value 列表

HINCRBY、HDECRBY、hsetnx
127.0.0.1:6379> HINCRBY myhash field3 1 #指定增量
127.0.0.1:6379> HDECRBY myhash field3 4
127.0.0.1:6379> hsetnx myhash field4 hello #如果不存在则可以设置
127.0.0.1:6379> hsetnx myhash field4 world #如果存在则不能设置

对象

127.0.0.1:6379> hset userInfoKey name "guide" description "dev" age "24"

hash变更的数据user name age,尤其是是用户信息之类的，经常变动的信息! hash更适合于对象的存储，String更加适合字符串存储!

应用场景

hash类型是一个string类型的field和value的映射表

1. 购物车　以用户id为key，商品id为field，商品数量为value，恰好构成了购物车的3个要素
2. 存储对象 hash类型的(key, field, value)的结构与对象的(对象id, 属性, 值)的结构相似，也可以用来存储对象。

一般对象用string + json存储，对象中某些频繁变化的属性抽出来用hash存储

Sorted set（Zset有序集合）

和 set 相比，sorted set 增加了一个权重参数 score，使得集合中的元素能够按 score 进行有序排列，还可以通过 score 的范围来获取元素的列表。有点像是 Java 中 HashMap 和 TreeSet 的结合体。set k1 v1 ----- zset k1 score1 v1

zadd

127.0.0.1:6379> zadd myZset 3.0 value1 # 添加元素到 sorted set 中 3.0 为权重

127.0.0.1:6379> zadd myZset 2.0 value2 1.0 value3 # 一次添加多个元素

zrange

127.0.0.1:6379> zrange myZset 0 -1 # 顺序输出某个范围区间的元素，0 -1 表示输出所有元素

zrevrange

127.0.0.1:6379> zrevrange myZset 0 -1 # 逆序输出某个范围区间的元素，0 为 start 1 为 stop

zcard

127.0.0.1:6379> zcard myZset # 查看 sorted set 中的元素数量

zscore

127.0.0.1:6379> zscore myZset value1 # 查看某个 value 的权重

ZRANGEBYSCORE

127.0.0.1:6379>ZRANGEBYSCORE salary -inf +inf # 显示全部的用户从小到大!
127.0.0.1:6379>ZRANGEBYSCORE salary -inf +inf withscores # 显示全部的用户并且附带成绩
127.0.0.1:6379>ZRANGEBYSCORE salary -inf 2500 withscores # 显示工资小于2500员工的升序排序!

zrem
127.0.0.1:6379>zrem salary xiaohong #移除有序集合中的指定元素

zcount

127.0.0.1:6379> zcount myset 1 3 # 获取指定区间的成员数量!

应用场景

1、根据时间排序的新闻列表等，
2、阅读排行榜

geospatial（地理位置）

朋友的定位，附近的人，打车距离计算？Redis的Geo在Redis3.2版本就推出了!这个功能可以推算地理位置的信息，两地之间的距离，方圆几里的人!

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

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

getadd 添加地理位置
#规则:两级无法直接添加，我们一般会下载城市数据，直接通过java程序一次性导入

#参数key值（经度、纬度、名称)

127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing
127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
127.0.0.1:6379> geoadd china:city 106.50 29.53 chongqing 114.05 22.52 shenzhen
127.0.0.1:6379> geoadd china:city 120.16 30.24 hangzhou 108.96 34.26 xian
getpos

127.0.0.1:6379>GEOPos china:city beijing # 获取指定的城市的经度和纬度!

1)1) "116.39999896287918091"
2) "39.90000009167092543"
getdist 指定单位的参数 unit 必须是以下单位的其中一个：

m 表示单位为米。

km 表示单位为千米。

mi 表示单位为英里。

ft 表示单位为英尺。

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

127.0.0.1:6379>GEODIST china: city beijing shanghai #返回两个给定位置之间的直线距离

"1067378.7564"
127.0.0.1:6379> GEODIST china: city beijing shanghai km

"1067.3788"
georadius以给定的经纬度为中心，找出某一半径内的元素【以自己为中心找附近的人】

127.0.0.1:6379>GEORADIUS china:city 110 30 1000 km # 以110，30这个经纬度为中心，寻找方圆1000km内的城市
127.0.0.1:6379> GEORADIus china:city 110 30 500 km withdist #在返回位置元素的同时，将位置元素与中心之间的距离也一并返回。

127.0.0.1:6379> GEORADIus china:city 110 30 500 km WITHCOORD #将位置元素的经度和维度也一并返回。

127.0.0.1:6379> GEORADIus china:city 110 30 500 km withdist WITHCOORD count 1 #指定返回结果数量

ASC: 根据中心的位置，按照从近到远的方式返回位置元素。

DESC: 根据中心的位置，按照从远到近的方式返回位置元素。

GEORADIUSBYMEMBER找出位于指定范围内的元素，中心点是由给定的位置元素决定

【导航定位】

127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km

1)"beijing"
2) "xian"
127.0.0.1:6379> GEORADIUSBYMEMBER china:city shanghai 400 km

1) "hangzhou"
2) "shanghai"
geohash返回一个或多个位置元素的Geohash表示

# 将二维的经纬度转换为一维的字符串(11位)，如果两个字符串越接近，那么则距离越近!
127.0.0.1:6379> geohash china:city beijing chongqi

1) "wx4fbxxfkeo"
2) "wm5xzrybtyo"
GEO底层的实现原理其实就是Zset !我们可以使用Zset命令来操作geo !
127.0.0.1:6379>ZRANGE china:city 0 -1 #查看地图中全部的元素
127.0.0.1:6379> zrem china:city beijing #移除指定元素

Hyperloglog

基数（不重复的元素）统计的算法，占用内存固定，2^64不同的元素只需要12KB的内存。比如网页的UV (一个人访问一个网站多次，但是还是算作一个人! )传统的方式，set保存用户的id，然后就可以统计set 中的元素数量作为标准判断!这个方式如果保存大量的用户id，就会比较麻烦!我们的目的是为了计数，而不是保存用户id ;hyperloglog 会有0.81%错误率!统计UV任务，可以忽略不计的!

PFadd PFCOUNT PFMERGE

127.0.0.1:6379> PFadd mykey a b c d e f g h i j # 创建第一组元素 mykey
127.0.0.1:6379>PFCOUNT mykey # 统计 mykey元素的基数数量

(integer) 10
127.0.0.1:6379> PFadd mykey2 i j z x c v b n m #创建第二组元素
127.0.0.1:6379> PFCOUNT mykey2

(integer) 9
127.0.0.1:6379> PFMERGE mykey3 mykey mykey2 #合并两组 mykey mykey2 => mykey3并集
127.0.0.1:6379> PFCOUNT mykey3 #看并集的数量!

(integer) 15

如果允许容错，那么一定可以使用Hyperloglog ! 如果不允许容错，就使用set或者自己的数据类型即可!

Bitmaps

位存储，0 1 0 1 0 1......统计用户信息，活跃，不活跃!登录、未登录!打卡，365打卡! Bitmaps位图，数据结构!都是操作二进制位来进行记录，就只有0和1两个状态!

使用bitmap来记录周一到周日的打卡!

周一∶1周二:0周三:0 周四:1 周五∶1 周六:0 周日:0

setbit

127.0.0.1:6379>setbit sign 0 1

127.0.0.1:6379>setbit sign 1 0
127.0.0.1:6379>setbit sign 2 0
127.0.0.1:6379>setbit sign 3 1
127.0.0.1:6379>setbit sign 4 1
127.0.0.1:6379>setbit sign 5 0
127.0.0.1:6379>setbit sign 6 0

查看某一天是否打卡

getbit

127.0.0.1:6379>getbit sign 6

统计操作，统计打卡的天数

bitcount

127.0.0.1:6379>bitcount sign

四、事务

Redis 中的事务是一组命令的集合，是 Redis 的最小执行单位。它可以保证一次执行多个命令，事务中的所有命令都会序列化、按顺序地执行。服务端在执行事务的过程中，不会被其他客户端发送来的命令请求打断。redis事务没有隔离级别的概念，不会出现脏读幻读之类的，所有的命令在事务中，并没有直接被执行!只有发起执行命令exec的时候才会执行，Redis单条命令式保存原子性的，但是事务不保证原子性!
redis的事务∶

开启事务（multi)
命令入队(.....)
执行事务（exec)

127.0.0.1:6379> multi #开启事务
127.0.0.1:6379> set k1 v1
127.0.0.1:6379> set k2 v2
127.0.0.1:6379>get k2
127.0.0.1:6379>set k3 v3
127.0.0.1:6379>exec #执行

放弃事务

127.0.0.1:6379> multi
127.0.0.1:6379> set k1 v1
127.0.0.1:6379> set k2 v2
127.0.0.1:6379>discard #取消事务，事务队列中的命令都不会执行

编译型异常（代码有问题!命令有错!)），事务中所有的命令都不会被执行!
127.0.0.1:6379> multi
127.0.0.1:6379>set k1 v1
127.0.0.1:6379> set k2 v2
127.0.0.1:6379> getset k3 #没有这个命令，命令错误
(error) ERR wrong number of arguments for 'getset' command

127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379>set k5 v5

QUEUED
127.0.0.1:6379>exec #运行报错
(error)EXECABORT Transaction discarded because of previous errors.

127.0.0.1:6379> get k5 #查看，队列中命令果然都没有执行
(nil)

运行时异常(1/0），如果事务队列中存在语法性，那么执行命令的时候，其他命令是可以正常执行的，错误命令抛出异常

127.0.0.1:6379>set k1 "v1"
127.0.0.1: 6379> multi
127.0.0.1:6379>incr k1 #字符串类型自增报错
127.0.0.1:6379>set k2 v2
127.0.0.1:6379> set k3 v3
127.0.0.1:6379>get k3
127.0.0.1:6379>exec #运行第一条命令抛出，会执行其他命令
1) (error)ERR value is not an integer or out of range

2)OK
3) OK

4) "v3"

乐观锁和悲观锁

悲观锁总是假设最坏的情况，认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改)，所以每次在获取资源操作的时候都会上锁，这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。

乐观锁总是假设最好的情况，认为共享资源每次被访问的时候不会出现问题，线程可以不停地执行，无需加锁也无需等待，只是在提交修改的时候去验证对应的资源（也就是数据）是否被其它线程修改了（具体方法可以使用版本号机制或 CAS 算法）。

redis监视测试 watch unwatch -----redis实现乐观锁

五、Jedis（使用Java来操作 Redis）

使用Java来操作 Redis，什么是Jedis？是Redis官方推荐的java连接开发工具!使用Java操作Redis 中间件!如果你要使用java操作redis，那么一定要对Jedis十分的熟悉!

1、导入对应的依赖

2、编码测试∶

连接数据库
操作命令
断开连接

连接redis，输出pong代表连接成功

再次理解事务

六、SpringBoot集成Redis

SpringBoot操作数据:spring-data jpa jdbc mongodb redis !SpringData也是和SpringBoot齐名的项目!说明︰在SpringBoot2.x之后，原来使用的jedis被替换为了lettuce?
jedis :采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用jedis pool连接池!更像BIO模式

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

整合测试

1、导入依赖

<!--操作redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2、配置连接

#配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379

3、测试

@SpringBootTest
class Redis02SpringbootApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void contextLoads() {
        // redisTemplate操作不同的数据类型，api和我们的指令是一样的
        // opsForvalue 操作字符串 类似string
        // opsForList 操作List 类似List
        // opsForset
        // opsForHash 
        // opsForzsetl 
        // opsForGeo
        // opsForHyperLogLog
//除了进本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务，和基本的CRUD
//获取redis的连接对象

//Redisconnection connection = redisTemplate.getconnectionFactory().getconnection ();
//connection.flushDb();
//connection.flushAll();
    redisTemplate.opsForvalue().set("mykey", "asdf");
    system.out.println(redisTemplate.opsForvalue().get("mykey"));
    }
}

七、自定义RedisTemplate

真实的开发一般使用json来传递对象，直接传递对象会报错，所有的对象需要序列化

@Component
@AllArgsConstructor
@NoArgsConstructorData
//在企业中，我们的所有pojo都会序列化
SpringBootpublic class User implements Serializable {
    private String name;
    private int age;
}

自定义redisTemplate

@Configuration
public class RedisConfig{
//自己定义一个RedisTemplate
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate (RedisconnectionFactory factory){
    //我们为了自己开发方便，一般直接使用<String, object>
    RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        // Json序列化配置
  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);
        //String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // Value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的Value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

RedisUtil封装工具类

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;

@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;
        }

    }

}

测试类

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class SpringbootRedisApplicationTests {

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

    @Autowired
    private RedisUtil redisUtil;
    
    @Test
    public void test1() {
        redisUtil.set("myKey","myValue");
        System.out.println(redisUtil.get("myKey"));
    }

}

八、Redis.conf详解

启动时通过配置文件来启动的

> redis-server xx/xx/redis.conf

单位

包含

网络

bind 127.0.0.1 #绑定的ip

protected-mode yes #保护模式，默认开启的

port 6379 #端口设置

通用GENERAL

daemonize yes #以守护进程的方式运行（后台运行），默认是no，需要我们自己开启为yes

logfile "" #日志的文件位置名，为空表示标准的输出

databases 16 #数据库的数量，默认是16个数据库
always-show-logo yes # 是否总是显示LoGo

快照

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

redis是内存数据库，如果没有持久化，那么数据断电及失!
#如果900s内，如果至少有一个1 key进行了修改，我们及进行持久化操作

save 900 1
#如果300s内，如果至少10 key进行了修改，我们及进行持久化操作

save 300 10
# 如果60s内，如果至少10000 key进行了修改，我们及进行持久化操作

save 60 10000
#我们之后学习持久化，会自己定义这个测试!

stop-writes-on-bgsave-error yes #持久化如果出错，是否还需要继续工作!
rdbcompression yes # 是否压缩rdb文件，需要消耗一些cpu资源!
rdbchecksum yes #保存rdb文件的时候，进行错误的检查校验!
dir./ #rdb文件保存的目录!

REPLICATION复制

我们后面讲解主从复制的，时候再进行讲解

SECURITY安全

#requirepas foobared 可以在这里设置redis的密码，默认是没有密码!

CLIENTS限制

maxclients 10000 #设置能连接上redis的最大客户端的数量
maxmemory <bytes> #redis 配置最大的内存容量
maxmemory-policy noeviction #内存到达上限之后的处理策略

1、volatile-lru:只对设置了过期时间的key进行LRU（默认值）

2、allkeys-lru :删除lru算法的key

3、volatile-random:随机删除即将过期key

4、allkeys-random:随机删除

5、volatile-ttl :删除即将过期的

6、noeviction :永不过期，返回错误

APPEND ONLY 模式aof配置

appendonly no #默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分所有的情况下，rdb完全够用!

appendfilename "appendonly.aof" #持久化的文件的名字

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

具体的配置，在 Redis持久化中去给大家详细详解!

本文链接：https://blog.csdn.net/m0_62639288/article/details/132724927

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

稀疏编码的数学基础与理论分析-程序员宅基地

文章浏览阅读290次，点赞8次，收藏10次。1.背景介绍稀疏编码是一种用于处理稀疏数据的编码技术，其主要应用于信息传输、存储和处理等领域。稀疏数据是指数据中大部分元素为零或近似于零的数据，例如文本、图像、音频、视频等。稀疏编码的核心思想是将稀疏数据表示为非零元素和它们对应的位置信息，从而减少存储空间和计算复杂度。稀疏编码的研究起源于1990年代，随着大数据时代的到来，稀疏编码技术的应用范围和影响力不断扩大。目前，稀疏编码已经成为计算...

EasyGBS国标流媒体服务器GB28181国标方案安装使用文档-程序员宅基地

文章浏览阅读217次。EasyGBS - GB28181 国标方案安装使用文档下载安装包下载，正式使用需商业授权, 功能一致在线演示在线API架构图EasySIPCMSSIP 中心信令服务, 单节点, 自带一个 Redis Server, 随 EasySIPCMS 自启动, 不需要手动运行EasySIPSMSSIP 流媒体服务, 根..._easygbs-windows-2.6.0-23042316使用文档

【Web】记录巅峰极客2023 BabyURL题目复现——Jackson原生链_原生jackson 反序列化链子-程序员宅基地

文章浏览阅读1.2k次，点赞27次，收藏7次。2023巅峰极客 BabyURL之前AliyunCTF Bypassit I这题考查了这样一条链子：其实就是Jackson的原生反序列化利用今天复现的这题也是大同小异，一起来整一下。_原生jackson 反序列化链子

一文搞懂SpringCloud，详解干货，做好笔记_spring cloud-程序员宅基地

文章浏览阅读734次，点赞9次，收藏7次。微服务架构简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目。这么多小服务，如何管理他们？(服务治理注册中心[服务注册发现剔除])这么多小服务，他们之间如何通讯？这么多小服务，客户端怎么访问他们？(网关)这么多小服务，一旦出现问题了，应该如何自处理？(容错)这么多小服务，一旦出现问题了，应该如何排错?(链路追踪)对于上面的问题，是任何一个微服务设计者都不能绕过去的，因此大部分的微服务产品都针对每一个问题提供了相应的组件来解决它们。_spring cloud

Js实现图片点击切换与轮播-程序员宅基地

文章浏览阅读5.9k次，点赞6次，收藏20次。Js实现图片点击切换与轮播图片点击切换<!DOCTYPE html><html> <head> <meta charset="UTF-8"> <title></title> <script type="text/ja..._点击图片进行轮播图切换

tensorflow-gpu版本安装教程（过程详细）_tensorflow gpu版本安装-程序员宅基地

文章浏览阅读10w+次，点赞245次，收藏1.5k次。在开始安装前，如果你的电脑装过tensorflow，请先把他们卸载干净，包括依赖的包（tensorflow-estimator、tensorboard、tensorflow、keras-applications、keras-preprocessing），不然后续安装了tensorflow-gpu可能会出现找不到cuda的问题。cuda、cudnn。..._tensorflow gpu版本安装

随便推点

物联网时代权限滥用漏洞的攻击及防御-程序员宅基地

文章浏览阅读243次。0x00 简介权限滥用漏洞一般归类于逻辑问题，是指服务端功能开放过多或权限限制不严格，导致攻击者可以通过直接或间接调用的方式达到攻击效果。随着物联网时代的到来，这种漏洞已经屡见不鲜，各种漏洞组合利用也是千奇百怪、五花八门，这里总结漏洞是为了更好地应对和预防，如有不妥之处还请业内人士多多指教。0x01 背景2014年4月，在比特币飞涨的时代某网站曾经..._使用物联网漏洞的使用者

Visual Odometry and Depth Calculation--Epipolar Geometry--Direct Method--PnP_normalized plane coordinates-程序员宅基地

文章浏览阅读786次。A. Epipolar geometry and triangulationThe epipolar geometry mainly adopts the feature point method, such as SIFT, SURF and ORB, etc. to obtain the feature points corresponding to two frames of images. As shown in Figure 1, let the first image be and th_normalized plane coordinates

开放信息抽取(OIE)系统（三）-- 第二代开放信息抽取系统(人工规则, rule-based, 先抽取关系)_语义角色增强的关系抽取-程序员宅基地

文章浏览阅读708次，点赞2次，收藏3次。开放信息抽取(OIE)系统（三）-- 第二代开放信息抽取系统(人工规则, rule-based, 先关系再实体)一.第二代开放信息抽取系统背景第一代开放信息抽取系统(Open Information Extraction， OIE， learning-based, 自学习, 先抽取实体)通常抽取大量冗余信息，为了消除这些冗余信息，诞生了第二代开放信息抽取系统。二.第二代开放信息抽取系统历史第二代开放信息抽取系统着眼于解决第一代系统的三大问题: 大量非信息性提取（即省略关键信息的提取）、_语义角色增强的关系抽取