11 Redis大厂真实需求落地案例实战

案例实战：微信抢红包

需求分析

1. 各种节假日，发红包+抢红包，不说了，100%高并发业务要求，不能用mysql来做
2. 一个总的大红包，会有可能拆分成多个小红包，总金额= 分金额1+分金额2+分金额3…分金额N
3. 每个人只能抢一次，你需要有记录，比如100块钱，被拆分成10个红包发出去，总计有10个红包，抢一个少一个，总数显示(10/6)直到完，需要记录那些人抢到了红包，重复抢作弊不可以。
4. 有可能还需要你计时，完整抢完，从发出到全部over，耗时多少？
5. 红包过期，或者群主人品差，没人抢红包，原封不动退回。
6. 红包过期，剩余金额可能需要回退到发红包主账户下。
7. 由于是高并发不能用mysql来做，只能用redis，那需要要redis的什么数据类型？

架构设计

难点

1. 拆分算法如何：红包其实就是金额，拆分算法如何 ？给你100块，分成10个小红包(金额有可能小概率相同，有2个红包都是2.58)，如何拆分随机金额设定每个红包里面安装多少钱?
2. 次数限制：每个人只能抢一次，次数限制
3. 原子性：每抢走一个红包就减少一个(类似减库存)，那这个就需要保证库存的-----------------------原子性，不加锁实现你认为存在redis什么数据类型里面？set ？hash？ list？

关键点

• 发红包
• 抢红包
  • 抢，不加锁且原子性，还能支持高并发
  • 每人一次且有抢红包记录
• 记红包
• 拆红包算法
  • 所有人抢到金额之和等于红包金额，不能超过，也不能少于。
  • 每个人至少抢到一分钱。
  • 要保证所有人抢到金额的几率相等。
• 二倍均值法：
  • 剩余红包金额为M，剩余人数为N，那么有如下公式：
  • 每次抢到的金额 = 随机区间 （0， (剩余红包金额M ÷ 剩余人数N ) X 2）
  • 这个公式，保证了每次随机金额的平均值是相等的，不会因为抢红包的先后顺序而造成不公平。
  • 举个栗子：
    • 假设有10个人，红包总额100元。
    • 第1次：100÷10 X2 = 20, 所以第一个人的随机范围是（0，20 )，平均可以抢到10元。假设第一个人随机到10元，那么剩余金额是100-10 = 90 元。
    • 第2次：90÷9 X2 = 20, 所以第二个人的随机范围同样是（0，20 )，平均可以抢到10元。假设第二个人随机到10元，那么剩余金额是90-10 = 80 元。
    • 第3次：80÷8 X2 = 20, 所以第三个人的随机范围同样是（0，20 )，平均可以抢到10元。 以此类推，每一次随机范围的均值是相等的。

编码实现

@RestController
public class RedPackageController {
    
    
    public static final String RED_PACKAGE_KEY = "redpackage:";
    public static final String RED_PACKAGE_CONSUME_KEY = "redpackage:consume:";

    @Resource
    private RedisTemplate redisTemplate;

    /**
     * 拆分+发送红包
     * http://localhost:5555/send?totalMoney=100&redPackageNumber=5
     *
     * @param totalMoney
     * @param redPackageNumber
     * @return
     */
    @RequestMapping("/send")
    public String sendRedPackage(int totalMoney, int redPackageNumber) {
    
    
        //1 拆红包，总金额拆分成多少个红包，每个小红包里面包多少钱
        Integer[] splitRedPackages = splitRedPackage(totalMoney, redPackageNumber);
        //2 红包的全局ID
        String key = RED_PACKAGE_KEY + IdUtil.simpleUUID();
        //3 采用list存储红包并设置过期时间，红包主有且仅有一个，不用加锁控制
        redisTemplate.opsForList().leftPushAll(key, splitRedPackages);
        redisTemplate.expire(key, 1, TimeUnit.DAYS);
        return key + "\t" + "\t" + Ints.asList(Arrays.stream(splitRedPackages).mapToInt(Integer::valueOf).toArray());
    }

    /**
     * 抢红包，谁发送的红包，分别被谁抢走了。
     * http://localhost:5555/rob?redPackageKey=上一步的红包UUID&userId=1
     *
     * @param redPackageKey
     * @param userId
     * @return
     */
    @RequestMapping("/rob")
    public String rodRedPackage(String redPackageKey, String userId) {
    
    
        //1 验证某个用户是否抢过红包
        Object redPackage = redisTemplate.opsForHash().get(RED_PACKAGE_CONSUME_KEY + redPackageKey, userId);
        //2 没有抢过就开抢，否则返回-2表示抢过
        if (redPackage == null) {
    
    
            // 2.1 从list里面出队一个红包，抢到了一个
            Object partRedPackage = redisTemplate.opsForList().leftPop(RED_PACKAGE_KEY + redPackageKey);
            if (partRedPackage != null) {
    
    
                //2.2 抢到手后，记录进去hash表示谁抢到了多少钱的某一个红包
                redisTemplate.opsForHash().put(RED_PACKAGE_CONSUME_KEY + redPackageKey, userId, partRedPackage);
                System.out.println("用户: " + userId + "\t 抢到多少钱红包: " + partRedPackage);
                //TODO 后续异步进mysql或者RabbitMQ进一步处理
                //TODO 后续异步进mysql或者RabbitMQ进一步处理
                //TODO 后续异步进mysql或者RabbitMQ进一步处理
                return String.valueOf(partRedPackage);
            }
            //抢完
            return "errorCode:-1,红包抢完了";
        }
        //3 某个用户抢过了，不可以作弊重新抢
        return "errorCode:-2,   message: " + "\t" + userId + " 用户你已经抢过红包了";
    }

    /**
     * 1 拆完红包总金额+每个小红包金额别太离谱
     * 2 算法：二倍均值法
     * 3 对于金钱应该用decimal，不用Integer，这里先忽略小数精度这个问题
     * 只讨论算法的合理性
     *
     * @param totalMoney
     * @param redPackageNumber
     * @return
     */
    private Integer[] splitRedPackage(int totalMoney, int redPackageNumber) {
    
    
        //已经被抢的钱
        int useMoney = 0;
        // 每次抢到的钱
        Integer[] redPackageNumbers = new Integer[redPackageNumber];
        Random random = new Random();

        for (int i = 0; i < redPackageNumber; i++) {
    
    
            if (i == redPackageNumber - 1) {
    
    
                redPackageNumbers[i] = totalMoney - useMoney;
            } else {
    
    
                //每次抢到的金额 = 随机区间 (0， (剩余红包金额M ÷ 未被抢的剩余红包个数N ) X 2)
                int avgMoney = ((totalMoney - useMoney) / (redPackageNumber - i)) * 2;
                //System.out.println(avgMoney);
                redPackageNumbers[i] = 1 + random.nextInt(avgMoney - 1);
            }
            useMoney = useMoney + redPackageNumbers[i];
        }
        return redPackageNumbers;
    }
}

• 上述案例有许多红包记录了，如何批量删除
• 

案例实战：B站视频、淘宝购物、分享短连接推广

需求分析

真实生产案例

• B站视频推广短链接

• 小米购物推广短链接

• 淘宝购物推广短连接
  

• 好处

  • 简单方便，利与推广
  • http传输好了很多，有助于带宽节约和高并发
  • 防止尾巴参数泄密，不安全

架构设计

难点

• 短链接映射算法如何编写？
• 通过映射算法后，跳转到真实地址，如何编写？
• 短：长 url的映射，你觉得用redis里面的那个结构?

短链接算法

• 新浪使用短链接主要是因为微博只允许发144 字，如果链接地址太长的话，那么发送的字数将大大减少。
• 短链接的主要职责就是把原始链接很长的地址压缩成只有6 个字母的短链接地址，当我们点击这6 个字母的链接后，我们又可以跳转到原始的真实链接地址。

短链接算法Coding

public class ShortUrlUtils
{
    
    
    //26+26+10=62
    public static  final  String[] chars = new String[]{
    
    "a", "b", "c", "d", "e", "f", "g", "h",
            "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
            "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
            "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H",
            "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
            "U", "V", "W", "X", "Y", "Z"};

    /**
     * 一个长链接URL转换为4个短KEY,每个key6位
     *
     　思路：
     　　1)将长网址md5生成32位签名串,分为4段, 每段8个字节;
     　　2)对这四段循环处理, 取8个字节, 将他看成16进制串与0x3fffffff(30位1)与操作, 即超过30位的忽略处理;
     　　3)这30位分成6段, 每5位的数字作为字母表的索引取得特定字符, 依次进行获得6位字符串;
     　　4)总的md5串可以获得4个6位串; 取里面的任意一个就可作为这个长url的短url地址;
     * 当我们点击这6个字母的链接后，我们又可以跳转到原始的真实长链接地址。
     */
    public static String[] shortUrl(String url) {
    
    
        // 对传入长网址进行 MD5 加密
        String sMD5EncryptResult = DigestUtils.md5Hex(url);
        System.out.println("---------------sMD5EncryptResult: "+sMD5EncryptResult);
        System.out.println();
        //md5处理后是32位
        String hex = sMD5EncryptResult;
        //切割为4组，每组8个字符, 32 = 4 *  8
        String[] resUrl = new String[4];

        for (int i = 0; i < 4; i++) {
    
    
            //取出8位字符串，md5 32位，按照8位一组字符,被切割为4组
            String sTempSubString = hex.substring(i * 8, i * 8 + 8);
            System.out.println("---------------sTempSubString: "+sTempSubString);
            //返回由指定基数中的字符串参数表示的long型数
            System.out.println("将sTempSubString转换为long型： "+Long.parseLong(sTempSubString, 16));

            //把加密字符按照8位一组16进制与 0x3FFFFFFF 进行位与运算
            // 16进制的0x3FFFFFFF等于二进制的00111111111111111111111111111111,等于10进制的1073741823
            // 这里需要使用 long 型来转换，因为 Inteper .parseInt() 只能处理 31 位 ,
            // 首位为符号位 ,如果不用 long ，则会越界，下面做&运算保证不越界。
            // 00111110100000001110101000111000，等于10进制的1048635960
            long lHexLong = 0x3FFFFFFF & Long.parseLong(sTempSubString, 16);
            System.out.println("---------lHexLong: "+lHexLong);

            String outChars = "";
            for (int j = 0; j < 6; j++) {
    
    
                //0x0000003D它的10进制是61，61代表最上面定义的chars数组长度62的0到61的坐标。
                //0x0000003D & lHexLong进行位与运算，就是格式化为6位，即保证了index绝对是61以内的值
                long index = 0x0000003D & lHexLong;
                System.out.println("----------index: "+index);
                // 按照下标index把从chars数组取得的字符逐个相加
                outChars += chars[(int) index];
                //每次循环按位移5位，因为30位的二进制，分6次循环，即每次右移5位
                lHexLong = lHexLong >> 5;
            }
            // 把字符串存入对应索引的输出数组,会产生一组6位字符串
            resUrl[i] = outChars;
        }
        return resUrl;
    }


    /**
     * 测试类
     * @param args
     */
    public static void main(String[] args) {
    
    
        // 长连接
        String longUrl = "https://www.bilibili.com/video/BV1Hy4y1B78T?p=1&share_medium=android&share_plat=android&share_source=COPY&share_tag=s_i&timestamp=1605941821&unique_k=xIPwAV";

        // 转换成的短链接后6位码，返回4个短链接
        String[] shortCodeArray = shortUrl(longUrl);

        for (int i = 0; i < shortCodeArray.length; i++) {
    
    
            // 任意一个都可以作为短链接码
            System.out.println(shortCodeArray[i]);
        }
    }
}

编码实现

• 短链接算法
• 长短链接映射的要求，需要Redis存在hash结构里面short：long
• 请求重定向

@RestController
public class ShortUrlController {
    
    
    private final static String SHORT_URL_KEY = "short:url";

    @Resource
    private HttpServletResponse response;

    @Resource
    private RedisTemplate redisTemplate;

    /**
     * 长链接转换为短链接
     * 实现原理：长链接转换为短加密串key，然后存储在redis的hash结构中。
     * 测试地址：http://localhost:5555/shorturl/encode?longUrl=https://www.baidu.com/
     */
    @GetMapping(value = "/shorturl/encode")
    public String encode(@RequestParam("longUrl") String longUrl) {
    
    

        //一个长链接url转换为4个短加密串key
        String[] keys = ShortUrlUtils.shortUrl(longUrl);
        //任意取出其中一个，我们就拿第一个
        String shortUrlKey = keys[new Random().nextInt(4)];
        //用hash存储，key=加密串，value=原始url
        this.redisTemplate.opsForHash().put(SHORT_URL_KEY, shortUrlKey, longUrl);
        System.out.println("长链接: " + longUrl + "\t" + "转换短链接: " + shortUrlKey);

        return "http://127.0.0.1:5555/" + shortUrlKey;
    }

    /**
     * 重定向到原始的URL
     * 实现原理：通过短加密串KEY到redis找出原始URL，然后重定向出去
     * 测试地址：http://localhost:5555/shorturl/decode/VFRrQn
     */
    @GetMapping(value = "/shorturl/decode/{shortUrlKey}")
    public void decode(@PathVariable String shortUrlKey) {
    
    
        //到redis中把原始url找出来
        String url = (String) this.redisTemplate.opsForHash().get(SHORT_URL_KEY, shortUrlKey);
        System.out.println("----准备调整到真实长地址url(注意是否有前缀：https://): " + url);
        try {
    
    
            //重定向到原始的url
            response.sendRedirect(url);
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
    }
}