【Redis|实战篇7】黑马点评|附近商铺、用户签到、UV签到

文章目录

• • 9.附近商铺
  • • 9.1GEO数据结构
    • 9.2导入店铺数据到GEO
    • 9.3实现附近商户功能
  • 10.用户签到
  • • 10.1BitMap功能
    • 10.2实现签到功能
    • 10.3统计连续签到
  • 11.UV签到
  • • 11.1HyperLogLog用法
    • 11.2实现UV统计

明天再完善一些小问题做个总价

9.附近商铺

9.1GEO数据结构

GEO就是Geolocation的简写形式，代表地理坐标。Redis在3.2版本中加入了对GEO的支持，允许存储地理坐标信息，帮助我们根据经纬度来检索数据。常见的命令有：

• GEOADD：添加一个地理空间信息，包含：经度（longitude）、纬度（latitude）、值（member）
• GEODIST：计算指定的两个点之间的距离并返回
• GEOHASH：将指定member的坐标转为hash字符串形式并返回
• GEOPOS：返回指定member的坐标
• GEORADIUS：指定圆心、半径，找到该圆内包含的所有member，并按照与圆心之间的距离排序后返回。6.2以后已废弃
• GEOSEARCH：在指定范围内搜索member，并按照与指定点之间的距离排序后返回。范围可以是圆形或矩形。6.2.新功能
• GEOSEARCHSTORE：与GEOSEARCH功能一致，不过可以把结果存储到一个指定的key。

# 添加坐标数据
GEOADD g1 116.378248 39.865275 bjnz 116.42803 39.903738 bjz 116.322287 39.893729 bjxz
# 计算北京西站到北京站的距离
GEODIST g1 bjnz bjxz km
# 搜索天安门附近10km内的所有火车站，并按照距离升序排序
GEOSEARCH g1 FROMLONLAT 116.397904 39.909005 BYRADIUS 10 km WITHDIST

9.2导入店铺数据到GEO

按照商户类型做分组，类型相同的商户作为同一组，以typeId为key存入同一个GEO集合中

@Test
    void localShopData(){
        //1.查询店铺信息
        List<Shop> list = shopService.list();
        //2.把店铺分组，typeId一致的放到一个集合
        Map<Long, List<Shop>> map = list.stream().collect(Collectors.groupingBy(Shop::getTypeId));
        //3.分批完成写入Redis
        for (Map.Entry<Long, List<Shop>> entry : map.entrySet()) {
            //1.获取该类型的类型id
            Long typeTd = entry.getKey();
            String key = "shop:geo:" + typeTd;
            //2.获取同类型的店铺的集合
            List<Shop> value = entry.getValue();
            List<RedisGeoCommands.GeoLocation<String>> locations = new ArrayList<>(value.size());
            for (Shop shop : value) {
                locations.add(new RedisGeoCommands.GeoLocation<>(shop.getId().toString(),new Point(shop.getX(),shop.getY())));
            }
            //3.写入Redis
            stringRedisTemplate.opsForGeo().add(key,locations);
        }
    }

为啥不在第二层for循环里一个一个add？

因为：使用 stringRedisTemplate.opsForGeo().add(key, locations) 批量添加，速度会比在一个循环中逐个调用 add 快得多，尤其是在数据量较大时，性能差距会非常明显。

Redis 是一个基于网络的服务，每一次客户端（你的 Java 应用）和服务器（Redis）之间的通信都涉及网络请求和响应，这个过程会产生延迟

9.3实现附近商户功能

在此之前还需要导入一些依赖

/**
     * 查询附近商户
     *
     * @param typeId
     * @param current
     * @param x
     * @param y
     * @return
     */
    @Override
    public Result queryShopByType(Integer typeId, Integer current, Double x, Double y) {
        //1.判断是否需要根据坐标查询
        if (x == null || y == null) {
            //不需要根据坐标查询，按数据库查询
            Page<Shop> page = query()
                    .eq("type_id", typeId)
                    .page(new Page<>(current, SystemConstants.DEFAULT_PAGE_SIZE));
            // 返回数据
            return Result.ok(page.getRecords());
        }
        //TODO geo依赖
        //2.计算分页参数
        int from = (current - 1) * SystemConstants.DEFAULT_PAGE_SIZE;
        int end = current * SystemConstants.DEFAULT_PAGE_SIZE;
        //3.查询Redis，按照距离排序、分页
        String key = "shop:geo:" + typeId;
        GeoResults<RedisGeoCommands.GeoLocation<String>> results = stringRedisTemplate.opsForGeo()
                .search(
                        key,
                        GeoReference.fromCoordinate(x, y),
                        new Distance(5000),
                        RedisGeoCommands.GeoSearchCommandArgs.newGeoSearchArgs().includeDistance().limit(end)
                );
        //4.解析出id
        if (results == null) {
            return Result.ok(Collections.emptyList());
        }
        List<GeoResult<RedisGeoCommands.GeoLocation<String>>> list = results.getContent();
        if (list.size() <= from) {
            // 没有下一页了，结束
            return Result.ok(Collections.emptyList());
        }
        // 4.1.截取 from ~ end的部分
        List<Long> ids = new ArrayList<>(list.size());
        Map<String, Distance> distanceMap = new HashMap<>(list.size());
        list.stream().skip(from).forEach(result -> {
            // 4.2.获取店铺id
            String shopIdStr = result.getContent().getName();
            ids.add(Long.valueOf(shopIdStr));
            // 4.3.获取距离
            Distance distance = result.getDistance();
            distanceMap.put(shopIdStr, distance);
        });
        //5.根据id查询出Shop
        String idStr = StrUtil.join(",", ids);
        List<Shop> shops = query().in("id", ids).last("ORDER BY FIELD(id," + idStr + ")").list();
        for (Shop shop : shops) {
            shop.setDistance(distanceMap.get(shop.getId().toString()).getValue());
        }
        // 6.返回
        return Result.ok(shops);
    }

10.用户签到

10.1BitMap功能

BitMap用法

Redis中是利用string类型数据结构实现BitMap，因此最大上限是512M，转换为bit则是2^32个bit位。

BitMap的操作命令有：

• SETBIT：向指定位置（offset）存入一个0或1
• GETBIT：获取指定位置（offset）的bit值
• BITCOUNT：统计BitMap中值为1的bit位的数量
• BITFIELD：操作（查询、修改、自增）BitMap中bit数组中的指定位置（offset）的值
• BITFIELD_RO：获取BitMap中bit数组，并以十进制形式返回
• BITOP：将多个BitMap的结果做位运算（与、或、异或）
• BITPOS：查找bit数组中指定范围内第一个0或1出现的位置

10.2实现签到功能

Controller层

/**
     * 用户签到
     * @return
     */
    @PostMapping("/sign")
    public Result sign(){
        return userService.sign();
    }

Service层

/**
     * 用户签到
     * @return
     */
    @Override
    public Result sign() {
        //1.获取当前登录用户
        Long userId = UserHolder.getUser().getId();
        //2.获取日期
        LocalDateTime now = LocalDateTime.now();
        //3.拼接key
        String keySuffix = now.format(DateTimeFormatter.ofPattern(":yyyyMM"));
        String key = "sign:" + userId + keySuffix;
        //4.获取今天是本月的第几天
        int dayOfMonth = now.getDayOfMonth();
        //5.写入Redis SETBIT key offset 1
        stringRedisTemplate.opsForValue().setBit(key, dayOfMonth - 1, true);
        return Result.ok();
    }

10.3统计连续签到

/**
     * 记录连续签到的天数
     * @return
     */
    @Override
    public Result signCount() {
        //获取签到记录
        //1.获取当前登录用户
        Long userId = UserHolder.getUser().getId();
        //2.获取日期
        LocalDateTime now = LocalDateTime.now();
        //3.拼接key
        String keySuffix = now.format(DateTimeFormatter.ofPattern(":yyyyMM"));
        String key = "sign:" + userId + keySuffix;
        //4.获取今天是本月的第几天
        int dayOfMonth = now.getDayOfMonth();
        //5.获取本月截止今天为止的所有的签到记录，返回的是一个十进制的数字
        List<Long> result = stringRedisTemplate.opsForValue().bitField(
                key,
                BitFieldSubCommands.create()
                        .get(BitFieldSubCommands.BitFieldType.unsigned(dayOfMonth)).valueAt(0)
        );
        // 判断签到记录是否存在
        if (result == null || result.isEmpty()) {
            // 没有任何签到结果
            return Result.ok(0);
        }
        Long num = result.get(0);
        if (num == null || num == 0) {
            // 二次判断签到结果是否存在
            return Result.ok(0);
        }
        // 4、循环遍历，获取连续签到的天数（从当前天起始）
        int count = 0;
        while (true) {
            // 让这个数字与1做与运算，得到数字的最后一个bit位，并且判断这个bit位是否为0
            if ((num & 1) == 0) {
                //如果为0，说明未签到，结束
                break;
            } else {
                //如果不为0，说明已签到，计数器+1
                count++;
            }
            //把数字右移一位，抛弃最后一个bit位，继续下一个bit位
            num >>>= 1;
        }
        return Result.ok(count);
    }

11.UV签到

11.1HyperLogLog用法

• UV：全称Unique Visitor，也叫独立访客量，是指通过互联网访问、浏览这个网页的自然人。1天内同一个用户多次访问该网站，只记录1次。
• PV：全称Page View，也叫页面访问量或点击量，用户每访问网站的一个页面，记录1次PV，用户多次打开页面，则记录多次PV。往往用来衡量网站的流量。

UV统计在服务端做会比较麻烦，因为要判断该用户是否已经统计过了，需要将统计过的用户信息保存。但是如果每个访问的用户都保存到Redis中，数据量会非常恐怖

Hyperloglog(HLL)是从Loglog算法派生的概率算法，用于确定非常大的集合的基数，而不需要存储其所有值。（相关算法原理可以参考：https://juejin.cn/post/6844903785744056333#heading-0）

Redis中的HLL是基于string结构实现的，单个HLL的内存永远小于16kb，内存占用非常低，作为代价，其测量结果是概率性的，有小于**0.81％**的误差。不过对于UV统计来说，这完全可以忽略。

核心指令

1. PFADD (添加元素)
   • 功能：将指定的元素添加到 HyperLogLog 中。它会自动进行去重处理。
   • 返回值：
     • 1：表示本次添加操作改变了 HyperLogLog 的内部状态（即可能添加了一个新元素）。
     • 0：表示内部状态未改变（通常是添加了重复元素）。
   • 示例 ：PFADD daily_uv user1 user2
2. PFCOUNT (获取基数)
   • 功能：返回存储在指定 key 中的 HyperLogLog 的基数估算值（即不重复元素的数量）。
   • 特性：
     • 可以接收多个 key，返回这些 key 合并后的并集基数估算值。
     • 注意：从技术角度看，这是一个写命令，因为它可能会更新内部缓存的估算值。
   • 示例 ：PFCOUNT daily_uv
3. PFMERGE (合并数据)
   • 功能：将多个 HyperLogLog 合并成一个新的 HyperLogLog。
   • 用途：常用于合并多天的统计数据。例如，将7天的日活数据合并，以计算周活。
   • 示例 ：PFMERGE weekly_uv monday_uv tuesday_uv ...

优点

1. 极致的内存效率
   这是它最大的亮点。无论你要统计的元素是1万个还是10亿个，HyperLogLog 占用的内存都固定在一个非常小的范围内（例如在 Redis 中，通常只需要约 12KB）。这与存储所有元素的 Set 或 HashMap（内存占用随元素数量线性增长）形成了鲜明对比。
2. 极快的计算速度
   添加元素 (PFADD) 和查询基数 (PFCOUNT) 的时间复杂度都是 O(1)。这意味着即使面对海量数据流，它也能提供实时或近实时的统计结果，性能非常高。
3. 天生的可合并性
   多个独立的 HyperLogLog 实例可以轻松地合并成一个新的实例，合并后的结果等同于所有元素被添加到同一个 HyperLogLog 中的估算值。这个特性使其在分布式系统中非常有用，例如，每个服务器节点独立统计，最后再合并得到全局总数。

缺点

1. 结果是近似值，存在误差
   HyperLogLog 只能提供基数的估算值，无法做到 100% 精确。在标准配置下，它的标准误差率约为 0.81%。对于绝大多数大数据分析场景，这个误差是可以接受的，但在需要精确计数的业务（如金融交易）中则完全不适用。
2. 无法获取具体元素
   它只负责"计数"，不存储任何具体的元素信息。你只能知道"大概有多少个不同的用户"，但无法知道"这些用户具体是谁"。如果需要列出所有不重复的元素，HyperLogLog 无能为力。
3. 对小数据集相对不敏感
   当统计的数据量非常小（例如少于1000个）时，其估算结果的相对误差可能会显得比较大，不如直接使用 Set 等精确数据结构高效和准确。
4. 功能单一
   它只专注于基数估算，不支持删除元素等操作。一旦元素被添加，就无法从中移除。

11.2实现UV统计

利用单元测试，向HyperLogLog中添加100万条数据

1. 开始前先查看当前Redis占用内存情况

   #查看Redis的内存
   info memory

2. 测试

   /**
        * 测试HyperLogLog 实现UV统计
        */
       @Test
       public void testHyperLogLog() {
           String[] values = new String[1000];
           //批量保存100w条用户记录
           int j = 0;
           for (int i = 0; i < 1000000; i++) {
               j = i % 1000;
               values[j] = "user_" + i;
               if (j == 999) {
                   //凑够 1000 个再发送到Redis
                   stringRedisTemplate.opsForHyperLogLog().add("hl2", values);
               }
           }
           // 统计数量
           Long count = stringRedisTemplate.opsForHyperLogLog().size("hl2");
           System.out.println("count = " + count);
       }

3. 再回去查看一下Redis的内存