SpringBoot集成redis的LBS功能

下面的代码实现了添加经纬度数据 和 搜索经纬度数据的功能：

import java.util.List;

import com.longge.goods.dto.BuildingDto;
import com.longge.goods.dto.BuildingLbsDto;

/**
 * LBS相关的服务
 * @author yangzhilong
 *
 */
public interface LbsService {
    /**
     * 新增或者修改楼宇的经纬度
     * @param buildDto
     */
    void saveBuildingLonAndLat(BuildingDto buildDto);

    /**
     * 查询指定经纬度附近的楼宇
     * @param lon 经度
     * @param lat 纬度
     * @param limit 记录数
     * @return
     */
    List<BuildingLbsDto> listNearbyBuilding(double lon, double lat, int limit);

}

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import javax.annotation.Resource;

 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.geo.Circle;
 import org.springframework.data.geo.Distance;
 import org.springframework.data.geo.GeoResults;
 import org.springframework.data.geo.Metrics;
 import org.springframework.data.geo.Point;
 import org.springframework.data.redis.connection.RedisGeoCommands;
 import org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation;
 import org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs;
 import org.springframework.data.redis.core.GeoOperations;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.util.CollectionUtils;

 import com.alibaba.fastjson.JSONObject;
 import com.longge.core.util.BeanMapper;
 import com.longge.goods.api.BuildingService;
 import com.longge.goods.api.LbsService;
 import com.longge.goods.constants.BuildingConstant;
 import com.longge.goods.dto.BuildingDto;
 import com.longge.goods.dto.BuildingLbsDto;
 import com.longge.goods.util.GoodsRedisKeyUtils;

 import lombok.extern.slf4j.Slf4j;

 @Service
 @Slf4j
 public class LbsServiceImpl implements LbsService {
     @Autowired
     private BuildingService buildingService;
     // 搜索范围
     @Value("${lbs.distance:3}")
     private Double lbsDistance;
     @Resource
     private StringRedisTemplate redisTemplate;

     @Override
     public void saveBuildingLonAndLat(BuildingDto buildDto) {
         log.info("开始处理楼宇的经纬度数据,楼宇：{}", JSONObject.toJSONString(buildDto));
         GeoOperations<String, String> ops = redisTemplate.opsForGeo();
         String member = String.valueOf(buildDto.getId());
         // 查询楼宇的geo数据是否存在
         List<String> list = ops.hash(GoodsRedisKeyUtils.getBuildingLbsKey(), member);
         if (!CollectionUtils.isEmpty(list)) {
             log.info("该楼宇数据存在，先进行删除操作");
             // 存在，先删除，后新增
             ops.remove(GoodsRedisKeyUtils.getBuildingLbsKey(), member);
         }
         ops.add(GoodsRedisKeyUtils.getBuildingLbsKey(),
                 new RedisGeoCommands.GeoLocation<String>(member, new Point(buildDto.getLon(), buildDto.getLat())));
         log.info("楼宇经纬度信息处理完成");
     }

     @Override
     public List<BuildingLbsDto> listNearbyBuilding(double lon, double lat, int limit) {
         log.info("查询LBS楼宇信息，经度：{}，纬度：{}，条数：{}", lon, lat, limit);
         GeoOperations<String, String> ops = redisTemplate.opsForGeo();

         // 获取redis里全局的配置，实现参数动态化
         String redisLbsDistance = (String)RedisCache.hGet("config:global", "lbsDistance");
         if(StringUtils.isNotBlank(redisLbsDistance)) {
             lbsDistance = Double.valueOf(redisLbsDistance);
         }

         Point center = new Point(lon, lat);
         Distance radius = new Distance(lbsDistance, Metrics.KILOMETERS);
         Circle within = new Circle(center, radius);
         // order by 距离 limit 20 ，同时返回距离中心点的距离
         GeoRadiusCommandArgs args = GeoRadiusCommandArgs.newGeoRadiusArgs().includeDistance().limit(limit).sortAscending();

         GeoResults<GeoLocation<String>> result = ops.radius(GoodsRedisKeyUtils.getBuildingLbsKey(), within, args);
         log.info("查询redis后的经纬度数据：{}", JSONObject.toJSONString(result));
         if(null != result) {
             Map<Long, Double> data = new HashMap<>();
             List<Long> buildings = new ArrayList<>();

             result.forEach(item -> {
                 data.put(Long.valueOf(item.getContent().getName()), item.getDistance().getValue());
                 buildings.add(Long.valueOf(item.getContent().getName()));
             });
             if(!CollectionUtils.isEmpty(buildings)) {
                 List<BuildingDto> buildingList = buildingService.getBuildList(buildings);
                 if(!CollectionUtils.isEmpty(buildingList)) {
                     List<BuildingLbsDto> resp = new ArrayList<>();
                     buildingList.stream().forEach(item -> {
                         BuildingLbsDto dto = BeanMapper.map(item, BuildingLbsDto.class);
                         if(BuildingConstant.BuildingStatusEnum.OPENED.getValue() == dto.getStatus()) {
                             dto.setDistance(data.get(item.getId()));
                             resp.add(dto);
                         }
                     });
                     log.info("查询LBS楼宇信息的结果：{}", JSONObject.toJSONString(resp));
                     return resp;
                 }
             }
         }
         log.warn("未查询LBS楼宇信息");
         return null;
     }
 }

import java.util.Date;

/**
 * 楼宇信息dto
 *
 */
@Data
public class BuildingDto {
    private Long id;

    private Short status;
    /**
     * 纬度
     */
    private Double lat;
    /**
     * 经度
     */
    private Double lon;
}

import java.io.Serializable;

import lombok.Getter;
import lombok.Setter;

/**
 * 包含距离定位点距离的楼宇dto
 * @author yangzhilong
 *
 */
@Getter
@Setter
public class BuildingLbsDto extends BuildingDto implements Serializable{
    /**
     *
     */
    private static final long serialVersionUID = 3224249189169148012L;
    // 距离，单位：千米
    private Double distance;
}