附近的人功能如何设计

GEOADD nearby:users 116.404 39.915 user:1001

GEORADIUS nearby:users 116.405 39.916 5 km WITHDIST COUNT 20 ASC

GEOADD {nearby}:users ...

<!-- Spring Data Redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

@Configuration
public class RedisConfig {
    @Bean
    public RedisGeoCommands<String, String> redisGeoCommands(RedisConnectionFactory factory) {
        return RedisTemplate.create(factory).opsForGeo();
    }
}

@Service
@RequiredArgsConstructor
public class NearUserService {

    private final RedisGeoCommands<String, String> redisGeoCommands;
    // Redis Key：存储所有用户位置
    private static final String GEO_KEY = "user:location";

    // ====================== 1. 上报用户位置 ======================
    public void reportUserLocation(Long userId, double longitude, double latitude) {
        // 技术亮点：使用 Point 封装经纬度
        Point point = new Point(longitude, latitude);
        // 存入 Redis Geo
        redisGeoCommands.add(GEO_KEY, point, userId.toString());
    }

    // ====================== 2. 查询附近的人（核心接口） ======================
    public List<NearUserDTO> nearByPeople(double longitude, double latitude, int radiusMeter) {
        // 1. 构造查询原点
        Point point = new Point(longitude, latitude);
        // 2. 构造距离范围（米）
        Distance distance = new Distance(radiusMeter, RedisGeoCommands.DistanceUnit.METERS);
        // 3. 构造查询参数：限制返回数量 + 携带距离
        RedisGeoCommands.GeoRadiusCommandArgs args = RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
                .includeDistance()   // 返回距离（面试加分点）
                .sortAscending()     // 由近到远排序
                .limit(50);          // 只查50个，防止大流量

        // 4. 执行 Redis 附近查询
        GeoResults<GeoLocation<String>> results = redisGeoCommands.radius(
                GEO_KEY, point, distance, args
        );

        // 5. 封装返回结果
        List<NearUserDTO> list = new ArrayList<>();
        for (GeoResult<GeoLocation<String>> result : results) {
            NearUserDTO dto = new NearUserDTO();
            dto.setUserId(Long.valueOf(result.getContent().getName()));
            dto.setDistance(result.getDistance().getValue()); // 距离（米）
            list.add(dto);
        }
        return list;
    }
}

@Data
public class NearUserDTO {
    private Long userId;
    private Double distance; // 距离多少米
    // 可扩展：昵称、头像、性别、年龄等
}

// 用户上报位置，同时刷新在线心跳
public void updateLocation(String userId, double lng, double lat) {
    String geoKey = resolveGeoKey(lng, lat);  // 按城市分片，如 "{beijing}:nearby:users"
    String onlineKey = "online:heartbeat";
    long now = System.currentTimeMillis();
    
    // 使用 Lettuce 异步 + Pipeline 减少 RTT
    redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
        byte[] geoKeyBytes = geoKey.getBytes();
        byte[] member = userId.getBytes();
        // GEOADD key longitude latitude member
        connection.geoCommands().geoAdd(geoKeyBytes, new Point(lng, lat), member);
        // 同时更新在线心跳 ZSET，score = 当前时间戳
        connection.zSetCommands().zAdd(onlineKey.getBytes(), now, member);
        return null;
    });
}

public List<NearbyUser> searchNearby(double lng, double lat, double radiusKm, int page, int size) {
    String geoKey = resolveGeoKey(lng, lat);
    // Redis Geo 不支持游标分页，这里用 COUNT 加客户端 offset 模拟
    // 注意：大 offset 性能差，业务限制最大页数
    int maxPage = 10;
    if (page > maxPage) return Collections.emptyList();
    
    RedisGeoCommands.GeoRadiusCommandArgs args = RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
            .includeDistance()
            .sortAscending()
            .limit(size * maxPage);  // 多取一些，后面根据 offset 截断
    
    // GEORADIUS key longitude latitude radius km WITHDIST ASC
    GeoResults<RedisGeoCommands.GeoLocation<String>> results =
            redisTemplate.opsForGeo().radius(geoKey,
                    new Circle(new Point(lng, lat), new Distance(radiusKm, Metrics.KILOMETERS)),
                    args);
    
    if (results == null) return Collections.emptyList();
    
    // 截断分页
    List<GeoResult<RedisGeoCommands.GeoLocation<String>>> content = results.getContent();
    int start = (page - 1) * size;
    int end = Math.min(start + size, content.size());
    if (start >= content.size()) return Collections.emptyList();
    
    List<String> userIds = content.subList(start, end).stream()
            .map(g -> g.getContent().getName())
            .collect(Collectors.toList());
    
    // 批量加载用户信息：先查 Redis 缓存，缺失的批量查 DB，再回填缓存
    return batchLoadUserInfo(userIds);
}

private List<NearbyUser> batchLoadUserInfo(List<String> userIds) {
    // 1. 先批量从 Redis 缓存获取
    List<String> cacheKeys = userIds.stream().map(id -> "user:info:" + id).collect(Collectors.toList());
    List<Object> cachedData = redisTemplate.opsForValue().multiGet(cacheKeys);
    
    // 2. 找出缓存未命中的 ID，并过滤掉布隆过滤器认为不存在的非法 ID
    List<String> missedIds = new ArrayList<>();
    for (int i = 0; i < userIds.size(); i++) {
        if (cachedData.get(i) == null) {
            String uid = userIds.get(i);
            if (bloomFilter.mightContain(uid)) {  // 可能存在的才去查 DB
                missedIds.add(uid);
            }
        }
    }
    
    // 3. 批量查 DB（使用 IN 查询）
    Map<String, User> dbResult = Collections.emptyMap();
    if (!missedIds.isEmpty()) {
        List<User> users = userMapper.selectBatchIds(missedIds);
        dbResult = users.stream().collect(Collectors.toMap(User::getId, u -> u));
        // 回填缓存（异步批量写入）
        cacheService.asyncBatchPut(dbResult);
    }
    
    // 4. 组装结果，保持原有排序
    return userIds.stream().map(id -> {
        Object cached = cachedData.get(userIds.indexOf(id));
        if (cached != null) {
            return buildNearbyUser((User)cached);
        }
        User u = dbResult.get(id);
        if (u != null) return buildNearbyUser(u);
        // 非法用户标记，布隆过滤器也加上（这里忽略详细）
        return null;
    }).filter(Objects::nonNull).collect(Collectors.toList());
}

// 定时任务，每分钟执行一次，清除心跳超过 3 分钟的用户
private String CLEAN_SCRIPT = 
    "local members = redis.call('ZRANGEBYSCORE', KEYS[1], 0, ARGV[1]) " +
    "if #members > 0 then " +
    "   redis.call('ZREM', KEYS[1], unpack(members)) " +
    "   for i, member in ipairs(members) do " +
    "       local geoKey = redis.call('GET', 'user:geo:key:' .. member) " +
    "       if geoKey then redis.call('ZREM', geoKey, member) end " +
    "   end " +
    "   return #members " +
    "else return 0 end";

public void cleanOfflineUsers() {
    long expireTimestamp = System.currentTimeMillis() - 180_000; // 3分钟前
    // 在 Redis Cluster 中需要针对每个分片执行，这里简略
    Long removed = redisTemplate.execute(
            new DefaultRedisScript<>(CLEAN_SCRIPT, Long.class),
            Collections.singletonList("online:heartbeat"),
            String.valueOf(expireTimestamp));
    log.info("Cleaned {} offline users", removed);
}