# 语法：GEOADD key longitude latitude member [longitude latitude member ...]
GEOADD g1 116.37825 39.86468 "北京南" 116.42724 39.90378 "北京站" 116.32810 39.90056 "北京西"
# 返回值：成功添加的个数（如返回 3）

# 语法：GEODIST key member1 member2 [m|km|ft|mi]
GEODIST g1 "北京南" "北京西" km
# 返回：5.7299（千米）
GEODIST g1 "北京南" "北京西" m
# 返回：5729.9533（米，米是默认单位）

GEOPOS g1 "北京站"
# 返回：116.42724 39.90378

GEOHASH g1 "北京站"
# 返回：wx4g05f66y0（相比经纬度，占用空间更小，可读性更好）

# 语法：GEOSEARCH key FROMLONLAT longitude latitude BYRADIUS radius m|km [ASC|DESC] [WITHDIST] [COUNT count]
GEOSEARCH g1 FROMLONLAT 116.397428 39.90746 BYRADIUS 10 km ASC WITHDIST
# 搜索天安门周围 10 公里内的火车站，按升序排列并返回距离
# 结果示例：北京站 2.6km、北京南 5.14km、北京西 6.6km

@SpringBootTest
class ShopGeoTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    @Autowired
    private IShopService shopService;

    @Test
    void loadShopData() {
        // 1. 查询所有商铺
        List<Shop> list = shopService.list();
        
        // 2. 按 type_id 分组（Stream API）
        Map<Long, List<Shop>> map = list.stream()
                .collect(Collectors.groupingBy(Shop::getTypeId));
        
        // 3. 分批写入 Redis
        for (Map.Entry<Long, List<Shop>> entry : map.entrySet()) {
            Long typeId = entry.getKey();
            List<Shop> shops = entry.getValue();
            
            // 构造 Key：shop:geo:typeId
            String key = RedisConstants.SHOP_GEO_KEY + typeId;
            
            // 将 Shop 转换为 GeoLocation 集合
            List<RedisGeoCommands.GeoLocation<String>> locations = new ArrayList<>(shops.size());
            for (Shop shop : shops) {
                locations.add(new RedisGeoCommands.GeoLocation<>(
                        shop.getId().toString(),
                        new Point(shop.getX(), shop.getY())
                ));
            }
            
            // 批量写入（一次性请求，效率更高）
            stringRedisTemplate.opsForGeo().add(key, locations);
        }
    }
}

<!-- 排除 Spring Boot 自带的旧版本 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </exclusion>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!-- 引入新版 -->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.6.2</version>
</dependency>
<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.1.6</version>
</dependency>

@GetMapping("/of/type")
public Result queryShopByType(
        @RequestParam("typeId") Integer typeId,
        @RequestParam(value = "current", defaultValue = "1") Integer current,
        @RequestParam(value = "x", required = false) Double x,
        @RequestParam(value = "y", required = false) Double y
) {
    return shopService.queryShopByType(typeId, current, x, y);
}

@Override
public Result queryShopByType(Integer typeId, Integer current, Double x, Double y) {
    // 1. 判断是否需要根据坐标查询
    if (x == null || x == 0 || y == null || y == 0) {
        // 不需要：按数据库查询（原有逻辑）
        Page<Shop> page = query()
                .eq("type_id", typeId)
                .page(new Page<>(current, DEFAULT_PAGE_SIZE));
        return Result.ok(page.getRecords());
    }

    // 2. 计算分页参数
    int from = (current - 1) * DEFAULT_PAGE_SIZE;
    int end = current * DEFAULT_PAGE_SIZE;

    // 3. Redis GEO 搜索
    String key = SHOP_GEO_KEY + typeId;
    GeoResults<RedisGeoCommands.GeoLocation<String>> results = stringRedisTemplate
            .opsForGeo()
            .search(
                    key,
                    GeoReference.fromCoordinate(x, y),     // 圆心：用户坐标
                    new Distance(5000),                      // 半径：5 公里
                    RedisGeoCommands.GeoSearchCommandArgs.newArgs()
                            .includeDistance()               // 带上距离
                            .sortAscending()                 // 升序（近的排前面）
                            .limit(end)                      // 查 0~end 条
            );

    // 4. 解析结果（逻辑分页）
    if (results == null) {
        return Result.ok(Collections.emptyList());
    }

    List<GeoResult<RedisGeoCommands.GeoLocation<String>>> content = results.getContent();
    
    // ⚠️ 关键判断：skip 后可能为空
    if (content.size() <= from) {
        return Result.ok(Collections.emptyList());
    }

    // 5. 手动截取 from~end 部分（Stream skip 实现逻辑分页）
    List<Long> ids = new ArrayList<>(content.size());
    Map<Long, Distance> distanceMap = new HashMap<>(content.size());

    content.stream()
            .skip(from)
            .forEach(result -> {
                String shopId = result.getContent().getName();
                ids.add(Long.valueOf(shopId));
                distanceMap.put(Long.valueOf(shopId), result.getDistance());
            });

    // 6. 根据 ID 批量查询商铺（保证有序）
    String idStr = StrUtil.join(",", ids);
    List<Shop> shops = query()
            .in("id", ids)
            .last("ORDER BY FIELD(id," + idStr + ")")
            .list();

    // 7. 将距离信息填充到商铺对象中
    for (Shop shop : shops) {
        shop.setDistance(distanceMap.get(shop.getId()).getValue());
    }

    return Result.ok(shops);
}

SELECT * FROM tb_shop WHERE id IN (3,1,5) ORDER BY FIELD(id, 3,1,5)

@TableField(exist = false)  // 非数据库字段
private Double distance;

// 错误：只判断了 results == null，没判断 skip 后是否为空
if (results == null) { return Result.ok(Collections.emptyList()); }

// 正确：补充 skip 后的空集合判断
if (content.size() <= from) {
    return Result.ok(Collections.emptyList());
}

# 添加坐标
GEOADD shop:geo:1 116.397 39.907 "1001"

# 搜索附近（5km 内，升序，带距离，限 10 条）
GEOSEARCH shop:geo:1 FROMLONLAT 116.397 39.907 BYRADIUS 5 km ASC WITHDIST COUNT 10

# 计算距离
GEODIST shop:geo:1 "1001" "1002" km

# 获取坐标
GEOPOS shop:geo:1 "1001"

# 获取 GeoHash
GEOHASH shop:geo:1 "1001"