Java 根据地图定位坐标推荐附近的目标地址（直线距离）

1、先根据当前定位和距离范围值计算出这个圆形范围的最大经纬度，这样就得出了这个圆的切线正方形；

2、再根据这个经纬度区间将符合条件的记录查询出来（包含有小部分直线距离不符合要求的记录）；

3、将查询出来的结果与定位坐标逐一计算直线距离值，剔除超出距离范围的记录

4、将结果集排序，完成！

//进行范围搜索，先按照圆切先正方形查找大概范围，再逐一计算排序
        if (space.getLongitude()!=null && space.getLatitude() != null && space.getDistance()!=null){
            String[] split = MapCountUtil.getNearbyByLongitudeAndLatitudeAndDistance(
                    BigDecimal.valueOf(space.getLongitude()),
                    BigDecimal.valueOf(space.getLatitude()),
                    space.getDistance().intValue()
            ).split("-");
            BigDecimal minlng = new BigDecimal(split[0]);
            BigDecimal maxlng = new BigDecimal(split[1]);
            BigDecimal minlat = new BigDecimal(split[2]);
            BigDecimal maxlat = new BigDecimal(split[3]);
            queryWrapper.ge("s.latitude",minlat)
                    .ge("s.longitude",minlng)
                    .le("s.latitude",maxlat)
                    .le("s.longitude",maxlng);
        }

//查询出圆切线正方形的结果集
        List<SpaceVo> listTemp = spaceMapper.selectListInstall(queryWrapper);
        //计算并排序
        List<SpaceVo> list = new ArrayList<>();
        if (space.getLatitude()!=null && space.getLongitude()!=null){
            for (SpaceVo item : listTemp){
                SpaceVo vo = new SpaceVo();
                BeanUtils.copyProperties(item, vo);
                Double distance = MapCountUtil.getDistance(
                        BigDecimal.valueOf(space.getLongitude()),
                        BigDecimal.valueOf(space.getLatitude()),
                        BigDecimal.valueOf(item.getLongitude()),
                        BigDecimal.valueOf(item.getLatitude()));

                vo.setDistance(distance);
                if (space.getDistance()!=null){
                    if (space.getDistance() > (vo.getDistance()/1000)){
                        list.add(vo);
                    }
                }else {
                    list.add(vo);
                }
            }
            Collections.sort(list, Comparator.comparing(SpaceVo::getDistance));
        }else {
            list = listTemp;
        }

import java.math.BigDecimal;

/**
 * 地图计算工具类
 */
public class MapCountUtil {


    /**
     *
     * @Description   计算给定经纬度附近相应公里数的经纬度范围
     * @param         longitude 经度
     * @param         latitude 纬度
     * @param         distance 距离（千米）
     * @return        String 格式：经度最小值-经度最大值-纬度最小值-纬度最大值
     * @Data          2020.06.19
     **/
    public static String getNearbyByLongitudeAndLatitudeAndDistance(BigDecimal longitude, BigDecimal latitude, Integer distance) {
        // 地球半径千米
        double r = 6371.393;
        double lng = longitude.doubleValue();
        double lat = latitude.doubleValue();
        double dlng = 2 * Math.asin(Math.sin(distance / (2 * r)) / Math.cos(lat * Math.PI / 180));
        // 角度转为弧度
        dlng = dlng * 180 / Math.PI;
        double dlat = distance / r;
        dlat = dlat * 180 / Math.PI;
        double minlat = lat - dlat;
        double maxlat = lat + dlat;
        double minlng = lng - dlng;
        double maxlng = lng + dlng;

        return minlng + "-" + maxlng + "-" + minlat + "-" + maxlat;
    }

    /**
     * @Description     根据经纬度获取两点之间的距离
     * @param           longitude1   地点1经度
     * @param           latitude1    地点1纬度
     * @param           longitude2   地点2经度
     * @param           latitude2    地点2纬度
     * @return          距离：单位 米
     */
    public static Double getDistance(BigDecimal longitude1, BigDecimal latitude1, BigDecimal longitude2, BigDecimal latitude2) {
        // 地球半径千米
        double r = 6371.393;
        double lat1 = latitude1.doubleValue();
        double lng1 = longitude1.doubleValue();
        double lat2 = latitude2.doubleValue();
        double lng2 = longitude2.doubleValue();
        double radLat1 = rad(lat1);
        double radLat2 = rad(lat2);
        double a = radLat1 - radLat2;
        double b = rad(lng1) - rad(lng2);
        double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a/2),2) +
                Math.cos(radLat1)*Math.cos(radLat2)*Math.pow(Math.sin(b/2),2)));
        s = s * r;
        s = Math.round(s * 1000);
        return s;
    }

    private static Double rad(double d) {
        return d * Math.PI / 180.0;
    }
}