Laughing_Xie

Redis笔记

什么是NoSQL

Not Only SQL 泛指非关系型数据库，传统的关系型数据库，很难应对web2.0时代(视频、音乐、个人信息)，尤其是超大规模的高并发的社区。在大数据环境下发展的十分迅速。Redis

关系型数据库：表格，行列存储

很多的数据类型用户的个人信息，社交网络，地理位置，这些数据类型的存储不需要一个固定的格式，不需要多余的操作就可以横向扩展的。Map其中一类使用键值对来控制，典型代表为Redis

NoSQL特点：

1.方便扩展，数据之间没有关系，很好扩展，可解耦

2.大数据量高性能（Redis 一秒写8w次，读取11w次，NoSQL的缓存是记录级，是一种细粒度的缓存，性能会比较高）

3.数据类型多样性！（不需要事先设计数据库，随取随用！）

5种常见数据类型和3种特殊数据类型 String,List,Set,Hash,Zset,geo,hyperloglog,bitmap

4.没有固定的查询语言，键值对存储，列存储，文档存储，图形数据库（社交关系），满足最终一致性CAP定理和BASE(异地多活，保证服务器不会宕机)

5.高性能、高可用，高可扩展

NoSQL四大分类

1.KV键值对: Redis、Redis+Tair、Redis+memecache

2.文档型数据库（bson格式和json一样）：

MongoDB(是一个基于分布式文件存储的数据库，C++编写，主要用来处理大量的文档)，是一个介入关系型数据库和非关系型数据库的中间产品，是非关系型数据库中功能最丰富，最像关系型数据库的；ConthDB；kv键值对，value为结构化数据；查询性能不高

3.列存储数据库：大数据里的 HBase,分布式文件系统；以列簇存储，将同一列数据存在一起

4.图关系数据库：不是存图形的，放的是关系，比如：朋友圈社交网络，广告推荐 Neo4j,infoGrid，最短路径寻址，N度关系查找等

Redis入门

Redis是什么？

Remote Dictionary Server ，即远程字典服务；

C语言编写的，支持网络，基于内存，可持久化的日志型Key-Value数据库，并提供多种语言的API,免费开源，结构化数据库。

Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave（主从同步）

能做什么？

1.内存存储、持久化，内存中是断电即失，可以持久化（RDB/AOF)

2.效率高，可以用于高速缓存

3.发布订阅系统

4.地图信息分析

5.计时器，计数器（浏览量）...

特性：多样数据类型，持久化，支持集群，事务...

推荐在Linux服务器上搭建，基于Linux

Windows安装

一般不用

Linux安装

1.下载安装包可在官网下载

获得安装包 redis-6.2.4.tar.gz

2.传到我们的home目录下

[root@centos7 eric]# ls
apache-tomcat-10.0.20         jdk-18_linux-x64_bin.rpm   redis-6.2.4.tar.gz
apache-tomcat-10.0.20.tar.gz  jdk-8u51-linux-x64.tar.gz  snakeGame.jar

3.解压redis安装包程序一般放在opt目录下先移动过去

[root@centos7 eric]# ls
apache-tomcat-10.0.20         jdk-18_linux-x64_bin.rpm   redis-6.2.4.tar.gz
apache-tomcat-10.0.20.tar.gz  jdk-8u51-linux-x64.tar.gz  snakeGame.jar
[root@centos7 eric]# mv redis-6.2.4.tar.gz /opt
[root@centos7 eric]# cd /opt
[root@centos7 opt]# ls
containerd  redis-6.2.4.tar.gz
[root@centos7 opt]#

tar -zxvf redis-6.2.4.tar.gz 解压

[root@centos7 opt]# tar -zxvf redis-6.2.4.tar.gz
redis-6.2.4/
redis-6.2.4/.github/
redis-6.2.4/.github/ISSUE_TEMPLATE/
redis-6.2.4/.github/ISSUE_TEMPLATE/bug_report.md
redis-6.2.4/.github/ISSUE_TEMPLATE/crash_report.md
redis-6.2.4/.github/ISSUE_TEMPLATE/feature_request.md

[root@centos7 opt]# ls
containerd  redis-6.2.4  redis-6.2.4.tar.gz
[root@centos7 opt]# ll
总用量 2408
drwx--x--x. 4 root root      28 4月  23 16:05 containerd
drwxrwxr-x. 7 root root    4096 6月   1 2021 redis-6.2.4
-rw-r--r--. 1 root root 2457940 4月  28 23:03 redis-6.2.4.tar.gz
[root@centos7 opt]#

进入解压后的文件可看到配置文件 redis.conf

[root@centos7 opt]# cd redis-6.2.4
[root@centos7 redis-6.2.4]# ls
00-RELEASENOTES  COPYING   MANIFESTO   runtest-cluster    src
BUGS             deps      README.md   runtest-moduleapi  tests
CONDUCT          INSTALL   redis.conf  runtest-sentinel   TLS.md
CONTRIBUTING     Makefile  runtest     sentinel.conf      utils

基本的环境安装

yum install gcc-c++

gcc -v 查看环境是否有问题

[root@centos7 redis-6.2.4]# gcc -v
使用内建 specs。
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/4.8.5/lto-wrapper
目标：x86_64-redhat-linux
配置为：../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-bootstrap --enable-shared --enable-threads=posix --enable-checking=release --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-linker-hash-style=gnu --enable-languages=c,c++,objc,obj-c++,java,fortran,ada,go,lto --enable-plugin --enable-initfini-array --disable-libgcj --with-isl=/builddir/build/BUILD/gcc-4.8.5-20150702/obj-x86_64-redhat-linux/isl-install --with-cloog=/builddir/build/BUILD/gcc-4.8.5-20150702/obj-x86_64-redhat-linux/cloog-install --enable-gnu-indirect-function --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux
线程模型：posix
gcc 版本 4.8.5 20150623 (Red Hat 4.8.5-44) (GCC)

执行 make命令会去把所有需要的文件配置上需要等待一会儿把所有东西下载完毕

可以make install 进行一个确认也可以不执行

[root@centos7 redis-6.2.4]# make install
cd src && make install
make[1]: 进入目录“/opt/redis-6.2.4/src”
    CC Makefile.dep
make[1]: 离开目录“/opt/redis-6.2.4/src”
make[1]: 进入目录“/opt/redis-6.2.4/src”

Hint: It's a good idea to run 'make test' ;)

    INSTALL redis-server
    INSTALL redis-benchmark
    INSTALL redis-cli
make[1]: 离开目录“/opt/redis-6.2.4/src”

redis默认安装路径 /usr/local/bin

[root@centos7 usr]# ls
bin  etc  games  include  lib  lib64  libexec  local  sbin  share  src  tmp
[root@centos7 usr]# cd local
[root@centos7 local]# ls
bin  docker  etc  games  include  lib  lib64  libexec  sbin  share  src
[root@centos7 local]# cd bin
[root@centos7 bin]# ls
redis-benchmark  redis-check-aof  redis-check-rdb  redis-cli  redis-sentinel  redis-server
[root@centos7 bin]# pwd
/usr/local/bin

将我们的redis配置文件进行拷贝到当前目录下 , 首先建一个目录

mkdir rconfig

cp /opt/redis-6.2.4/redis.conf rconfig

[root@centos7 bin]# mkdir rconfig
[root@centos7 bin]# cp /opt/redis-6.2.4/redis.conf rconfig
[root@centos7 bin]# cd rconfig
[root@centos7 rconfig]# ls
redis.conf
[root@centos7 rconfig]#

我们之后就用 rconfig 目录下的配置文件进行启动，就算出问题了以后还可以拷贝

redis 默认不是后台启动，需要修改配置文件为后台启动

view redis.conf 配置的daemonize 后台启动目前配置的是no 需要改为 yes

# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
# When Redis is supervised by upstart or systemd, this parameter has no impact.
daemonize no

# If you run Redis from upstart or

# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
# When Redis is supervised by upstart or systemd, this parameter has no impact.
daemonize yes

wq保存退出，通过指定的配置文件启动服务并ping 测试

[root@centos7 bin]# ls
rconfig          redis-check-aof  redis-cli       redis-server
redis-benchmark  redis-check-rdb  redis-sentinel
[root@centos7 bin]# pwd
/usr/local/bin
[root@centos7 bin]# redis-server rconfig/redis.conf

使用redis 客户端进行连接 redis-cli -p 6379

[root@centos7 bin]# redis-server rconfig/redis.conf
[root@centos7 bin]# ls
rconfig          redis-check-aof  redis-cli       redis-server
redis-benchmark  redis-check-rdb  redis-sentinel
[root@centos7 bin]# redis-cli -p 6379
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> set name eric
OK
127.0.0.1:6379> get name
"eric"
127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379>

查看redis 进程是否开启 ps -ef | grep redis

[root@centos7 /]# ps -ef | grep redis
root      24064      1  0 23:24 ?        00:00:00 redis-server 127.0.0.1:6379
root      24130  17727  0 23:26 pts/0    00:00:00 redis-cli -p 6379
root      24505  24443  0 23:31 pts/2    00:00:00 grep --color=auto redis
[root@centos7 /]#

如何关闭redis 服务？ shutdown 然后exit退出

127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379> shutdown
not connected> exit

再查看进程已无连接

root      24130  17727  0 23:26 pts/0    00:00:00 redis-cli -p 6379
root      24505  24443  0 23:31 pts/2    00:00:00 grep --color=auto redis
[root@centos7 /]# ps -ef | grep redis
root      24642  24443  0 23:33 pts/2    00:00:00 grep --color=auto redis
[root@centos7 /]#

可以使用单机多redis启动集群

测试性能

redis-benchmark 压力测试工具，官方自带

命令：

-h 指定服务器主机名默认127.0.0.1

-p 指定服务器端口默认6379

-s 指定服务器socket

-c 指定并发连接数默认 50

-n 指定请求书默认10000

-d 以字节的形式指定set/get 值的数据大小默认 3

-k 1=keep alive 0=reconnect

-r set/get/incr 使用随机key ,SADD 使用随机值

-P 通过管道传输请求

-q 强制退出redis, 仅显示query/sec 值

-csv 以CSV格式输出

-t 仅运行以逗号分割的测试命令列表

测试：100个并发连接每个并发10w个请求

redis-benchmark -h localhost -p 6379 -c 100 -n 100000

====== SET ======
  100000 requests completed in 1.03 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.900% <= 10.103 milliseconds (cumulative count 99900)
99.917% <= 24.111 milliseconds (cumulative count 99917)
100.000% <= 25.103 milliseconds (cumulative count 100000)

Summary:
  throughput summary: 96805.42 requests per second
  latency summary (msec):
          avg       min       p50       p95       p99       max
        0.746     0.400     0.711     0.967     1.095    24.591

100并发，每次写入3字节，10w请求1.03秒完成，只有一台服务器处理这些请求，单机性能

每秒处理96805.42个请求。

基础：

redis默认有16个数据库配置文件中可以看到相关说明，并且通过select 来选择使用哪个数据库

[root@centos7 bin]# cd rconfig
[root@centos7 rconfig]# ls
redis.conf
[root@centos7 rconfig]# vim redis.conf

# Set the number of databases. The default database is DB 0, you can select
# a different one on a per-connection basis using SELECT  where
# dbid is a number between 0 and 'databases'-1
databases 16

选择数据库，并查看大小

[root@centos7 bin]# redis-cli -p 6379
127.0.0.1:6379> select 0
OK
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> dbsize
(integer) 0
127.0.0.1:6379[1]> select 15
OK
127.0.0.1:6379[15]> select 16
(error) ERR DB index is out of range
127.0.0.1:6379[15]> set name eric
OK
127.0.0.1:6379[15]> dbsize
(integer) 1
127.0.0.1:6379[15]> get name
"eric"
127.0.0.1:6379[15]> keys *   #查看数据库所有的key
1) "name"
127.0.0.1:6379[15]> flushdb
OK
127.0.0.1:6379[15]> keys *
(empty array)

keys * 查看数据库所有的key

清除当前数据库： flushdb

127.0.0.1:6379[15]> select 0
OK
127.0.0.1:6379> keys *
1) "name"
2) "myhash"
3) "mylist"
4) "key:__rand_int__"
5) "counter:__rand_int__"
6) "age"

清除所有的数据库：flushall

127.0.0.1:6379> select 3
OK
127.0.0.1:6379[3]> keys *
(empty array)
127.0.0.1:6379[3]> flushall
OK
127.0.0.1:6379[3]> keys *
(empty array)
127.0.0.1:6379[3]> select 0
OK
127.0.0.1:6379> keys *
(empty array)

为什么redis端口号是6379 ？

6379是手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字。

Redis 是单线程的！（6.0版本以上，对外功能支持多线程，但其实内核处理部分依然是单线程的），基于内存操作，CPU不是Redis性能瓶颈，Redis的瓶颈是根据机器的内存和网络带宽，既然可以使用单线程来实现，就使用单线程。

Redis是C语言写的，官方提供的数据为10w+ 的QPS，完全不比Memecache差。

Redis为什么单线程还这么快？

1.误区：高性能的服务器一定是多线程的

2.误区：多线程（CPU会上下文切换）一定比单线程效率高

核心：redis将所有的数据全部放在内存中的，所以使用单线程去操作效率就是最高的（cpu上下文切换耗时），对于内存系统来说，如果没有上下文切换，效率就是最高的！多次读写都是在一个CPU上的，在内存情况下，这个就是最佳方案！

五大数据类型：String 、List 、 Set、 Hash、 Zset（有序集合）

三种特殊数据类型：geospatial（地理空间）、 hyperloglog 、 bitmaps（范围查询）

Redis-key

查看所有的key : keys *

检查key是否已经存在： exists +key

127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> set name lina
OK
127.0.0.1:6379> exists name
(integer) 1
127.0.0.1:6379> exists name1
(integer) 0

移除当前key 到指定的某个数据库中： move +key +dbNum

127.0.0.1:6379> set name lily
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> get name
"lily"
127.0.0.1:6379> move name 1
(integer) 1
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
1) "name"
127.0.0.1:6379[1]> get name
"lily"
127.0.0.1:6379[1]>

设置过期时间：expire +key +seconds

查看当前key的剩余时间：ttl +key

127.0.0.1:6379> expire name 10
(integer) 1
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> ttl name
(integer) 2
127.0.0.1:6379> ttl name
(integer) -2
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> keys *
1) "age"

查看当前key存储的内容的数据类型：type +key

删除某个key-value: del +key

127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> type name
string
127.0.0.1:6379> type age
string
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> del name
(integer) 1
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379>

String

追加内容：append +key +value (如果key不存在，则自动进行新增key-value操作)

计算value字符串长度：strlen +key

127.0.0.1:6379> set key1 v
OK
127.0.0.1:6379> get key1
"v"
127.0.0.1:6379> keys *
1) "key1"
127.0.0.1:6379> exists key1
(integer) 1
127.0.0.1:6379> append key1 "hello"   #append追加内容 
(integer) 6
127.0.0.1:6379> get key1
"vhello"
127.0.0.1:6379> append key1 123
(integer) 9
127.0.0.1:6379> get key1
"vhello123"
127.0.0.1:6379> strlen key1           #计算字符串长度
(integer) 9
127.0.0.1:6379> append key1 ",erichaha"
(integer) 18
127.0.0.1:6379> get key1
"vhello123,erichaha"
127.0.0.1:6379> append name zhangsan   #name这个key不存在，直接新建key 及value
(integer) 8
127.0.0.1:6379> keys *
1) "name"
2) "key1"
127.0.0.1:6379> get name
"zhangsan"
127.0.0.1:6379> strlen name
(integer) 8
127.0.0.1:6379>

自增 i++ 、自减 i-- 、设置步长 i+= 。

127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> get views              #设置浏览量初始值为 0
"0"
127.0.0.1:6379> incr views             #自增1 i++
(integer) 1
127.0.0.1:6379> get views
"1"
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> decr views              #自减1 i--
(integer) 1
127.0.0.1:6379> get views
"1"
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> get views
"2"
127.0.0.1:6379> incrby views 10         #设置步长为10 ，自增10，i+=10
(integer) 12
127.0.0.1:6379> get views
"12"
127.0.0.1:6379> incr views
(integer) 13
127.0.0.1:6379> decrby views 5          #设置步长为5，自减5，i-=5
(integer) 8
127.0.0.1:6379> get views
"8"

获取字符串范围：getrange + key +startIndex +endIndex (左右包含)

127.0.0.1:6379> set key1 "hello,world"
OK
127.0.0.1:6379> getrange key1 0 3     #[0~3]范围内的字符串
"hell"
127.0.0.1:6379> getrange key1 0 -1    #获取全部字符串
"hello,world"

替换指定位置开始的字符串！setrange + key +offset + value

127.0.0.1:6379> set key2 abcdefg
OK
127.0.0.1:6379> get key2
"abcdefg"
127.0.0.1:6379> setrange key2 1 xx       #从下标1开始，内容替换为xx
(integer) 7
127.0.0.1:6379> get key2
"axxdefg"
127.0.0.1:6379> setrange key2 3 xxx      #从下标3开始，内容替换为xxx
(integer) 7
127.0.0.1:6379> get key2
"axxxxxg"
127.0.0.1:6379> setrange key2 1 ***********
(integer) 12
127.0.0.1:6379> get key2
"a***********"

setex（set with expire）设置过期时间

如果不存在：setnx (set if not exist ）不存在再设置（在分布式锁中会常常使用）

127.0.0.1:6379> setex k3 30 "hello"    #设置过期时间30秒
OK
(integer) 19
127.0.0.1:6379> get k3
"hello"
127.0.0.1:6379> setnx key "redis"      #如果这个key存在则创建 内容"redis"
(integer) 1
127.0.0.1:6379> keys *
1) "key2"
2) "key1"
3) "key"
127.0.0.1:6379> ttl k3
(integer) -2
127.0.0.1:6379> setnx key "mongdb"    #因为这个key已经存在了所以设置不成功
(integer) 0
127.0.0.1:6379> get key
"redis"
127.0.0.1:6379>

mset 批量设置值

mget 批量获取值

msetnx 批量设置值，如果不存在再设置，是原子性操作

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3      #同时设置多个值
OK
127.0.0.1:6379> keys *
1) "k3"
2) "key2"
3) "key1"
4) "k1"
5) "key"
6) "k2"
127.0.0.1:6379> mget k1 k2 k3    #同时获取多个值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v1 k4 v4    #msetnx 是一个原子性操作，要么一起成功，要么一起失败
(integer) 0
127.0.0.1:6379> get k4
(nil)
127.0.0.1:6379>

设置对象：

set user:1 {name:zhangsan,age:18} 设置一个user:1 对象值为json字符串来保存一个对象

也可以用mset 来实现 mset user:1:name zhangsan user:1:age 18

这里的key 是： user:{id}:{field}

127.0.0.1:6379> set user:1 {name:zhangsan,age:18}
OK
127.0.0.1:6379> get user:1
"{name:zhangsan,age:18}"
127.0.0.1:6379> mset user:2:name zhangsan user:2:age 7 user:2:sex girl user:1:sex boy
OK
127.0.0.1:6379> keys *
 1) "user:2:name"
 2) "user:1"
 3) "user:2:age"
 4) "k1"
 5) "key1"
 6) "k2"
 7) "k3"
 8) "key2"
 9) "user:1:sex"
10) "user:2:sex"
11) "key"
127.0.0.1:6379> get user:1:name
(nil)
127.0.0.1:6379> get user:2:name
"zhangsan"
127.0.0.1:6379> get user:2:age
"7"
127.0.0.1:6379> get user:2:sex
"girl"
127.0.0.1:6379> get user:1:sex
"boy"
127.0.0.1:6379> get user:1
"{name:zhangsan,age:18}"

getset 先get一个值再设置

127.0.0.1:6379> getset db mysql      #如果不存在值，则返回nil
(nil)
127.0.0.1:6379> get db
"mysql"
127.0.0.1:6379> getset db redis      #如果存在值，获取原来的值，并设置新的值
"mysql"
127.0.0.1:6379> get db
"redis"

数据结构是相同的!

String类似的使用场景：value除了是字符串还可以是数字，计数器；统计多单位的数量；粉丝数；对象缓存存储；

List 列表

在redis里面，可以把list 模拟为栈（一个口子进出，先进后出）；队列(从一边进，另外一边出)；阻塞队列（可以从两边去取）。

所有的list命令都是以 l 开头的。

LPUSH（不区分大小写）：放入元素，将一个值或多个值放入列表的头部，从左边放进去

LRANGE ：获取区间内的元素，0号位为最新放进去的元素，（先进后出）

127.0.0.1:6379> lpush list one  
(integer) 1
127.0.0.1:6379> lpush list two
(integer) 2
127.0.0.1:6379> lpush list three
(integer) 3
127.0.0.1:6379> lrange list 0 -1     # 获取列表中所有的元素
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> lrange list 0 1     # 获取0到1号位的元素
1) "three"
2) "two"
127.0.0.1:6379> LPUSH lll a
(integer) 1
127.0.0.1:6379> LPUSH lll b
(integer) 2
127.0.0.1:6379> LRANGE lll 0 -1
1) "b"
2) "a"
127.0.0.1:6379>

rpush ：将元素放到列表的右边（尾部） lrange:获取list中的值

127.0.0.1:6379> RPUSH list right
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"
127.0.0.1:6379>

LPOP：移除，从左边弹出 + key +count 从左侧（头部）移除多个元素

RPOP：从右边弹出 +key +count 从右侧（尾部）移除多个元素

127.0.0.1:6379> LPOP list     # 移除列表的第一个元素
"three"
127.0.0.1:6379> RPOP list     # 移除列表的最后一个元素
"right"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
127.0.0.1:6379> lrange list 0 -1
1) "a"
2) "b"
3) "a"
4) "two"
5) "one"
6) "right"
127.0.0.1:6379> lpop list 2    # 从左侧弹出两个元素
1) "a"
2) "b"
127.0.0.1:6379> rpop list 2    # 从尾部弹出两个元素
1) "right"
2) "one"
127.0.0.1:6379> lrange list 0 -1
1) "a"
2) "two"

Lindex : 通过下标获取某个数据 +key +index

127.0.0.1:6379> lrange list 0 -1
1) "oneone"
2) "one"
3) "a"
4) "two"
5) "right"
6) "haha"
127.0.0.1:6379> lindex list 0    # 获取0号位上的数据
"oneone"
127.0.0.1:6379> Lindex list 1    # 获取1号位上的数据
"one"
127.0.0.1:6379>

Llen : 返回列表的长度 +key

127.0.0.1:6379> Llen list
(integer) 6
127.0.0.1:6379>

Lrem : 移除指定个数的值 +key +count +value

127.0.0.1:6379> lrem list 1  one  # 移除一个one 
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "oneone"
2) "a"
3) "two"
4) "right"
5) "haha"
127.0.0.1:6379> lpush list a
(integer) 6
127.0.0.1:6379> lrange list 0 -1
1) "a"
2) "oneone"
3) "a"
4) "two"
5) "right"
6) "haha"
127.0.0.1:6379> lrem list 2 a   # 移除两个 "a"
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "oneone"
2) "two"
3) "right"
4) "haha"
127.0.0.1:6379>

trim : 修剪，通过下标截断list 只要其中部分值 +key +start +end

127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "oneone"
3) "two"
4) "right"
5) "haha"
127.0.0.1:6379> ltrim list 1 2
OK
127.0.0.1:6379> lrange list 0 -1
1) "oneone"
2) "two"
127.0.0.1:6379>

rpoplpush :移除列表的最后一个元素，并将此元素从头部放入另一个列表（或者自身）

127.0.0.1:6379> lrange list 0 -1
1) "oneone"
2) "two"
127.0.0.1:6379> Rpush list right
(integer) 3
127.0.0.1:6379> lpush list one
(integer) 4
127.0.0.1:6379> rpoplpush list mylist
"right"
127.0.0.1:6379> lrange mylist 0 -1
1) "right"
127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "oneone"
3) "two"
127.0.0.1:6379> rpoplpush list list   # 将自己的末尾元素弹出 从头部再放入
"two"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
3) "oneone"
127.0.0.1:6379>

lset : 对列表某下标值进行赋值（更新当前下标的值），如果不存在会报错

127.0.0.1:6379> exists list
(integer) 0
127.0.0.1:6379> lset list 0 item
(error) ERR no such key
127.0.0.1:6379> lpush list value1
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "value1"
127.0.0.1:6379> lset list 0 item
OK
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
127.0.0.1:6379>

linsert : 将某个元素插入到列表中某个值的前面或者后面

127.0.0.1:6379> lpush list item2
(integer) 2
127.0.0.1:6379> linsert list before "item2" haha
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "haha"
2) "item2"
3) "item"
127.0.0.1:6379> linsert list after item2 world
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "haha"
2) "item2"
3) "world"
4) "item"
127.0.0.1:6379>

小结：实际上是一个链表，Node ,在前后都可以插入值；如果key不存在，创建新的链表。如果移除了所有值，空链表，代表不存在！；在两边插入或者改动值，效率最高！中间元素，相对来说效率会低一点。可用作消息队列(Lpush Rpop)，栈（Lpush Lpop）。

Set中的值是不能重复的（无序不重复集合，抽随机！）

命令都是s开头，

sadd +key+value 增加集合名及value

smembers +key 查看这个集合里面有哪些元素

sismember + key + value 判断某个值是否在集合中

127.0.0.1:6379> sadd myset "hello"
(integer) 1
127.0.0.1:6379> sadd myset 134
(integer) 1
127.0.0.1:6379> sadd myset "134"  #不允许重复，如果重复无法添加进去
(integer) 0
127.0.0.1:6379> smembers myset    #查看myset集合中有哪些元素
1) "134"
2) "hello"
127.0.0.1:6379> keys *
1) "myset"
127.0.0.1:6379> sismember myset 134  #查看这个元素是否在 这个key中
(integer) 1
127.0.0.1:6379> sismember myset 1344
(integer) 0

scard + key 获取集合中元素的个数

srem +key + value 移除某个集合中的某个元素

127.0.0.1:6379> sadd myset love
(integer) 1
127.0.0.1:6379> scard myset    #获取set集合中的内容元素的个数
(integer) 3
127.0.0.1:6379> srem myset "hello"  #移除set集合中某个元素
(integer) 1
127.0.0.1:6379> scard myset
(integer) 2
127.0.0.1:6379> sismember myset "hello"
(integer) 0
127.0.0.1:6379> smembers myset
1) "134"
2) "love"
127.0.0.1:6379>

srandmember +key 随机抽选出一个元素

srandmember +key +count 随机抽取多个数量的元素

127.0.0.1:6379> scard myset
(integer) 5
127.0.0.1:6379> smembers myset
1) "1"
2) "134"
3) "eric"
4) "love"
5) "56"
127.0.0.1:6379> srandmember myset
"56"
127.0.0.1:6379> srandmember myset      # 随机抽取一个元素
"love" 
127.0.0.1:6379> srandmember myset
"134"
127.0.0.1:6379> srandmember myset  2   # 随机抽取指定个数的元素
1) "eric"
2) "love"
127.0.0.1:6379> srandmember myset  2
1) "love"
2) "56"
127.0.0.1:6379> srandmember myset  3
1) "love"
2) "1"
3) "56"
127.0.0.1:6379> srandmember myset  3
1) "eric"
2) "love"
3) "1"

随机删除一些set集合中的元素

spop + key +count 可随机删除多个元素

127.0.0.1:6379> smembers myset
1) "134"
2) "love"
3) "eric"
4) "1"
5) "56"
127.0.0.1:6379> spop myset               # 随机弹出一个元素
"eric"
127.0.0.1:6379> spop myset
"1"
127.0.0.1:6379> smembers myset
1) "134"
2) "love"
3) "56"
1) "134"
2) "56"
127.0.0.1:6379> spop myset 2            # 随机弹出两个元素
1) "134"
2) "56"
127.0.0.1:6379> smembers myset            
1) "love"
127.0.0.1:6379>

将一个指定的值移动到另外一个set集合中！

127.0.0.1:6379> keys *
1) "myset2"
2) "myset"
127.0.0.1:6379> smembers myset
1) "eric"
2) "world"
3) "hello"
127.0.0.1:6379> smembers myset2
1) "lala"
2) "haha"
127.0.0.1:6379> smove myset myset2 hello    # 将myset集合中的hello元素移动到myset2中
(integer) 1
127.0.0.1:6379> smembers myset
1) "eric"
2) "world"
127.0.0.1:6379> smembers myset2
1) "lala"
2) "hello"
3) "haha"
127.0.0.1:6379> sadd myset lala        
(integer) 1
127.0.0.1:6379> smove myset myset2 lala     # 如果目标集合中已经有元素了，依然移除成功，但是                                 
(integer) 1
127.0.0.1:6379> smembers myset              # 目标集合不可重复特性依然生效
1) "eric"
2) "world"
127.0.0.1:6379> smembers myset2
1) "lala"
2) "hello"
3) "haha"
127.0.0.1:6379>

微博、B站共同关注！（交集）

数字集合类： - 差集 - 交集 - 并集

sdiff +key1 +key2 ：key1集合同key2集合比较，与key2集合不同的元素有哪些（差集）

sinter +key1 +key2 ： key1集合与key2集合比较，交集有哪些元素（交集）

sunion +key1 +key2 ：key1集合与key2集合的并集，重复元素不展示（并集）

127.0.0.1:6379> sadd key1 a
(integer) 1
127.0.0.1:6379> sadd key1 b
(integer) 1
127.0.0.1:6379> sadd key1 c
(integer) 1
127.0.0.1:6379> sadd key2 c
(integer) 1
127.0.0.1:6379> sadd key2 d
(integer) 1
127.0.0.1:6379> sadd key2 e
(integer) 1
127.0.0.1:6379> sdiff key1 key2      # 已key1集合同key2比较，那几个元素与key2集合不同（差集）
1) "a"
2) "b"
127.0.0.1:6379> sinter key1 key2    # key1集合与key2集合 的交集
1) "c"
127.0.0.1:6379> sunion key1 key2    # key1集合与key2集合 的并集（重复元素去重）并集
1) "c"
2) "b"
3) "e"
4) "a"
5) "d"
127.0.0.1:6379>

微博，用户将所有关注的人放在一个set集合中！将它的粉丝也放在一个集合中！

共同关注，共同爱好，二度好友，推荐好友！

Hash(哈希）本质上与String类型没太大区别，还是一个简单的key-value 结构

Map集合，key-map 这个值是一个map集合！命令是h开头

hset +key +< field +value> 设置一个map名及里面的key-value

hget +key +< field +value> 获取一个map名里面的某个key的value

hmset +key +< field +value>+< field +value>..... 批量设置map集合里面的key-value

hmget +key +field +field +field ...... 批量获取map集合里面的各个字段的value

127.0.0.1:6379> hset myhash field name      # 添加map的key-v 
(integer) 1
127.0.0.1:6379> hget myhash field           # 获取myhash 里面 field字段的值  
"name"
127.0.0.1:6379> hset myhash name eric 
(integer) 1
127.0.0.1:6379> hget myhash name
"eric"
127.0.0.1:6379> hset myhash age 18
(integer) 1
127.0.0.1:6379> hget myhash age
"18"
127.0.0.1:6379> hmset myhash score 18 sex girl   # 批量设置hash 里面 k-v k-v
OK
127.0.0.1:6379> hmget myhash name age score sex  # 批量获取hash 里面 k k k k 对应的值
1) "eric"
2) "18"
3) "18"
4) "girl"
127.0.0.1:6379>

hgetall +key 获取 hash表里面map的所有内容 k-v

127.0.0.1:6379> hmset myhash score 18 sex girl
OK
127.0.0.1:6379> hmget myhash name age score sex
1) "eric"
2) "18"
3) "18"
4) "girl"
127.0.0.1:6379> hgetall myhash   # 获取所有元素内容 k-v 键值对方式展现
 1) "field"
 2) "name"
 3) "name"
 4) "eric"
 5) "age"
 6) "18"
 7) "score"
 8) "18"
 9) "sex"
10) "girl"
127.0.0.1:6379>

hdel +key +field .... 删除hash表中的 map里面的一个k-v 或者多个k-v

127.0.0.1:6379> hdel myhash field
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "name"
2) "eric"
3) "age"
4) "18"
5) "score"
6) "18"
7) "sex"
8) "girl"
127.0.0.1:6379> hdel myhash name age
(integer) 2
127.0.0.1:6379> hgetall myhash
1) "score"
2) "18"
3) "sex"
4) "girl"
127.0.0.1:6379>

hlen + key 获取哈希表的字段数量

127.0.0.1:6379> hmset myhash field1 hello field2 world
OK
127.0.0.1:6379> hgetall myhash
1) "score"
2) "18"
3) "sex"
4) "girl"
5) "field1"
6) "hello"
7) "field2"
8) "world"
127.0.0.1:6379> hlen myhash
(integer) 4
127.0.0.1:6379>

hexists +key +field 判断hash表的map里面是否包含某个字段

hkeys +key 获取map中的所有key

hvals +key 获取map中的所有value

127.0.0.1:6379> hgetall myhash
1) "score"
2) "18"
3) "sex"
4) "girl"
5) "field1"
6) "hello"
7) "field2"
8) "world"
127.0.0.1:6379> hlen myhash                 # 获取长度
(integer) 4
127.0.0.1:6379> hexists myhash field1       # 是否含有某个字段
(integer) 1
127.0.0.1:6379> hexists myhash field3
(integer) 0
127.0.0.1:6379> hkeys myhash                # 展示所有的key
1) "score"
2) "sex"
3) "field1"
4) "field2"
127.0.0.1:6379> hvals myhash                # 展示所有的value
1) "18"
2) "girl"
3) "hello"
4) "world"
127.0.0.1:6379>

hincrby +key +field + num 某个字段的value 自增多少

hsetnx +key +field +value 如果某个字段不存在，进行set操作，存在则不set

127.0.0.1:6379> hset myhash field3 5
(integer) 1
127.0.0.1:6379> hincrby myhash field3  1         # 自增1
(integer) 6
127.0.0.1:6379> hincrby myhash field3 -1         # 自增-1
(integer) 5
127.0.0.1:6379> hsetnx myhash field4 hehe        # 如果字段不存在 set操作
(integer) 1
127.0.0.1:6379> hsetnx myhash field4 lala        # 存在 则set无效
(integer) 0
127.0.0.1:6379> hincrby myhash field3 2          # 自增2
(integer) 7
127.0.0.1:6379> hgetall myhash
 1) "score"
 2) "18"
 3) "sex"
 4) "girl"
 5) "field1"
 6) "hello"
 7) "field2"
 8) "world"
 9) "field3"
10) "7"
11) "field4"
12) "hehe"
127.0.0.1:6379> hincrby myhash field3          # 自增后面必须加步长
(error) ERR wrong number of arguments for 'hincrby' command
127.0.0.1:6379>

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

hset +objectName: num +... 设置对象的属性及值

hget +objectName:num + k 获取对象的某个属性的value

hmget +objectName:num + k +k +k ...... 批量获取对象的属性的value

127.0.0.1:6379> hset user:1 name eric age 25 score 100  # 设置对象的属性及value
(integer) 3
127.0.0.1:6379> hget user:1 name                       # 获取其中某个属性的值
"eric"
127.0.0.1:6379> hmget user:1 name age score            # 批量获取属性的值
1) "eric"
2) "25"
3) "100"
127.0.0.1:6379>

Zset （有序集合）

在set的基础上，增加了一个值，中间加了一score 标识位，可用于排序

set +key +score +value

zadd + key +score +value +score +value 添加多个值并含有排序所用的数字

zrange +key + 0 -1 获取某个zset里面的所有元素

127.0.0.1:6379> zadd myzset 1 one                 # 添加一个值 含有排序所用的值
(integer) 1
127.0.0.1:6379> zadd myzset 2 two
(integer) 1
127.0.0.1:6379> zadd myzset 3 three 4 four        # 添加多个值
(integer) 2
127.0.0.1:6379> zrange myzset 0 -1                # 获取所有的元素
1) "one"
2) "two"
3) "three"
4) "four"
127.0.0.1:6379>

排序：

zrangebyscore + key +min +max (从负无穷到正无穷) 最小值到最大值之间

127.0.0.1:6379> zadd salary 1500 lina
(integer) 1
127.0.0.1:6379> zadd salary 3000 lily
(integer) 1
127.0.0.1:6379> zadd salary 4500 tom
(integer) 1
127.0.0.1:6379> zrangebyscore salary -inf +inf
1) "lina"
2) "lily"
3) "tom"
127.0.0.1:6379> zadd salary 500 oscar
(integer) 1
127.0.0.1:6379> zrange salary 0 -1
1) "oscar"
2) "lina"
3) "lily"
4) "tom"
127.0.0.1:6379> zrangebyscore salary -inf +inf withscores  # 可以带上 score 一起展示
1) "oscar"
2) "500"
3) "lina"
4) "1500"
5) "lily"
6) "3000"
7) "tom"
8) "4500"
127.0.0.1:6379> zrangebyscore salary -inf 2500 withscores  # 指定scaore范围
1) "oscar"
2) "500"
3) "lina"
4) "1500"
127.0.0.1:6379> zadd salary 500 oscar    # 会自动去重 如果score 和 元素名 一致
(integer) 0
127.0.0.1:6379> zrangebyscore salary -inf +inf withscores   # 升序展示所有元素及scores
1) "oscar"
2) "500"
3) "lily"
4) "3000"
5) "tom"
6) "4500"
127.0.0.1:6379> zrevrange salary 0 -1 withscores       # 降序展示所有元素及scores
1) "tom"
2) "4500"
3) "lily"
4) "3000"
5) "oscar"
6) "500"
127.0.0.1:6379>

移除某元素

zrem + key + value

zcard + key 获取有序集合中的元素个数

zrevrange +key 0 -1 从高到低降序展示

zrevrange +key 0 -1 withscores 从高到低降序展示并展示 scores

zcount +key +min +max 计算score 在某个区间的元素的个数

zcard +key 计算集合中所有的元素的个数

127.0.0.1:6379> zrange salary 0 -1
1) "oscar"
2) "lina"
3) "lily"
4) "tom"
127.0.0.1:6379> zrem salary lina           # 移除lina这个元素
(integer) 1
127.0.0.1:6379> zrange salary 0 -1
1) "oscar"
2) "lily"
3) "tom"
127.0.0.1:6379> zcard salary             # 集合中所有的元素个数
(integer) 3
127.0.0.1:6379> zcount salary 100  1000  # 计算满足在此区间内的元素个数
(integer) 1
127.0.0.1:6379> zadd zset 1 hello
(integer) 1
127.0.0.1:6379> zadd zset 2 world
(integer) 1
127.0.0.1:6379> zadd zset 3 haha
(integer) 1
127.0.0.1:6379> zcount zset 1 3
(integer) 3
127.0.0.1:6379> zcount zset 1 2
(integer) 2
127.0.0.1:6379> zrevrange salary 0 -1   # 从高到低 降序展示
1) "tom"
2) "lily"
3) "oscar"
127.0.0.1:6379> zrevrange salary 0 -1 withscores   # 带有score展示
1) "tom"
2) "4500"
3) "lily"
4) "3000"
5) "oscar"
6) "500"
127.0.0.1:6379> zcard salary              # 查看有多少个元素
(integer) 3

set的排序版，可存储成绩、薪资，可带权重来进行判断，对不同信息进行赋值1 2 3 ，根据数据量、粉丝数等信息进行排序展示排行榜。

三种特殊类型

geospatial 地理位置

定位、附近的人、打车距离计算？Redis 的 Geo 在Redis 3.2 版本已经有了，可以推算地理位置信息，两地之间的距离，附近的人

共有6个命令

GEOADD GEODIST GEOHASH GEOPOS GEORADIUS GEORADIUSBYMEMBER

geoadd 添加位置（经度，纬度，名称）南极北极无法添加，一般都会下载城市数据，通过java程序一次性导入

127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing   # 添加key 为城市
(integer) 1
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 chognqing 114.05 22.52 shengzheng
(integer) 2
127.0.0.1:6379> geoadd china:city 120.16 30.24 hangzhou  108.96 34.26 xian # 添加多个
(integer) 2
127.0.0.1:6379>

geopos 从key里面获取指定城市的经度纬度

获得当前定位：一定是一个坐标值！

127.0.0.1:6379> keys *
1) "zset"
2) "china:city"
127.0.0.1:6379> geopos china:city beijing
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"
127.0.0.1:6379> geopos china:city chongqing
1) 1) "106.49999767541885376"
   2) "29.52999957900659211"

计算两人之间的距离！直线距离

geodist :返回两个给定位置之间的距离

m 表示单位为米 km 千米 mi 英里 ft 英尺

127.0.0.1:6379> geodist china:city beijing hangzhou   #默认距离 米
"1127337.7813"
127.0.0.1:6379> geodist china:city beijing hangzhou km
"1127.3378"
127.0.0.1:6379>

我附近的人？（获得所有附近的人的地址，定位！）通过半径来查询！

georadius - 以给定的经纬度为中心，找出某一半径内的元素，且可显示距离、经纬度、符合条件的数据的数量

127.0.0.1:6379> georadius china:city 110 30 1000 km  # 以此位置为中心，半径1000km内的城市
1) "chongqing"
2) "xian"
3) "shenzheng"
4) "hangzhou"
127.0.0.1:6379> georadius china:city 110 30 500 km # 此集合中，此位置半径500km内的城市
1) "chongqing"
2) "xian"
127.0.0.1:6379> georadius china:city 110 30 500 km withdist # 显示直线距离
1) 1) "chongqing"
   2) "341.9374"
2) 1) "xian"
   2) "483.8340"
127.0.0.1:6379> georadius china:city 110 30 500 km withcoord # 显示符合条件的城市的经纬度
1) 1) "chongqing"
   2) 1) "106.49999767541885376"
      2) "29.52999957900659211"
2) 1) "xian"
   2) 1) "108.96000176668167114"
      2) "34.25999964418929977"
127.0.0.1:6379> georadius china:city 110 30 500 km withdist withcoord count 1 # 限制显示的数量为1
1) 1) "chongqing"
   2) "341.9374"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"

georadiusbymember 基于给定的元素来寻找周围符合条件的元素

127.0.0.1:6379> georadiusbymember china:city hangzhou 500 km
1) "hangzhou"

geohash 返回一个或多个位置元素的geohash表示

如果两个字符串越接近，距离越近

127.0.0.1:6379> geohash china:city beijing chongqing
1) "wx4fbxxfke0"
2) "wm5xzrybty0"

GEO底层的实现原理其实就是Zset ! 可以使用zset命令来操作GEO

127.0.0.1:6379> zrange china:city  0 -1
1) "chongqing"
2) "xian"
3) "shenzheng"
4) "hangzhou"
5) "beijing"

hyperloglog : 用来做基数统计的算法！

优点：占用内存固定12kb 如果从内存角度来比较 Hyperloglog首选

什么是基数？不重复的元素，拥有相等的对应的关系的个数

A { 1,35,5,7,8,3} B{1,3,5,7,8}

例如：数据集A和B 之间对比，不重复的元素的数量，叫做基数，可以接受误差

例子：网页UV 一个人访问一个网站多次，但是还是算作一个人

传统的方式用set保存用户的id,就可以统计set中元素数量作为标准判断！这个方式如果保存大量的用户id就会比较麻烦！目的是为了计数而不是为了保存用户id;

有0.81%的错误率。

pfadd +key +elements 添加或创建数据

pfcount + key 统计基数

pfmerge +targetKey +sourceKey1 +sourceKey2 将两组元素合并到新的key中并会去重

127.0.0.1:6379> pfadd mykey a b c d e f g h i j  # 创建第一组元素
(integer) 1
127.0.0.1:6379> pfcount mykey                   # 统计mykey中基数数量
(integer) 10
127.0.0.1:6379> pfadd mykey2 i j z x c v        
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 6
127.0.0.1:6379> pfmerge mykey3 mykey mykey2     # 合并两组元素 为mykey3 
OK
127.0.0.1:6379> pfcount mykey3                 # 查看并集的数量，去重
(integer) 13
127.0.0.1:6379> pfadd mykey1 a b c d d d
(integer) 1
127.0.0.1:6379> pfcount mykey1               # mykey1的基数数量为4 
(integer) 4
127.0.0.1:6379> pfadd mykey1 e f             # 继续添加两个不重复元素
(integer) 1
127.0.0.1:6379> pfcount mykey1
(integer) 6
127.0.0.1:6379>

如果允许容错，一定可以使用Hyperloglog！

Bitmaps 位存储

统计用户信息，活跃、不活跃，登录、未登录，打卡，365打卡！只有两个状态的，都可以使用Bitmaps，都是操作二进制位来进行记录，就只有0和1两个状态！通过位运算来表示元素对应的值，365天=365bit 1字节=8bit

setbit +key +offset +value

127.0.0.1:6379> setbit sign 0 1             # 打卡记录，周一打卡
(integer) 0
127.0.0.1:6379> setbit sign 1 0             # 打卡记录，周二未打卡
(integer) 0
127.0.0.1:6379> setbit sign 2 1             # 打卡记录，周二打卡
(integer) 0
127.0.0.1:6379> setbit sign 3 0
(integer) 0
127.0.0.1:6379> setbit sign 4 2
(error) ERR bit is not an integer or out of range
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 0
(integer) 0
127.0.0.1:6379> setbit sign 6 1
(integer) 0

使用bitmap 周一到周日的打卡！周一：1 周二：0 周三：1 周四：0 周五：1 周六：0周日：1

查看某一天是否打卡

getbit +key +offset 获取信息

127.0.0.1:6379> getbit sign 3      # 查看 周四打卡情况
(integer) 0
127.0.0.1:6379> getbit sign 2      # 查看 周三打卡情况
(integer) 1
127.0.0.1:6379>

统计操作：统计打卡天数

127.0.0.1:6379> bitcount sign   # 统计 值为1的数据，这周的打卡记录
(integer) 4

bitcount +key [start , end]

就是bitcount的start和end是字节（byte）数，而bitmap存储数据的时候是按位（bit）存储的，而1byte=8bit，所以bitmapcount sign 0 0，实际上是统计了bitmap的offect前8位为1的数量

127.0.0.1:6379> bitcount sign 0 0
(integer) 5
127.0.0.1:6379> bitcount sign
(integer) 6

事务（不保证原子性！没有隔离级别的概念，所有的命令在事务中并没有直接被执行，只有发起执行命令的时候才会执行）

Redis单条命令是保证原子性的，但是事务不保证原子性！

Redis事务本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程中，会像队列一样，按照顺序执行！

一次性、顺序性、排他性（不允许别人干扰）执行一系列的命令！Exec

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

redis的事务：

- 开启事务（multi）

- 命令入队（.......）

- 执行事务（exec）

正常执行事务！

127.0.0.1:6379> multi                      # 开启事务
OK
127.0.0.1:6379(TX)> set k1 v1              # 命令入队列
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2                # 命令入队列
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> exec                  # 执行
1) OK
2) OK
3) "v2"
4) OK
127.0.0.1:6379>                         # 执行完毕

执行完毕。

放弃事务：discard取消

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v3
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> discard         # 放弃事务，事务队列中命令都不会被执行！
OK
127.0.0.1:6379> get k4
(nil)
127.0.0.1:6379>

编译型异常（命令有错！），事务中所有的命令都不会被执行！

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k v
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> getset k3   # 错误命令
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> set k5 v5
QUEUED
127.0.0.1:6379(TX)> exec                 # 执行事务报错
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k5       # 所有的命令都不会被标错
(nil)

运行时异常（例：1/0），事务队列中存在语法性错误，执行命令的时候，错误命令抛出异常，其他命令可以正常执行！（redis事务无原子性，mysql则是要么都执行成功，要么都执行失败）

127.0.0.1:6379> set k1 aaa
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incr k1            # 对字符串进行自增1 命令没问题 但是运行会报错
QUEUED
127.0.0.1:6379(TX)> set k2 2
QUEUED
127.0.0.1:6379(TX)> set k3 3
QUEUED
127.0.0.1:6379(TX)> get k3
QUEUED
127.0.0.1:6379(TX)> exec
1) (error) ERR value is not an integer or out of range   #执行事务 这个命令报错 其他命令成功
2) OK
3) OK
4) "3"
127.0.0.1:6379> get k2                # 获得执行后的结果 
"2"
127.0.0.1:6379> get k3
"3"

Redis用乐观锁监控（Watch）

悲观锁：认为什么时候都会出问题，无论做什么都加锁

乐观锁：很乐观，认为什么时候都不会出问题，所以不会加锁！更新数据的时候去判断在此期间是否有人修改过这个数据，获取version,更新的时候比较version ,CAS的原理。

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

再开一个客户连接redis，用于测试多线程修改值，使用watch可以当做redis的乐观锁操作！相当于mysql的获取version

[root@centos7 bin]# redis-cli -p 6379
127.0.0.1:6379> keys *
1) "out"
2) "money"



[root@centos7 bin]# ps -ef |grep redis
root       2254      1  0 16:33 ?        00:00:13 redis-server 127.0.0.1:6379
root       2265   2186  0 16:34 pts/1    00:00:00 redis-cli -p 6379
root       6668   6627  0 22:46 pts/2    00:00:00 redis-cli -p 6379
root       6690   2126  0 22:46 pts/0    00:00:00 grep --color=auto redis

127.0.0.1:6379> keys *
1) "out"
2) "money"
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> watch money             # 监视 money
OK
127.0.0.1:6379> multi                  # 开启事务
OK
127.0.0.1:6379(TX)> decrby money 50
QUEUED
127.0.0.1:6379(TX)> exec        # 在执行之前 另外一个cli端/线程 进行了修改money 
(nil)
127.0.0.1:6379> get money      # 执行结果为 nil ,因为被修改了导致事务执行失败
"101"
127.0.0.1:6379>

事务执行执行，对money进行修改

127.0.0.1:6379> get money
"100"
127.0.0.1:6379> set money 101
OK

这种情况下，如果事务执行失败，需要先解锁，再重新进行监视，获取最新的值，再进行事务操作

unwatch

127.0.0.1:6379> unwatch                # 进行解锁 取消监视
OK
127.0.0.1:6379> watch money            # 重新加锁，进行监视
OK
127.0.0.1:6379> multi                 # 再次开启事务
OK
127.0.0.1:6379(TX)> decrby money 20
QUEUED
127.0.0.1:6379(TX)> exec     #比对监视的值，是否有变化，有变化就会失败，没有变化就执行成功
1) (integer) 81

Jedis

使用java来操作Redis，Jedis是Redis官方推荐的java连接开发工具！使用java操作Redis中间件。（目前用springboot集成了）。

测试：

1、建立空项目，加入maven moudle

2、导入依赖


    
        
        
            redis.clients
            jedis
            4.2.3
        
        
        
            com.alibaba
            fastjson
            1.2.28

3、编码测试：连接、操作、断开

新建Jedis对象，可空参，可传参创建，此处指定地址及端口建立

public Jedis(String host, int port) {
        this.commandObjects = new CommandObjects();
        this.db = 0;
        this.transaction = null;
        this.isInMulti = false;
        this.isInWatch = false;
        this.pipeline = null;
        this.dataSource = null;
        this.connection = new Connection(host, port);

可能连接不上远端redis

服务器上的地址可能无法连接，需要进入redis.conf文件，先注释掉：bind 127.0.0.1 再修改保护yes 为 no protected-mode no

放行6379端口并重启防火墙

[root@centos7 rconfig]# firewall-cmd --zone=public --add-port=6379/tcp --permanent
success
[root@centos7 rconfig]# systemctl restart firewalld

本地连接测试：

public class TestPing {
    public static void main(String[] args) {
        //2.new Jedis 对象 此处以本地连接为例
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        //jedis所有的命令 就是之前学的redis命令 在java里都是一个一个的方法
        System.out.println(jedis.ping());
        System.out.println("清空数据："+jedis.flushDB());
        System.out.println("判断值是否存在"+jedis.exists("username"));
        System.out.println("新增键值对"+jedis.set("username","eric"));
        System.out.println("新增键值对"+jedis.set("password","123456"));
        //所有的键
        Set keys = jedis.keys("*");
        System.out.println(keys);
        //删除
        jedis.del("password");
        //判断是否存在
        System.out.println(jedis.exists("password"));
        System.out.println("查看所存储的值的类型:"+jedis.type("username"));
        System.out.println("随机返回key空间的一个:"+jedis.randomKey());
        System.out.println("重命名key:"+jedis.rename("username","name"));
        System.out.println("获取值:"+jedis.get("name"));
        System.out.println("按索引查询:"+jedis.select(0));
        System.out.println("返回当前数据库key的数目："+jedis.dbSize());
        System.out.println("删除所有数据库中的所有key:"+jedis.flushAll());

    }
}

常用的API

String List Set Hash Zset Geopatial Hyperloglog Bitmap

public class TestJedis {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        System.out.println("增加多个值："+jedis.mset("key","v","k2","v2","k3","v3","k4","v4"));
        System.out.println("获取多个值："+jedis.mget("key","k2"));
        System.out.println("删除多个键值对："+jedis.del("k4","k3"));
        jedis.flushDB();
        //不存在再设置，分布式锁
        System.out.println(jedis.setnx("key1","value"));
        System.out.println(jedis.setnx("key2","value2"));
        System.out.println(jedis.setnx("key3","value3"));
        System.out.println(jedis.get("key2"));
        //新增键值对，并设置过期时间
        System.out.println(jedis.setex("k",4,"v"));
        System.out.println(jedis.get("k"));
     /*   try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        System.out.println(jedis.get("k"));
        System.out.println("===========添加一个list=============");
        jedis.lpush("collections","ArrayList","vector","stack","haha");
        jedis.lpush("collections","tree");
        System.out.println("collections的所有内容："+jedis.lrange("collections",0,-1));
        System.out.println("collections的内容："+jedis.lrange("collections",0,3));
        System.out.println("collections左边出栈："+jedis.lpop("collections"));
        System.out.println("collections截取3个："+jedis.ltrim("collections",0,2));
        System.out.println("collections的所有内容："+jedis.lrange("collections",0,-1));
        jedis.lpush("list","2","0","0","3","9","200");
        System.out.println(jedis.lrange("list", 0, -1));
        List sortList = jedis.sort("list");
        System.out.println("排序后："+sortList);
    }
}

事务：

//事务
public class TextTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        jsonObject.put("name","lily");
        jsonObject.put("age","18");
        //开启事务
        Transaction multi = jedis.multi();
        String s = jsonObject.toString();
        System.out.println("json串数据为："+s);
        //模拟监控
        jedis.watch("s");
        try {
            multi.set("user",s);
            multi.set("user1",s);
            //模拟失败
           // int i = 1/0;
            multi.exec();
        } catch (Exception e) {
            //如果失败有异常，放弃事务
            multi.discard();
            e.printStackTrace();
        }finally {
            System.out.println(jedis.get("user"));
            System.out.println(jedis.get("user1"));
            //执行完毕，关闭连接
            jedis.close();
        }
    }
}

SpringBoot整合

SpringBoot操作数据：都放在spring-data里的 jpa jdbc mongodb redis

SpringData也是和SpringBoot齐名的项目

在SpringBoot2.x之后，在依赖的底层，之前的Jedis 被替换成了lettuce


      io.lettuce
      lettuce-core
      5.3.5.RELEASE

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

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

新增springboot类型的模块，加上web/data Redis/DevTools/Lombok/spring Configuration Processor

@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate") //我们可以自己定义一个redisTemplate来替换这个默认的 此注解代表 如果没有这个template则自动生效
	public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
//默认的RedisTemplate 没有过多的设置，redis 对象都是需要序列化！
//两个泛型 都是Object 类型，后面使用需要强制转换
		RedisTemplate template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean //y由于String是最常使用的类型，所以单独提出来了一个bean
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

// RedisConnectionFactory 是个接口，共有两个实现类一个是 JedisConnectionFactory 源码down下来会发现很多类其实是不存在的，并没有生效

public class JedisConnectionFactory implements InitializingBean, DisposableBean, RedisConnectionFactory {

	private final static Log log = LogFactory.getLog(JedisConnectionFactory.class);
	private static final ExceptionTranslationStrategy EXCEPTION_TRANSLATION = new PassThroughExceptionTranslationStrategy(
			JedisConverters.exceptionConverter());

	private final JedisClientConfiguration clientConfiguration;
	private @Nullable JedisShardInfo shardInfo;
	private boolean providedShardInfo = false;
	private @Nullable Pool pool;
	private boolean convertPipelineAndTxResults = true;
	private RedisStandaloneConfiguration standaloneConfig = new RedisStandaloneConfiguration("localhost",
			Protocol.DEFAULT_PORT);

另一个实现类 LettuceConnectionFactory 类是生效的

public class LettuceConnectionFactory
		implements InitializingBean, DisposableBean, RedisConnectionFactory, ReactiveRedisConnectionFactory {

	private static final ExceptionTranslationStrategy EXCEPTION_TRANSLATION = new PassThroughExceptionTranslationStrategy(
			LettuceConverters.exceptionConverter());

	private final Log log = LogFactory.getLog(getClass());
	private final LettuceClientConfiguration clientConfiguration;

	private @Nullable AbstractRedisClient client;
	private @Nullable LettuceConnectionProvider connectionProvider;
	private @Nullable LettuceConnectionProvider reactiveConnectionProvider;
	private boolean validateConnection = false;
	private boolean shareNativeConnection = true;
	private boolean eagerInitialization = false;
	private @Nullable SharedConnection connection;
	private @Nullable SharedConnection reactiveConnection;
	private @Nullable LettucePool pool;
	/** Synchronization monitor for the shared Connection */

1.导入依赖 2.配置连接 3.使用

         
            org.springframework.boot
            spring-boot-starter-data-redis

所以，在进行配置的时候，用的Leuce 下面的连接池

# 配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
# spring.redis.cluster.nodes= 配置集群节点

@SpringBootTest
class Redis02SpringbootApplicationTests {
    //将自带的模板进行注入 使用
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
       // opsForValue() 操作字符串类似String 类型
        //opsForList() 操作list类型
        //opsForSet() opsForHash() opsForGeo() opsForZSet() opsForHyperLogLog
        //redisTemplate.opsForList().leftPop()
        //常用的方法，直接通过redisTemplate来操作，比如事务，执行，取消

        //去操作关于数据库的连接 获取连接对象
        /*RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushDb();
        connection.flushAll();*/
        redisTemplate.opsForValue().set("mykey","helloWorld");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }
}

RedisTemplate 模板对象有默认的序列化配置

public class RedisTemplate extends RedisAccessor implements RedisOperations, BeanClassLoaderAware {

	private boolean enableTransactionSupport = false;
	private boolean exposeConnection = false;
	private boolean initialized = false;
	private boolean enableDefaultSerializer = true;
	private @Nullable RedisSerializer defaultSerializer;
	private @Nullable ClassLoader classLoader;

	@SuppressWarnings("rawtypes") private @Nullable RedisSerializer keySerializer = null;
	@SuppressWarnings("rawtypes") private @Nullable RedisSerializer valueSerializer = null;
	@SuppressWarnings("rawtypes") private @Nullable RedisSerializer hashKeySerializer = null;
	@SuppressWarnings("rawtypes") private @Nullable RedisSerializer hashValueSerializer = null;
	private RedisSerializer stringSerializer = RedisSerializer.string();

如果没有自定义序列化方式，会报错

 //测试没有序列化
    @Test
    public  void test() throws JsonProcessingException {
        User lily = new User("lily", 18);
        //jackson帮忙序列化 变成json
        String jsonLily = new ObjectMapper().writeValueAsString(lily);
        System.out.println("jackson方式："+jsonLily);
        //fastJson
        System.out.println("fastJson转换方式："+JSON.toJSONString(lily));
        redisTemplate.opsForValue().set("user",jsonLily);
        System.out.println(redisTemplate.opsForValue().get("user"));
        //{"name":"lily","age":18}
        //如果不转换直接传对象进来
        redisTemplate.opsForValue().set("user1",lily);
        System.out.println(redisTemplate.opsForValue().get("user1"));
    }

关于对象的保存，需要序列化以后才可以正常传输

默认序列化方式为JDK序列化，这个时候我们可能会使用Json来序列化，需要自己定义配置类才行

boolean defaultUsed = false;

		if (defaultSerializer == null) {

			defaultSerializer = new JdkSerializationRedisSerializer(
					classLoader != null ? classLoader : this.getClass().getClassLoader());
		}

		if (enableDefaultSerializer) {

如果用默认的，中文内容可能会有问题，此时可以在配置包里面加上redis配置类，参照原有的redisTemplate方式，写一个配置类，

@Configuration
public class RedisConfig {
    //编写我们自己的reidsTemplate
    @Bean
    //@ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate template = new RedisTemplate<>();

  //自定义的序列化方式


        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

}

里面的参数默认用的jdk的序列化以Jackson 的序列化对象为例

完整自定义配置模板

//固定模板
@Configuration
public class RedisConfig {
    //编写我们自己的reidsTemplate 将原有的方式改为方便使用
    @Bean
    //@ConditionalOnMissingBean(name = "redisTemplate")
    @SuppressWarnings("all") //跳过所有检查
    public RedisTemplate redisTemplate1(RedisConnectionFactory factory)
            throws UnknownHostException {
        //一般方便 直接使用
        RedisTemplate template = new RedisTemplate();
        //默认连接工厂
        template.setConnectionFactory(factory);
        //可以new jackson的redis序列化对象  自定义的jason序列化配置 用json去解析任意的对象
        Jackson2JsonRedisSerializer

Redis笔记

你可能感兴趣的:(java基础知识点,数据库,java)