redis6笔记

前提了解

1、解决功能性的问题：Java、Jsp、RDBMS、Tomcat、HTML、Linux、JDBC、SVN. 2、解决扩展性的问题：struts、Spring、SpringMVC、Hibernate、Mybatis 3、解决性能的问题：NoSQL、Java线程、Hadoop、Nginx、MQ、ElasticSearch

原子性：原子操作（不会被线程机制打断的操作）

i++:取值、赋值、

NoSQL数据库简介

NoSQL(NoSQL = Not Only sQL )，意即“不仅仅是sQL”，泛指非关系型的数据库。NoSQL不依赖业务逻辑方式存储，而以简单的key-value模式存储。因此大大的增加了数据库的扩展能力。

Redis简介

端口号：6379

默认有16个数据库，从0开始（默认0），切换命令（select 15）

Redis 使用的是单线程 + 多路 IO 复用技术：

多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用 select 和 poll 函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）。

串行 vs 多线程 + 锁（memcached） vs 单线程 + 多路 IO 复用 (Redis)**（与 Memcache 三点不同：支持多数据类型，支持持久化，单线程 + 多路 IO 复用） 。

类似于：

打开Redis

cd /usr/local/bin //切换到

redis-server /etc/redis.conf //设置为后台启动

redis-cli //启动redis

shutdown //关闭

常用五大数据类型

Redis键（key）

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

exists key 判断某个key是否存在

type key 查看你的 key是什么类型

del key 删除指定的 key数据

unlink key 根据value选择非阻塞删除（仅将keys 从 keyspace元数据中删除，真正的删除会在后续异步操作）

expire key 10 为给定的key设置过期时间

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

select 命令切换数据库

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

flushdb 清空当前库

flushall 通杀全部库

1.字符串（String）

概述

String 是 Redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。

String 类型是二进制安全的。意味着 Redis 的 string 可以包含任何数据。比如 jpg 图片或者序列化的对象。

String 类型是 Redis 最基本的数据类型，一个 Redis 中字符串 value 最多可以是 512M。

命令

set 添加键值对

get 查询对应键值

append 将给定的追加到原值的末尾

strlen 获得值的长度

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

---

incr 将key中储存的数字值增1 (只能对数字值操作,如果为空，新增值为1)

decr 将key中储存的数字值减1 (只能对数字值操作,如果为空，新增值为-1)

incrby / decrby <步长> 将key中储存的数字值增减。自定义步长。（原子操作，不会被线程机制打断的操作）

---

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

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

getrange <起始位置><结束位置> 获得值的范围，类似java中的substring，前包，后包

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

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

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

数据结构

String 的数据结构为简单动态字符串(Simple Dynamic String,缩写SDS)。是可以修改的字符串，内部结构实现上类似于Java的ArrayList!，采用预分配冗余空间的方式来减少内存的频繁分配。

如图中所示，内部为当前字符串实际分配的空间capacity一般要高于实际字符串长度len。当字符串长度小于1M时，扩容都是加倍现有的空间，如果超过1M，扩容时一次只会多扩1M的空间。需要注意的是字符串最大长度为512M。

---

2、列表（List）

概述

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

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

命令

lpush/rpush.... 从左边/右边插入一个或多个值。

lpop/rpop 从左边/右边吐出一个值。值在键在，值光键亡。

rpoplpush 从列表右边吐出一个值，插到列表左边。(key1最后一个放在key2第一个位置)

lrange 按照索引下标获得元素(从左到右) 例如查全部：lrange key1 0 -1

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

llen 获得列表长度

---

列表中每次插入值时，其他数值的索引都会发生改变

linsert before 在的后面插入插入值

lrem 从左边删除n个value(从左到右) lset 将列表key下标为index的值替换成value

数据结构

List的数据结构为快速链表quickList。

首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是ziplist，也即是压缩列表。它将所有的元素紧挨着一起存储，分配的是一块连续的内存。

当数据量比较多的时候才会改成quicklist。因为普通的链表需要的附加指针空间太大，会比较浪费空间。比如这个列表里存的只是int类型的数据，结构上还需要两个额外的指针prev和next。

Redis将链表和ziplist结合起来组成了quicklist。也就是将多个ziplist使用双向指针串起来使用。这样既满足了快速的插入删除性能，又不会出现太大的空间冗余。

---

3、集合（set）

概述

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

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

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

命令

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

smembers 取出该集合的所有值。

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

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

srem ... 删除集合中的某个元素。

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

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

---

smove value 把集合中一个值从一个集合移动到另一个集合

sinter 返回两个集合的交集元素。

sunion 返回两个集合的并集元素。

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

数据结构

set数据结构是dict字典，字典是用哈希表实现的。

Java中 Hashset的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。Redis的set结构也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。

4、哈希（Hash）

概述

Redis hash 是一个键值对集合。

Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。（类似Java里面的Map）

例如：用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息。

命令

hset 给集合中的键赋值 例如：hset user:1001 id 1

hget 从集合取出value hmset... 批量设置hash的值

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

hkeys 列出该hash集合的所有field。

hvals 列出该hash集合的所有value

---

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

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

---

数据结构

Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable。

---

5、有序集合（Zset）

概述

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

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

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

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

命令

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

zrange [WITHSCORES] 返回有序集key中，下标在之间的元素;带 WITHSCORES，可以让分数一起和值返回到结果集。

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

zrevrangebyscore key maxmin [withscores] [limit offset count] 同上，改为从大到小排列。

zincrby 为元素的score加上增量

zrem 删除该集合下，指定值的元素，

zcount 统计该集合，分数区间内的元素个数

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

数据结构

SortedSet(zset)是Redis提供的一个非常特别的数据结构，一方面它等价于Java的数据结构Map，可以给每一个元素value赋予一个权重score，另一方面它又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表。

zset底层使用了两个数据结构：

（1）hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。

（2）跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。

跳跃表

有序集合在生活中比较常见，例如根据成绩对学生排名，根据得分对玩家排名等。对于有序集合的底层实现，可以用数组、平衡树、链表等。数组不便元素的插入、删除；平衡树或红黑树虽然效率高但结构复杂；链表查询需要遍历所有效率低。Redis采用的是跳跃表，跳跃表效率堪比红黑树，实现远比红黑树简单。

例如：

从第⒉层开始，1节点比51节点小，向后比较。21节点比51节点小，继续向后比较，后面就是NULL了，所以从21节点向下到第1层 在第1层，41节点比51节点小，继续向后，61节点比51节点大，所以从41向下 在第0层，51节点为要查找的节点，节点被找到，共查找4次。

---

配置文件

修改成网络连接

vi /etc/redis.conf

---

Redis的发布和订阅

概述

Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。

Redis 客户端可以订阅任意数量的频道。

1、客户端可以订阅频道如下图：

2、当给这个频道发布消息后，消息就会发送给订阅的客户端：

命令

1、打开一个客户端订阅channel1：

SUBSCRIBE channel1

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

publish channel1 hello

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

新数据类型

Bitmaps

概述

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

Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作。

Bitmaps单独提供了一套命令， 所以在Redis中使用Bitmaps和使用字符串的方法不太相同。 可以把Bitmaps想象成一个以位为单位的数组， 数组的每个单元只能存储0和1， 数组的下标在Bitmaps中叫做偏移量。

命令

setbit 设置Bitmaps中某个偏移量的值(О或1)

getbit 获取Bitmaps 中某个偏移量的值

bitcount 统计偏移总数

bitop and(or/not/xor) [key...] bitop是一个复合操作，它可以做多个Bitmaps的and(交集)、or (并集）、 not(非）、xor(异或）操作并将结果保存在destkey 中。

HyperLogLog

在工作当中，我们经常会遇到与统计相关的功能需求，比如统计网站PV（PageView页面访问量），可以使用Redis的incr、incrby轻松实现。但像UV（UniqueVisitor独立访客）、独立IP数、搜索记录数等需要去重和计数的问题如何解决？这种求集合中不重复元素个数的问题称为基数问题。

概述

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

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

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

命令

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

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

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

Geospatial

概述

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

命令

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

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

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

georadius< longitude>radius m|km|ft/mi] 以给定的经纬度为中心，找出某一半径内的元素

---

所有的redis命令在ideal中都可以实现

mave配置

            redis.clients
            jedis
            3.3.0
 

模拟验证码发送

1、输入手机号，点击发送后随机生成6位数字码，2分钟有效 2、输入验证码，点击验证，返回成功或失败 3、每个手机号每天只能输入3次

package com.ch.jedis;
​
import redis.clients.jedis.Jedis;
​
import java.util.Random;
​
public class PhoneCode {
    public static void main(String[] args) {
        verifyCoide("18581463023");
​
//        testCode("18581463023","187871");
​
    }
    //生成6位的随机数字
    public static  String getCode(){
        Random random=new Random();
        String code="";
        for (int i=0;i<6;i++){
            int rand = random.nextInt(10);
            code+=rand;
        }
        return code;
    }
    //每个手机每天只能发送三次，验证码放到redis中，设置过期时间
    public static void verifyCoide(String phone){
        //连接redis
        Jedis jedis=new Jedis("192.168.111.100",6379);
        //拼接key
        //手机发送次数key
        String countKey="VerifyCode"+phone+":count";
        //验证码key
        String codeKey="VerifyCode"+phone+":code";
        //每个手机每天只能发送三次
        String s = jedis.get(codeKey);
        if(s==null){
            //没有发送次数，第一次发送，设置发送次数为一
            jedis.setex(countKey,24*60*60,"1");
        }else if(Integer.parseInt(s)<=2){
            //发送次数加1
            jedis.incr(countKey);
        } else if (Integer.parseInt(s)>2) {
            System.out.println("已经超过3次了");
            jedis.close();
            return;
        }
        //发送验证码放到redis里面
        String vcode=getCode();
        jedis.setex(codeKey,120,vcode);
        jedis.close();
    }
​
​
    //校验
​
    public  static void testCode(String phone,String code){
        //从redis中获取验证码
        Jedis jedis=new Jedis("192.168.111.100",6379);
        String codeKey="VerifyCode"+phone+":code";
        String redisCode = jedis.get(codeKey);
        if(redisCode.equals(code)){
            System.out.println("okk");
        }else {
            System.out.println("noo");
        }
        jedis.close();
    }
}

与SpringBoot整合

1、在pom中配置

        
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
            org.apache.commons
            commons-pool2
        

2、application.properties中的配置

#Redis服务器地址
spring.redis.host=192.168.111.100
#Redis 服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0)
#spring.redis.database=0
# 连接超时时间（毫秒)
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
​

3、写配置类

其实是固定写法（可能自动配置好了）

4、测试类

​

redis_事务

redis的事务定义

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

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

Multi、Exec、discard

Multi：开始 Exec：结束 discard：放弃组队

（能避免组队时的错误，但不能避免执行时的错误【错的就错，对的会执行】）

悲观锁

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

乐观锁

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

通过WATCH key [key …]

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

Redis事务三特性

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

没有隔离级别的概念 ：队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行。

不保证原子性 ：事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚 。

秒杀案例

ab测试工具的安装

yum install httpd-tools

使用：ab -n 1000 -c 100 http://192.168.74.100:8080/seckill

-n 请求次数 -c 并发次数

public class SecKill_redis {
​
    public static void main(String[] args) {
        Jedis jedis =new Jedis("192.168.44.168",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 连接redis
        Jedis jedis = new Jedis("192.168.74.100",6379);
        //通过连接池得到jedis对象
        JedisPool jedisPoolInstance = JedisPoolUtil.getJedisPoolInstance();
        Jedis jedis = jedisPoolInstance.getResource();
​
        //3 拼接key
        // 3.1 库存key
        String kcKey = "sk:"+prodid+":qt";
        // 3.2 秒杀成功用户key
        String 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 判断用户是否重复秒杀操作
        if(jedis.sismember(userKey, uid)) {
            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();
​
        //组队操作
        multi.decr(kcKey);
        multi.sadd(userKey,uid);
​
        //执行
        List