第二章常见的Redis场景设计笔记

客官°小女子只卖身不卖艺 2023-06-13 03:22 30阅读 0赞

# **一、String存储** #

## **1、String存储介绍** ##

**Key的设计注意事项：**

一般以业务功能模块： 比如购物车key: cart:001，表示1号用户的购物车，简短明了以主，节约内存。

**简单字符缓存：**

> set key value
> 
> get key

**结构体或对象的存储：**

> a）set user:1 value   //value为XML或Json格式
> 
> b）mset user:1:name deer user:1:age 18
> 
> c）mget user1:name user:1:age

## **2、String常见应用场景** ##

**计数功能（文章编号为001）：**

> incr article:001
> 
> get article:001

**各类场景下(单机或分布式)的标识号：**

> incrby serialNo 1000

**集群环境下的Session共享****：**

使用spring session与redis完成session共享

## **3、String实现分布式锁** ##

**3.1、锁的场景**

多任务环境下——多对一操作

有状态的资源——会不一样哦（有状态类）

**3.2、问题根源**

状态的变迁，需要时间，存在中间态；

在1+1+1=3还未得出结果前，状态还是1，但只是幻象；

其它任务读出幻象值1，是错误的

## **4、关于redis分布式锁的基础知识** ##

**4.1、缓存有效期**

redis中的数据，不一定都是持久化的；给定key设置的生存时间，当key过期时，它会被自动删除；

**4.2、SETNX 命令**

SETNX key value，将 key 的值设为 value ，当且仅当 key 不存在。若给定的 key 已经存在，则 SETNX 不做任何动作。SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。

**4.3、lua脚本**

轻量小巧的脚本语言，用于支持redis操作序列的原子性；

## **5、redis加解锁的正确姿势** ##

来自于redis作者antirez的总结归纳

### **5.1、加锁** ###

通过setnx向特定的key写入一个随机值，并同时设置失效时间，写值成功既加锁成功；

**注意点：**

![20191113151714668.png][]

### **5.2、解锁** ###

匹配随机值，删除redis上特定key数据，要保证获取数据、判断一致以及删除数据三个操作是原子的；

**执行如下lua脚本：**

if redis.call("get",KEYS[1]) == ARGV[1] then
    
        return redis.call("del",KEYS[1])
    
    else
    
        return 0
    
    End

## **6、代码示例** ##

代码入口，模拟售票系统出票：

@Api(value = "锁机制", description = "锁机制说明")
    @RestController
    public class LockController {
        private static long count = 20;//黄牛
        private CountDownLatch countDownLatch = new CountDownLatch(5);
        @Resource(name="redisLock")
        private Lock lock;
       @ApiOperation(value="售票")
        @RequestMapping(value = "/sale", method = RequestMethod.GET)
        public Long sale() throws InterruptedException {
            count = 20;
            countDownLatch = new CountDownLatch(5);
            System.out.println("-------共20张票，分五个窗口开售-------");
            new PlusThread().start();
            new PlusThread().start();
            new PlusThread().start();
            new PlusThread().start();
            new PlusThread().start();
            return count;
        }
        // 线程类模拟一个窗口买火车票
        public class PlusThread extends Thread {
            private int amount = 0;//抢多少张票
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始售票");
                countDownLatch.countDown();
                if (countDownLatch.getCount()==0){
                    System.out.println("----------售票结果------------------------------");
                }
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                while (count > 0) {
                    lock.lock();
                    try {
                        if (count > 0) {  //模拟卖票业务处理
                            amount++;
                            count--;
                        }
                    }finally{
                        lock.unlock();
                    }
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "售出"+ (amount) + "张票");
            }
        }
    }

**Redis锁代码实现：**

@Service
    public class RedisLock implements Lock {
       private static final String  KEY = "LOCK_KEY";
       @Resource
       private JedisConnectionFactory factory;
       private ThreadLocal<String> local = new ThreadLocal<>();
       
       @Override
       //阻塞式的加锁
       public void lock() {
          // TODO 1.尝试加锁
          if(tryLock()){
             return;
          }
          //TODO 2.加锁失败，当前任务休眠一段时间
          try {
             Thread.sleep(10);//性能浪费
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
          //3.递归调用，再次去抢锁
          lock();
       }
       @Override
       //阻塞式加锁,使用setNx命令返回OK的加锁成功，并生产随机值
       public boolean tryLock() {
          //产生随机值，标识本次锁编号
          String uuid = UUID.randomUUID().toString();
          Jedis jedis = (Jedis) factory.getConnection().getNativeConnection();
          /**
           * key:我们使用key来当锁
           * uuid:唯一标识，这个锁是我加的，属于我
           * NX：设入模式【SET_IF_NOT_EXIST】--仅当key不存在时，本语句的值才设入
           * PX：给key加有效期
           * 1000：有效时间为 1 秒
           */
          String ret = jedis.set(KEY, uuid,"NX","PX",1000);
          //设值成功--抢到了锁
          if("OK".equals(ret)){
             local.set(uuid);//抢锁成功，把锁标识号记录入本线程--- Threadlocal
             return true;
          }
          //key值里面有了，我的uuid未能设入进去，抢锁失败
          return false;
       }
       //正确解锁方式
       public void unlock() {
          //读取lua脚本
          String script = FileUtils.getScript("unlock.lua");
          //获取redis的原始连接
          Jedis jedis = (Jedis) factory.getConnection().getNativeConnection();
          //通过原始连接连接redis执行lua脚本
          jedis.eval(script, Arrays.asList(KEY), Arrays.asList(local.get()));
       }
       @Override
       public Condition newCondition() {
          return null;
       }
       @Override
       public boolean tryLock(long time, TimeUnit unit)throws InterruptedException {
          return false;
       }
       @Override
       public void lockInterruptibly() throws InterruptedException {
       }
    }

**Redis配置代码：**

@Configuration
    public class RedisConfig {
        @Bean
        public JedisPoolConfig jedisPoolConfig() {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(10);
            jedisPoolConfig.setMaxTotal(10000);
            return jedisPoolConfig;
        }
        @Bean
        public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig)  {
            JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
            jedisConnectionFactory.setHostName("192.168.42.111");
            jedisConnectionFactory.setPort(6379);
            jedisConnectionFactory.setPassword("12345678");
            jedisConnectionFactory.setUsePool(true);
            jedisConnectionFactory.setPoolConfig(jedisPoolConfig);
            return jedisConnectionFactory;
        }
    }

# **二、HASH存储数据** #

## **1、对象级别存储的2种方式** ##

> hmset user:3 name zhangsan age 18
> 
> hmset user:4 name lisi age 5

2、批量插入

> hmset user 3:name zhangsan 3:age 18 4:name lisi 4:age 5

**批量取值：**hmget user:3 name age  //返回三行：zhangsan 18

**判断****field****是否存在：**hexists user:3 name  //若存在返回1，不存在返回0

**获取所有****field****：**hkeys user

> 192.168.30.156:6379> hkeys user
> 
> 1) "3:name"
> 
> 2) "3:age"
> 
> 3) "4:name"
> 
> 4) "4:age"

**获取****user:2****所有****value****：**hvals user  //返回hankin 23 boy

**获取****user:2****所有****field****与****value****：**hgetall user  //name age sex hankin 23 boy值

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70][]

## **2、淘宝购物车** ##

**功能****：**

1）全选功能-获取所有该用户的所有购物车商品

2）商品数量-购物车图标上要显示购物车里商品的总数

3）删除-要能移除购物车里某个商品

4）增加或减少某个商品的数量

例如：userid: 1001

**如何设计实现？**

例如：用户1001的购物车添加了两个上商品 product:01、 product:02数量分别为1

> hmset cart:1001 product:01 1 product:02 1

指令说明：

当前登录用户ID号做为KEY，商品ID号为Field, 加入购物车数量为value，

> 192.168.30.156:6379> hmset cart:1001 product:01 1 product:02 1
> 
> OK
> 
> 192.168.30.156:6379> hgetall cart:1001
> 
> 1) "product:01"
> 
> 2) "1"
> 
> 3) "product:02"
> 
> 4) "1"

# **三、List场景-数据结构** #

## **1、如何利用List实现栈、队列(JAVA实现)** ##

### **1.1、使用LinkedList实现栈** ###

/**
     * 栈的功能：进栈、出栈、返回栈口元素……
     */
    public class ListStack {
        private LinkedList<Object> linkedList=new LinkedList<Object>();
        //1、构造方法
        public ListStack(){}
        //2、出栈
        public Object pop(){
            if(isEmpty()){
                throw new EmptyStackException();
            }
            return linkedList.removeFirst();
        }
        //3、进栈
        public void push(Object obj){ //注意o不要0的区别，不要写成0了
            linkedList.addFirst(obj);
        }
        //4、清空
        public void clear() {
            linkedList.clear();
        }
        //5、判断是否为空
        public boolean isEmpty(){
            return linkedList.isEmpty();
        }
        //6 将对象转换成字符串
        public String toString(){
            return linkedList.toString();
        }
        //7、返回栈口元素
        public Object peek(){
            if(isEmpty()){
                throw new EmptyStackException();
            }
            return linkedList.peekFirst();
        }
        public static void main(String[] args) {
            ListStack stack=new ListStack();
            //进栈
            stack.push("a");
            stack.push("b");
            //出栈
            System.out.println(stack.pop());
            //返回栈口元素
            System.out.println(stack.peek());
        }
    }

### **1.2、使用LinkedList实现队列** ###

/**
     * 队列的功能：队尾进，队首出
     */
    public class ListQueue {
        // 借助LinkedList 类中的方法实现队列
        private LinkedList<Object> linkedList = new LinkedList<Object>();
        // 1、构造方法
        public ListQueue() { }
        // 2、出列
        public Object get() {
            if (isEmpty()) {
                throw new EmptyStackException();
            }
            return linkedList.removeFirst();
        }
        // 3、进列
        public void put(Object obj) {
            linkedList.addLast(obj);
        }
        // 4、清空
        public void clear() {
            linkedList.clear();
        }
        // 5、返回队列首元素(不删除)
        public Object getTop() {
            if (isEmpty()) {
                throw new EmptyStackException();
            }
            return linkedList.peekFirst();
        }
        // 6、将对象转换成字符串
        public String toString() {
            return linkedList.toString();
        }
        // 7、判断队列是否为空
        public boolean isEmpty() {
            return linkedList.isEmpty();
        }
        public static void main(String[] args) {
            ListQueue mq = new ListQueue();
            // 进列
            mq.put("a");
            mq.put("b");
            mq.put("c");
            // 出列
            System.out.println(mq.get());
            System.out.println(mq.get());
            // 返回对首元素
            System.out.println(mq.getTop());
        }
    }

## **2、什么是阻塞队列？** ##

### **2.1、常见List场景：** ###

面试题：hankin的微信ID:004，他关注了CSDN，男子别输在说话上，如下图展示效果如何设计？

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1][]

### **2.2、设计如下：** ###

1) 比如：CSDN发布了一条消息ID为666

> lpush message:004 666

2）男子别输在说话上也发布了一条消息ID为777

> lpush message:004 777

3）那么上图图hankin的微信消息列表实现如下

> lrange message:004 0 5
> 
> 192.168.30.156:6379> lpush message:004 666
> 
> (integer) 1
> 
> 192.168.30.156:6379> lpush message:004 777
> 
> (integer) 2
> 
> 192.168.30.156:6379> lrange message:004 0 5
> 
> 1) "777"
> 
> 2) "666"

## **四、Set应用场景** ##

> 指令：sadd key member1 member2

微信有一个活动，活动ID为001，如何实现微信抽奖功能，基于Redis设计实现？

userId: 004

1）当hankin点击参与抽奖时，数据放入set集合

> 指令：sadd active:001 004

2)  开始抽奖2名中奖者（随机）

> 指令：srandmember active:001 2 或 spop act:001 2

2)  查看有多少用户参加了本次抽奖

> 指令：smembers active:001

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2][]

## **1、Set集合快速应用** ##

面试题目：朋友圈消息ID:008，微信点赞如何设计？

张三用户ID为userId:01

1）张三对消息mssageId008点赞啦

> sadd zan:008 userId:01

2)  张三取消了对消息008的点赞

> srem zan:008 userId:01

3）检查用户是否点过赞

> sismember zan:008 userId:01

4）获取消息mssageId008所有的点赞用户列表

> smembers zan:008

5）消息mssageId008的点赞数计算

> scard zan:008

## **2、Set集合特殊的操作指令** ##

setA=\{A,B,C\}  setB=\{B, C\}

1）集合与集合之间的交集

sinter setA setB－－>得到集合\{B,C\}

2)  集合与集合之间的并集

sunion setA setB －－>得到集合\{A,B,C\}

3）集合与集合之间的差集

> sdiff setA setB－－>得到集合\{A\}
> 
> 192.168.30.156:6379> sadd setA a b c
> 
> (integer) 3
> 
> 192.168.30.156:6379> sadd setB b c
> 
> (integer) 2
> 
> 192.168.30.156:6379> sinter setA setB
> 
> 1) "c"
> 
> 2) "b"
> 
> 192.168.30.156:6379> sunion setA setB
> 
> 1) "a"
> 
> 2) "b"
> 
> 3) "c"
> 
> 192.168.30.156:6379> sdiff setA setB
> 
> 1) "a"

### **3、Set集合特殊的操作指令应用场景** ###

**面试题目：如何实现微博的微关系设计？**

条件1）hankin关注的人

> sadd hankinCares jason,zacker,jone,kelven

条件2)  jason关注的人

> sadd jasonCares hankin,zacker,jone,bin

条件3)  zacker老师关注的人

> sadd zackerCares hankin,jason,jone

**计算1****：**hankin**和**jason**共同关注的人**

> sinter hankinCares jasonCares ，计算结果为 \{ hankin,zacker\}

**计算2****：****我关注的人也关注他(king老师)**

> sismember jasonCares jone
> 
> sismember zackerCares jone

计算3）我可能认识的人

> 192.168.30.156:6379> sdiff hankinCares jasonCares
> 
> 1) "jason,zacker,jone,kelven"

### **4、Zset有序集合** ###

常用于排行榜，如视频网站需要对用户上传视频做排行榜，或点赞数；与集合有联系，不能有重复的成员。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3][]

**Zset集合应用实战****：**

腾讯新闻话题榜Redis设计实现，以日期做为Key

1）点击话题

> zincrby topic:20191022 1 军嫂怒怼张馨予

2)  右侧排行实现，展示今日前9排名

> zrevrange  topic:20191022 0 20  withscores

3）统计近3日点击数据

> zunionstore topic:3day 3  topic:20191022  topic:20191021 topic:20191020

4) 展示近3日的排行前9名

> zrevrange topic:20191022-20191020 0 9 withscores

[20191113151714668.png]: https://img-blog.csdnimg.cn/20191113151714668.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191113152118580.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191113152502112.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191113152732942.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191113152841544.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70