第三章 Redis设计实战笔记

逃离我推掉我的手 2023-06-13 03:22 3阅读 0赞

# **一、基于Redis设计的投票网站实战** #

## **1、应用场景实战** ##

文章投票功能模块需求

*  用户可以发表文章,发表时默认给自己的文章投了一票
 *  用户在查看网站时可以按评分进行排列查看
 *  用户也可以按照文章发布时间进行排序
 *  为节约内存，一篇文章发表后，7天内可以投票,7天过后就不能再投票了
 *  为防止同一用户多次投票，用户只能给一篇文章投一次票

## **2、关系数据库设计** ##

文章基本信息表 t\_article

article\_id  title  content post\_time user\_id

文章票数与分值表 t\_vote\_data

article\_id  votes  scores

文章投票详表 t\_vote\_details

article\_id  vote\_time  user\_id

## **3、应用场景Redis实现** ##

投票网站应用场景会使用到的Redis相关指令如下：

HASH类型命令：

> hset  hincrBy  hgetAll   expire

SET集合命令：

> sadd  smembers

ZSET集合命令：

> zadd   zscore  zincrby  zrevrange

## **4、redis的Key设计思路** ##

Key-Value键值对：比如set key value

key的设计：一般以业务、功能模块或表名开头，后跟主键（或能表示数据唯一性的值）

例子：用户模块，其中用户ID 001，用户名称hankin，那么Key如何设计？

set user:001:name hankin

key为 user:001:name

## **5、记录已投票用户，防重投** ##

已对002文章投票过的用户，使用SET存储（无序，不能重复）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70][]

## **6、记录文章分值** ##

使用ZSET记录文章投票分数，和按文章发布的时间戳（有序列，不能重复）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1][]

## **7、Redis缓存设计实战** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2][]

## **8、缓存数据变化** ##

1）004号用户对文章article:002投了1张票，文章的评分增加了400

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3][]

2）004号用户对article:002文章投票后，会被追加到已投票用户名单里

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4][]

## **9、代码环节** ##

代码参考：redis-vote模块，git地址：[https://gitee.com/hankin\_chj/redis-platform.git][https_gitee.com_hankin_chj_redis-platform.git]

业务接口方法：

/**
     * 业务接口方法
     */
    public interface RedisArticleService {
         public String postArticle(String title, String content, String link, String userId);
         public Map<String, String> hgetAll(String key);
         public void articleVote(String userId, String articleId);
         public String hget(String key, String votes);
         public List<Map<String,String>> getArticles(int page, String order);
    }

**文章发布代码：**

/**
    * 文章发布使用redis技术
    */
    @Service
    public class RedisArticleServiceImpl implements RedisArticleService {
       @Resource
       private JedisUtils jedis;
       /**
       * 文章提交发布
       * @param title 标题  内容  链接  用户ID
       * @return 文章的ID
       */
       @Override
       public String postArticle(String title, String content, String link, String userId) {
          //article:001
            String articleId = String.valueOf(jedis.incr("article:")); // articleId=1
            //投票键： voted:
            String voted = "voted:" + articleId;
            jedis.sadd(voted, userId);
            jedis.expire(voted, Constants.ONE_WEEK_IN_SECONDS);
            long now = System.currentTimeMillis() / 1000;
            String article = "article:" + articleId;
            HashMap<String,String> articleData = new HashMap<String,String>();
            articleData.put("title", title);
            articleData.put("link", link);
            articleData.put("user", userId);
            articleData.put("now", String.valueOf(now));
            articleData.put("votes", "1");
            jedis.hmset(article, articleData);
            jedis.zadd("score:info", now + Constants.VOTE_SCORE, article);
            jedis.zadd("time:", now, article);
            return articleId;
       }
       /**
       * 文章投票
       * @param  userId 用户ID 文章ID（article:001）  //001
       */
       @Override
       public void articleVote(String userId, String article) {
          //计算投票截止时间
            long cutoff = (System.currentTimeMillis() / 1000) - Constants.ONE_WEEK_IN_SECONDS;
            //检查是否还可以对文章进行投票,如果该文章的发布时间比截止时间小，则已过期，不能进行投票
            if (jedis.zscore("time:", article) < cutoff){
                return;
            }
           //获取文章主键id
            String articleId = article.substring(article.indexOf(':') + 1); article:1    1
            if (jedis.sadd("voted:" + articleId, userId) == 1) {
                jedis.zincrby("score:info", Constants.VOTE_SCORE, article);//分值加400
                jedis.hincrBy(article, "votes", 1l);//投票数加1
            }
       }
       /**
       * 文章列表查询（分页）
       * @return redis查询结果
       */
       @Override
       public List<Map<String, String>> getArticles(int page, String key) {
            int start = (page - 1) * Constants.ARTICLES_PER_PAGE;
            int end = start + Constants.ARTICLES_PER_PAGE - 1;
            //倒序查询出投票数最高的文章，zset有序集合，分值递减
            Set<String> ids = jedis.zrevrange(key, start, end); 
            List<Map<String,String>> articles = new ArrayList<Map<String,String>>();
            for (String id : ids){
                Map<String,String> articleData = jedis.hgetAll(id);
                articleData.put("id", id);
                articles.add(articleData);
           }
           return articles;
       } 
       @Override
       public String hget(String key, String feild) {
          return jedis.hget(key,feild);
       }
       @Override
       public Map<String, String> hgetAll(String key) {
          return jedis.hgetAll(key);
       }
    }

**Redis业务测试用例代码：**

/**
    * Redis业务测试用例
    */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
    public class TestRedisArticle {
       @Resource(name = "redisArticleServiceImpl")
       private RedisArticleService redisArticleService;
       /**
       * 测试用例：用户发布文章
       */
       @Test
       public void apostArticle() {
          String userId = "001"; //用户ID 001
          String title = "The road to west";
          String content = "About body and mental health";
          String link = "www.xx.com";
          //发布文章，返回文章ID
            String articleId = redisArticleService.postArticle(title, content, link, userId);
            System.out.println("刚发布了一篇文章，文章ID为: " + articleId);
            System.out.println("文章所有属性值内容如下:");
            Map<String,String> articleData = redisArticleService.hgetAll("article:" + articleId);
            for (Map.Entry<String,String> entry : articleData.entrySet()){
                System.out.println("  " + entry.getKey() + ": " + entry.getValue());
            }
            System.out.println();   
       }
       /**
       * 测试用例：用户对文章投票
       */
       @Test
       public void barticleVote(){
          String userId = "002";
          String articleId = "1";
            System.out.println("开始对文章"+"article:" + articleId+"进行投票啦~~~~~");
            //cang用户给James的文章投票
            redisArticleService.articleVote(userId, "article:" + articleId);//article:1
            //投票完后，查询当前文章的投票数votes
            String votes = redisArticleService.hget("article:" + articleId, "votes");
            System.out.println("article:" + articleId+"这篇文章的投票数从redis查出来结果为: " + votes);
       }
       /**
       * 测试用例：获取文章列表并打印出来
       */
       @Test
       public void cgetArticles(){
          int page = 1;
          String key = "score:info";
            System.out.println("查询当前的文章列表集合为：");
            List<Map<String,String>> articles = redisArticleService.getArticles(page,key);
            for (Map<String,String> article : articles){
                System.out.println("  id: " + article.get("id"));
                for (Map.Entry<String,String> entry : article.entrySet()){
                    if (entry.getKey().equals("id")){
                        continue;
                    }
                    System.out.println("    " + entry.getKey() + ": " + entry.getValue());
                }
            }
       }
    }

# **二、Redis+Lua限流实战** #

## **1、LUA语言介绍** ##

LUA脚本语言是C开发的，类似存储过程

**使用LUA脚本的好处****：**

*  减少网络开销，在Lua脚本中可以把多个命令放在同一个脚本中运行。
 *  原子操作，redis会将整个脚本作为一个整体执行，中间不会被其他命令插入。换句话说，编写脚本的过程中无需担心会出现竞态条件。
 *  复用性，客户端发送的脚本会永远存储在redis中，这意味着其他客户端可以复用这一脚本来完成同样的逻辑。

## **2、LUA编译器安装** ##

Lua在linux中的安装

到官网下载lua的tar.gz的源码包

> wget http://www.lua.org/ftp/lua-5.3.5.tar.gz .
> 
> tar -zxvf lua-5.3.0.tar.gz

进入解压的目录：

> cd lua-5.2.0
> 
> make linux
> 
> make install

如果报错，说找不到readline/readline.h, 可以通过yum命令安装

> yum -y install libtermcap-devel ncurses-devel libevent-devel readline-devel

安装完以后再make linux  / make install

最后，直接输入 lua命令即可进入lua的控制台

![20191113154615950.png][]

## **3、LUA基本语法** ##

Lua基本语法  print（“hello  world”）

*  单行注释   --
 *  多行注释--\[\[  --\]\]
 *  Lua关键字

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5][]

## **4、LUA数据类型** ##

Lua是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。

Lua中有8个基本类型分别为：nil、boolean、number、string、userdata、function、thread和table。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 6][]

## **5、LUA例子** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 7][]

6379>eval "return redis.call('get',KEYS\[1\])" 1 name   //eval+脚本+KEYS\[1\]+键个数+键

语法：eval script numkeys key \[key ...\]

## **6、LUA执行流程** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 8][]

## **7、Lua脚本的管理** ##

1）./redis-cli -h 192.168.30.156 -a 12345678 script load "$(cat ipCount.lua)"

将LUA脚本内容加载到redis，得到返回的sha1值："d5bc13bea8aed72e12308acacc65ee725fe3a187"

![20191113154950693.png][]

输出随机数：evalsha d5bc13bea8aed72e12308acacc65ee725fe3a187 1 192.168.30.156 5 2

2）script exists xxxx  //检查sha1值的LUA脚本是否加载到redis中，返回1已加载成功。

> 192.168.30.156:6379> script exists d5bc13bea8aed72e12308acacc65ee725fe3a187
> 
> 1) (integer) 1

3）script flush //清空加载的lua脚本内容

4）script kill  //杀掉正在执行的LUA脚本，比如LUA比较耗时阻塞

![20191113155024912.png][]

## **8、什么是限流** ##

### **8.1、什么是限流？** ###

在大数据量高并发访问时，经常会出现服务或接口面对暴涨的请求而不可用的情况，甚至引发连锁反映导致整个系统崩溃。此时你需要使用的技术手段之一就是限流，当请求达到一定的并发数或速率，就进行等待、排队、降级、拒绝服务等。在限流时，常见的两种算法是漏桶和令牌桶算法算法。

### **8.2、为什么要限流？** ###

当我们的系统的访问量突然剧增，大量的请求涌入过来，最典型的就是秒杀业务了，我们可能会知道会有一波高峰，这时候该如何处理？

而且现在很多情况我们还需要调用第三方接口例如支付等，因此我们还得考虑如果第三方那边出问题了，返回异常的慢，我们系统该如何处理。

常见的处理方式有三种：降级、熔断、限流。

### **8.3、限流方式：** ###

1）限制总并发数：比如数据库连接池、线程池。

2）限制瞬时并发数：如nginx的limit\_conn模块，用来限制瞬时并发连接数。

3）限制时间窗口内的平均速率：如Guava的RateLimiter、nginx的limit\_req模块，限制每秒平均速率。

4）其它限制：如限制远程接口调用速率、限制MQ的消费速率。

备注：

限流算法：令牌桶(Token Bucket)、漏桶(leaky bucket)和计数器算法是最常用的三种限流的算法

具体详情参考：[https://www.cnblogs.com/AndyAo/p/8144049.html][https_www.cnblogs.com_AndyAo_p_8144049.html]

## **9、使用Java实现限流** ##

案例-实现访问频率限制:

实现访问者 $ip 127.0.0.1在一定的时间 $time 20S内只能访问 $limit 10次.使用JAVA语言实现如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 9][]

**带来的问题：**

1）使用了redis的弱事务，不支持回滚

2）可能会出现竞态条件

## **10、Redis+Lua实现限流** ##

实现方案：Redis实现分布式场景下的限流

分布式场景：多台应用

应用级别：接口

限流算法(计数器)：限制1秒访问5次

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 10][]

## **11、使用Lua实现限流** ##

用图把限流的图画出来：

见项目Lua实战：

**Lua脚本代如下：**

> local key =  KEYS\[1\]
> 
> local limit = tonumber(ARGV\[1\])
> 
> local expire\_time = ARGV\[2\]
> 
> local is\_exists = redis.call("EXISTS", key)
> 
> if is\_exists == 1 then
> 
>     if redis.call("INCR", key) > limit then
> 
>         return 0
> 
>     else
> 
>         return 1
> 
>     end
> 
> else
> 
>     redis.call("SET", key, 1)
> 
>     redis.call("EXPIRE", key, expire\_time)
> 
>     return 1
> 
> end

编译脚本后执行脚本：

> ./redis-cli -h 192.168.30.156 -a 12345678 script load "$(cat ipCount."xxxx")

**测试限流脚本：**

执行如下命令，后面数字5与2代表两秒内执行五次

> evalsha d5bc13bea8aed72e12308acacc65ee725fe3a187 1 192.168.30.156 **5 2**

执行结果如下所示：可以看出两秒内执行超过五次返回0，代表被限流了，过两秒后又可以访问

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 11][]

# **三、Redis+Lua抢红包实战** #

## **1、业务需求** ##

1）将所有红包全部存储到Redis (红包池子的概念)；

2）用户抢了多少红包, 记录红包被抢的详情信息；

3）用户只能抢一次红包, 不能重复抢红包；

4）其它........

## **2、抢红包实战预热** ##

List队列：将N个红包放到List队列中，用来初始化红包池子

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 12][]

## **3、抢红包实战用到的基础命令** ##

List类型：记录用户抢了多少钱

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 13][]

执行命令，如何将多个红包放到放到hongBaoDetailListKey中？

**抢红包基础命令****：**

Hash类型：记录哪些用户已抢过红包，防止重复抢

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 14][]

执行命令，如何将多个红包放到放到hongBaoPool中：

> hset userIdRecordKey 001 1
> 
> hset userIdRecordKey 002 1
> 
> hset userIdRecordKey 003 1
> 
> hset userIdRecordKey 00N 1

## **4、业务流程** ##

1）先初始化红包池：

lpush hongBaoPool \{id:rid\_1, money:9\}  //将N个红包信息放入hongBaoPool 中

2）Lua实现抢红包流程：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 15][]

3）代码实战操作与测试

代码参考：redis-redpack模块，git地址：[https://gitee.com/hankin\_chj/redis-platform.git][https_gitee.com_hankin_chj_redis-platform.git]

**红包测试入口类实现：**

public class MainTestRedPack {
       public static void main(String[] args) throws InterruptedException {//初始化红包
          // 初始化红包
          GenRedPack.genHongBao();
          // 从红包池抢红包
          GetRedPack.getHongBao();
       }
    }

**初始化红包类GenRedPack代码实现：**

public class GenRedPack {
       /**
        * 多线程模拟红包池初始化  Jedis类
        */
       public static void genHongBao() throws InterruptedException {
          JedisUtils jedis = new JedisUtils(Basic.ip, Basic.port, Basic.auth);
          jedis.flushall();  //清空,线上不要用.....
          //发枪器
          final CountDownLatch latch = new CountDownLatch(Basic.threadCount);
          for(int i = 0 ; i < Basic.threadCount; i++){
             final int page = i;
             Thread thread = new Thread(){
                public void run(){
                   latch.countDown();
                   try {
                      latch.await();
                   } catch (InterruptedException e) {
                      e.printStackTrace();
                   }
                   //每个线程要初始化多少个红包  20线程
                   int per = Basic.honBaoCount/Basic.threadCount;
                   JSONObject object = new JSONObject();
                   for(int j = page * per ; j < (page+1) * per; j++){
                      object.put("id", "rid_"+j); //红包ID
                      object.put("money", j);   //红包金额
                      jedis.lpush("hongBaoPoolKey", object.toJSONString());
                   }
                }
             };
             thread.start();
          }
       }
    }

多线程模拟用户抢红包：

/**
     * 多线程模拟用户抢红包
     */
    public class GetRedPack {
        //抢红包的方法
       static public void getHongBao() throws InterruptedException {
          final CountDownLatch latch = new CountDownLatch(Basic.threadCount);//20 发枪器
          for(int i = 0; i < Basic.threadCount ; i ++){  //20线程
             Thread thread = new Thread(){
                public void run(){
                   latch.countDown();
                   try {
                      latch.await();
                   } catch (InterruptedException e) {
                      e.printStackTrace();
                   }
                   //拿到jedis连接
                   JedisUtils jedis = new JedisUtils(Basic.ip, Basic.port, Basic.auth);
                   while(true){
                      //模拟一个用户ID使用UUID XXXX
                      String userid = UUID.randomUUID().toString();
                      //抢红包  eval 可以直接调用我们LUA脚本里的业务代码  object ={rid_1:1, money:9, userid:001}
                      Object object = jedis.eval(Basic.getHongBaoScript,4,Basic.hongBaoPoolKey,Basic.hongBaoDetailListKey,Basic.userIdRecordKey,userid);
                      if(null != object){
                         System.out.println("用户ID号："+userid+" 抢到红包的详情是 "+object);
                      }else{
                         if(jedis.llen(Basic.hongBaoPoolKey) == 0){
                            break;
                         }
                      }
                   }
                }
             };
             thread.start();
          }
       }
    }

Lua脚本工具类代码实现：

**public class** Basic \{   
   **public static** String *ip* = **"192.168.30.156"**;  
   **public static int** *port* = 6379;  
   **public static** String *auth* = **"12345678"**;  
   **public static int** *honBaoCount* = 1000;  
   **public static int** *threadCount* = 20;  
   **public static** String *hongBaoPoolKey* = **"hongBaoPoolKey"**; *//LIST类型来模拟红包池子*  
*   ***public static** String *hongBaoDetailListKey* = **"hongBaoDetailListKey"**;*//LIST类型，记录所有用户抢红包的详情*  
*   ***public static** String *userIdRecordKey* = **"userIdRecordKey"**;*//记录已经抢过红包的用户ID,防止重复抢*  
*   /\**  
*    \* KEYS\[1\]:hongBaoPool：  //键hongBaoPool为List类型，模拟红包池子，用来从红包池抢红包*  
*    \* KEYS\[2\]:hongBaoDetailList：//键hongBaoDetailList为List类型，记录所有用户抢红包的详情*  
*    \* KEYS\[3\]:userIdRecord ： //键userIdRecord为Hash类型，记录所有已经抢过红包的用户ID*  
*    \* KEYS\[4\]:userid ： //模拟抢红包的用户ID*  
*    \* jedis.eval(Basic.getHongBaoScript,4, Basic.hongBaoPoolKey,* *Basic.hongBaoDetailListKey,Basic.userIdRecordKey, userid);*  
*    \*  Lua脚本参数个数  key\[1\] key\[2\] key\[3\] key\[4\]*  
*   \*/*  
*   ***public static** String *getHongBaoScript* =  
         *// 查询用户是否抢过红包，如果已经抢过则直接返回nil*  
*         ***"if redis.call('hexists', KEYS\[3\], KEYS\[4\]) ~= 0 then****\\n****"   **\+  
               **"return nil****\\n****"** \+  
         **"else****\\n****"  **\+  
               *// 从红包池取出一个红包*  
*               ***"local hongBao = redis.call('rpop', KEYS\[1\]);****\\n****"  **\+  
               *// 判断红包池的红包是否为空*  
*               ***"if hongBao then****\\n****"  **\+  
                   **"local x = cjson.decode(hongBao);****\\n****"  **\+  
                  *// 将红包信息与用户ID信息绑定，表示该用户已经抢到红包*  
*                  ***"x\['userId'\] = KEYS\[4\];****\\n****"  **\+  
                  **"local re = cjson.encode(x);****\\n****"  **\+  
                  *// 记录该用户已经抢过userIdRecordKey*  
*                  ***"redis.call('hset', KEYS\[3\], KEYS\[4\], '1');****\\n****"  **\+  
                  *// 将抢红包的结果详情存入hongBaoDetailListKey*  
*                  ***"redis.call('lpush', KEYS\[2\], re);****\\n****"** \+  
                  **"return re;****\\n****"  **\+  
               **"end****\\n****"  **\+  
         **"end****\\n****"  **\+  
          **"return nil"**;  
\}

执行结果如下：

> 用户ID号：b0a1b61c-9358-4b83-b444-5d67ad1211e2 抢到红包的详情是
> 
> \{"id":"rid\_699","userId":"b0a1b61c-9358-4b83-b444-5d67ad1211e2","money":699\}
> 
> 用户ID号：eee3fd47-4d84-4967-b834-40955078298c 抢到红包的详情是 
> 
> \{"id":"rid\_649","userId":"eee3fd47-4d84-4967-b834-40955078298c","money":649\}
> 
> 用户ID号：7b52a9a3-142b-4e2b-a0f6-b80c20e468cf 抢到红包的详情是 
> 
> \{"id":"rid\_898","userId":"7b52a9a3-142b-4e2b-a0f6-b80c20e468cf","money":898\}
> 
> 用户ID号：c891ed87-2ff2-402f-91ee-db3b78e2e9c0 抢到红包的详情是 
> 
> \{"id":"rid\_599","userId":"c891ed87-2ff2-402f-91ee-db3b78e2e9c0","money":599\}
> 
> 用户ID号：ec7a0242-f912-4017-b2c3-a3ba15115e2d 抢到红包的详情是 
> 
> \{"id":"rid\_399","userId":"ec7a0242-f912-4017-b2c3-a3ba15115e2d","money":399\}
> 
> 用户ID号：585212f4-6ef0-479e-975a-982c0b6f3f41 抢到红包的详情是 
> 
> \{"id":"rid\_499","userId":"585212f4-6ef0-479e-975a-982c0b6f3f41","money":499\}
> 
> 用户ID号：3afd41f9-8aa0-4bff-82c6-7145203e4f7f 抢到红包的详情是 
> 
> \{"id":"rid\_899","userId":"3afd41f9-8aa0-4bff-82c6-7145203e4f7f","money":899\}

### **5、Lua实现核心业务——什么是Lua语言？** ###

Lua是一个小巧的脚本语言，由标准C编写而成，代码简洁优美，几乎在所有操作系统和平台上都可以编译运行。

一个完整的Lua解释器不过200k，在目前所有脚本引擎中，Lua的速度是最快的。

Lua语言里的操作提供原子性。

### **6、Redis+Lua使用** ###

6379>set name hankin

6379>eval "return redis.call('get',KEYS\[1\])" 1 name //1个键,键名为name,返回hankin

用java代码实现测试如下：

//eval "return redis.call('get',KEYS[1])" 1 name
    public static void main(String[] args) {
        // 工具类初始化
        Jedis jedis = new Jedis("192.168.30.156",6379);
        jedis.auth("12345678");
        jedis.set("name","hankin");
        String script = "return redis.call('get',KEYS[1])";
        Object result = jedis.eval(script,1,"name");
        System.out.println(result);
        jedis.disconnect();
    }

### **7、Lua实现核心业务** ###

Object object= jedis.eval(getHongBaoScript,4,hongBaoPoolKey,hongBaoDetailListKey,userIdRecordKey, userid );

Lua脚本参数个数KEY\[1\] KEY\[2\] KEY\[3\] KEY\[4\]

/*
        * KEYS[1]:hongBaoPool：  //键hongBaoPool为List类型，模拟红包池子，用来从红包池抢红包
        * KEYS[2]:hongBaoDetailList：//键hongBaoDetailList为List类型，记录所有用户抢红包的详情
        * KEYS[3]:userIdRecord ： //键userIdRecord为Hash类型，记录所有已经抢过红包的用户ID
        * KEYS[4]:userid ： //模拟抢红包的用户ID
        * 
        * jedis.eval(Basic.getHongBaoScript,4, Basic.hongBaoPoolKey, Basic.hongBaoDetailListKey,Basic.userIdRecordKey, userid);
        *  Lua脚本参数个数  key[1] key[2] key[3] key[4]
       */
       public static String getHongBaoScript =
             // 查询用户是否抢过红包，如果已经抢过则直接返回nil
             "if redis.call('hexists', KEYS[3], KEYS[4]) ~= 0 then\n"   +
                   "return nil\n" +
             "else\n"  +
                   // 从红包池取出一个红包
                   "local hongBao = redis.call('rpop', KEYS[1]);\n"  +
                   // 判断红包池的红包是否为空
                   "if hongBao then\n"  +
                       "local x = cjson.decode(hongBao);\n"  +
                      // 将红包信息与用户ID信息绑定，表示该用户已经抢到红包
                      "x['userId'] = KEYS[4];\n"  +
                      "local re = cjson.encode(x);\n"  +
                      // 记录该用户已经抢过userIdRecordKey
                      "redis.call('hset', KEYS[3], KEYS[4], '1');\n"  +
                      // 将抢红包的结果详情存入hongBaoDetailListKey
                      "redis.call('lpush', KEYS[2], re);\n" +
                      "return re;\n"  +
                   "end\n"  +
             "end\n"  +
              "return nil";
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191113154113287.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/20191113154132967.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/20191113154155683.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/20191113154220305.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 4]: https://img-blog.csdnimg.cn/20191113154240291.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[https_gitee.com_hankin_chj_redis-platform.git]: https://gitee.com/hankin_chj/redis-platform.git
[20191113154615950.png]: https://img-blog.csdnimg.cn/20191113154615950.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191113154641230.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 6]: https://img-blog.csdnimg.cn/20191113154721776.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 7]: https://img-blog.csdnimg.cn/20191113154745618.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 8]: https://img-blog.csdnimg.cn/20191113154902430.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[20191113154950693.png]: https://img-blog.csdnimg.cn/20191113154950693.png
[20191113155024912.png]: https://img-blog.csdnimg.cn/20191113155024912.png
[https_www.cnblogs.com_AndyAo_p_8144049.html]: https://www.cnblogs.com/AndyAo/p/8144049.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20191113155058912.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 10]: https://img-blog.csdnimg.cn/20191113155120490.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 11]: https://img-blog.csdnimg.cn/20191113155158258.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 12]: https://img-blog.csdnimg.cn/20191113155300834.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 13]: https://img-blog.csdnimg.cn/20191113155329461.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 14]: https://img-blog.csdnimg.cn/20191113155347396.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 15]: https://img-blog.csdnimg.cn/20191113155455186.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70