redis|spring-boot redis geo|附近定位功能

 /**
     * 定时刷新：启动后延迟3秒首次执行，之后每30分钟刷新一次
     */
    @Scheduled(initialDelayString = "${store.cache.init-delay:3000}",
               fixedDelayString = "${store.cache.refresh-interval:1800000}")
    public void refreshStoreCache() {
        log.info(">>>> 开始刷新店铺GEO缓存 >>>>");
        try {
            List<Store> stores = storeRepository.findAll();
            log.info("SQLite 查询到 {} 条店铺数据", stores.size());
            if (stores.isEmpty()) {
                log.warn("SQLite 中没有店铺数据，跳过缓存刷新");
                return;
            }

            // 1. 测试 Redis 连接
            try {
                String pong = redisTemplate.getConnectionFactory().getConnection().ping();
                log.info("Redis PING 结果: {}", pong);
            } catch (Exception e) {
                log.error("Redis 连接失败", e);
                return;
            }

            // 2. 清除旧数据
            log.info("步骤1: 删除旧缓存数据...");
            redisTemplate.delete(GEO_KEY);

            // 3. ZADD: 成员 = geohash:storeId, score = 0（用 ZRANGEBYLEX 按前缀查询）
            log.info("步骤2: ZADD 写入 geohash 索引...");
            for (Store store : stores) {
                String geohash5 = GeoHashUtils.encode(store.getLatitude(), store.getLongitude(), GEOHASH_PRECISION);
                String member = geohash5 + ":" + store.getId();
                redisTemplate.opsForZSet().add(GEO_KEY, member, 0);
            }
            log.info("Redis ZADD 完成，加载 {} 条店铺坐标", stores.size());

            // 4. 缓存店铺详情
            log.info("步骤3: 缓存店铺详情...");
            for (Store store : stores) {
                String key = STORE_DETAIL_PREFIX + store.getId();
                redisTemplate.opsForValue().set(key, JSON.toJSONString(store), 1, TimeUnit.HOURS);
            }
            log.info("Redis 店铺详情缓存完成，共 {} 条", stores.size());

        } catch (Exception e) {
            log.error("刷新店铺GEO缓存失败", e);
        }
        log.info("<<<< 店铺GEO缓存刷新结束 <<<<");
    }

/**
     * 搜索附近店铺
     */
    public List<StoreNearbyVO> searchNearby(double longitude, double latitude, double radiusKm) {
        // 缓存为空时重新加载
        Long geoSize = redisTemplate.opsForZSet().zCard(GEO_KEY);
        if (geoSize == null || geoSize == 0) {
            log.info("Redis 缓存为空，重新加载...");
            refreshStoreCache();
        }

        // 1. 计算中心点的 geohash（精度5）
        String centerHash = GeoHashUtils.encode(latitude, longitude, GEOHASH_PRECISION);

        // 2. 获取中心 + 8个邻居 geohash（九宫格覆盖搜索区域）
        List<String> searchHashes = GeoHashUtils.neighbors(centerHash);
        searchHashes.add(centerHash);
        log.debug("搜索九宫格: {}", searchHashes);

        // 3. ZRANGEBYLEX 按前缀查询每个 geohash 桶中的店铺
        Set<String> storeIds = new HashSet<>();
        for (String hash : searchHashes) {
            String min = hash + ":";
            String max = hash + ":\uffff";
            try {
                Set<String> members = redisTemplate.opsForZSet().rangeByLex(GEO_KEY, Range.closed(min, max));
                if (members != null) {
                    for (String member : members) {
                        // member 格式: "geohash:storeId"
                        int idx = member.indexOf(':');
                        if (idx >= 0) {
                            storeIds.add(member.substring(idx + 1));
                        }
                    }
                }
            } catch (Exception e) {
                log.warn("ZRANGEBYLEX 查询失败: hash={}", hash, e);
            }
        }

        if (storeIds.isEmpty()) {
            log.info("附近搜索：九宫格内无店铺");
            return Collections.emptyList();
        }

        // 4. 从 Redis 详情缓存中读取店铺，计算实际距离，过滤并排序
        List<StoreNearbyVO> result = new ArrayList<>();
        for (String storeId : storeIds) {
            String storeJson = redisTemplate.opsForValue().get(STORE_DETAIL_PREFIX + storeId);
            if (storeJson != null) {
                Store store = JSON.parseObject(storeJson, Store.class);
                double dist = GeoHashUtils.haversineDistance(latitude, longitude,
                        store.getLatitude(), store.getLongitude());
                if (dist <= radiusKm) {
                    result.add(toNearbyVO(store, dist));
                }
            }
        }

        // 按距离升序排序
        result.sort((a, b) -> Double.compare(a.getDistanceKm(), b.getDistanceKm()));

        log.info("附近搜索：中心({},{}) 半径{}km → 找到 {} 家店铺",
                longitude, latitude, radiusKm, result.size());
        return result;
    }

    public List<StoreNearbyVO> searchNearby(double longitude, double latitude) {
        return searchNearby(longitude, latitude, defaultRadiusKm);
    }

    private StoreNearbyVO toNearbyVO(Store store, double distanceKm) {
        StoreNearbyVO vo = new StoreNearbyVO();
        vo.setId(store.getId());
        vo.setName(store.getName());
        vo.setLongitude(store.getLongitude());
        vo.setLatitude(store.getLatitude());
        vo.setAddress(store.getAddress());
        vo.setPhone(store.getPhone());
        vo.setCategory(store.getCategory());
        vo.setDistanceKm(Math.round(distanceKm * 1000.0) / 1000.0);
        return vo;
    }