MySQL 实现附近人功能纯属学习，并不好用，推荐使用 Search，方案对比：

MySQL依然可以实现附近的人的功能，两种方案，

方案一：Mysql+外接正方形

实现思路：

以当前用户为圆心，以给定距离为半径画圆，那么在这个圆内的所有用户信息就是符合结果的信息，直接检索圆内的用户坐标难以实现，

我们可以通过获取这个圆的外接正方形。

通过外接正方形，获取经度和纬度的最大最小值，根据最大最小值可以将坐标在正方形内的用户信息搜索出来。

此时在外接正方形中不属于圆形区域的部分就属于多余的部分，这部分用户信息距离当前用户（圆心）的距离必定是大于给定半径的，

故可以将其剔除，最终获得指定范围内的附近的人

存储经纬度坐标用的数类型：数据类型为double（10,6）

将地理位置的经度、纬度 分开存储在数据库中:

根据定位中心和半径范围，得出经度的最大值最小值，纬度的最大值最小值，即一个正方形范围，得到范围内的对象集合，

再遍历对象集合，分别计算每个对象的距离是否满足距离小于等于半径，过滤掉不满足条件的对象，即可实现附近的人

求距离 S 半径内的对象时有一部分对象时在圆之外的四个三角区域，若换个思路，求S1 半径范围内的对象

这样得到的对象就都是范围内的对象，若 S1 范围内的对象不够再查找 S 范围的对象进行过滤

 计算给定中心坐标，半径范围内的经纬度范围(单位需要统一，用米/或者KM都可以)

public class GeoUtils {
   //地球半径（米）
   private static final double EARTH_RADIUS = 6371000d;
   //弧度
   public static final double RADIANS_TO_DEGREES = 180 / Math.PI;
   public static final double DEGREES_TO_RADIANS = Math.PI / 180;
 
 
   /**
    * 根据中心点经纬度，计算半径范围内的经纬度范围
    *
    * @param centerLon 中心点经度
    * @param centerLat 中心点纬度
    * @param dist      半径范围(米)
    * @return
    */
   public static Map<String, Double> findPosition(double centerLon, double centerLat, double dist) {
 
      //先计算查询点的经纬度范围
      double lonRad = 2 * Math.asin(Math.sin(dist / (2 * EARTH_RADIUS)) / Math.cos(centerLat * Math.PI / 180));
      //角度转为弧度
      lonRad = lonRad * RADIANS_TO_DEGREES;
      double latRad = dist / EARTH_RADIUS;
      latRad = latRad * 180 / Math.PI;
      //经度最小值
      double minLon = centerLon - lonRad;
      //经度最大值
      double maxLon = centerLon + lonRad;
      //纬度最小值
      double minLat = centerLat - latRad;
      //纬度最大值
      double maxLat = centerLat + latRad;
 
      HashMap<String, Double> geoMap = new HashMap<>();
      geoMap.put("minLat", minLat);
      geoMap.put("maxLat", maxLat);
      geoMap.put("minLon", minLon);
      geoMap.put("maxLon", maxLon);
      return geoMap;
   }
   
   /**
    * 求地球表面两点间的距离
    *
    * @param centerLon 中心点经度
    * @param centerLat 中心点纬度
    * @param targetLon 目标经度
    * @param targetLat 目标纬度
    * @return
    */
   public static double getDistance(double centerLon, double centerLat, double targetLon, double targetLat) {
 
      //计算中心点经纬度弧度
      double centerLonRad = centerLon * DEGREES_TO_RADIANS;
      double centerLatRad = centerLat * DEGREES_TO_RADIANS;
      //计算目标点经纬度弧度
      double targetLonRad = targetLon * DEGREES_TO_RADIANS;
      double targetLatRad = targetLat * DEGREES_TO_RADIANS;
      //计算经纬度的差
      double diffX = Math.abs(centerLonRad - targetLonRad);
      double diffY = Math.abs(centerLatRad - targetLatRad);
      //计算正弦
      double hsinX = Math.sin(diffX / 2);
      double hsinY = Math.sin(diffY / 2);
      //计算余弦
      double centerLatRad_cos = Math.cos(centerLatRad);
      double targetLatRad_cos = Math.cos(targetLatRad);
 
      double h = power(hsinY, 2) + (centerLatRad_cos * targetLatRad_cos * power(hsinX, 2));
      //两点的距离
      double dist = EARTH_RADIUS * 2 * Math.atan2(Math.sqrt(h), Math.sqrt(1 - h));
      return dist;
   }
 
   /**
    * 经纬度剔除小数点(直接剔除不舍入)，保留6位
    *
    * @param number 经度/纬度
    * @return
    */
   public static Double geoRound6Pla(Double number) {
      BigDecimal numDigd = new BigDecimal(number);
      number = numDigd.setScale(6, BigDecimal.ROUND_DOWN).doubleValue();
      return number;
   }
 
   public static void main(String[] args) {
      //中心点经纬度
      double x1 = 102.604646;
      double y1 = 24.239485;
 
      //目标点经纬度
      double x2 = 103.634895;
      double y2 = 24.778173;
 
      Map<String, Double> position = GeoUtils.findPosition(x1, y1, 130000 );
      double distance = GeoUtils.getDistance(x1, y1, x2, y2);
      System.out.println(position);
      System.out.println(distance);
   }
}

打印：

{
  minLon=101.32248517333221, 
  maxLat=25.40860308769435, 
  minLat=23.070366912305648, 
  maxLon=103.8868068266678
}
 
120220.59030376052

使用示例

Long distance = NOTICE_DISTANCE;
   publishNotice.setGeoLat(null);
   publishNotice.setGeoLon(null);
   Map<String, Double> geoMap = GeoUtils.findPosition(X, Y, distance);
   Double minLat = geoMap.get("minLat");
   Double maxLat = geoMap.get("maxLat");
   Double minLon = geoMap.get("minLon");
   Double maxLon = geoMap.get("maxLon");
   //保留6位小数点（尽量取多的小数点，保证计算精度）
   minLat = GeoUtils.geoRound6Pla(minLat);
   maxLat = GeoUtils.geoRound6Pla(maxLat);
   minLon = GeoUtils.geoRound6Pla(minLon);
   maxLon = GeoUtils.geoRound6Pla(maxLon);
   //组装SQL语句
   query.between("geo_lon", minLon, maxLon)
         .between("geo_lat", minLat, maxLat);
   iPage = page(page, query);
   noticeList = iPage.getRecords();
   noticeList = this.distFilter(noticeList, X, Y, distance);
}

过滤距离超过指定距离的

/**
 * 计算距离,过滤超出距离范围的元素
 *
 * @param noticeList 通告集合
 * @param centerLon  中心位置经度
 * @param centerLat  中心位置纬度
 * @param distance   距离半径
 */
private List<PublishNotice> distFilter(List<PublishNotice> noticeList, Double centerLon, Double centerLat, Long distance) {
   noticeList = noticeList.parallelStream()
         .map(notice -> {
            Double geoLon = notice.getGeoLon();
            Double geoLat = notice.getGeoLat();
            double dist = GeoUtils.getDistance(centerLon, centerLat, geoLon, geoLat);
            notice.setDistance(Math.round(dist));
            return notice;
         }).filter(notice -> notice.getDistance() <= distance)
         .sorted(Comparator.comparing(PublishNotice::getDistance))
         .collect(Collectors.toList());
   return noticeList;
}

使用框架依赖不用自己写计算工具类：

在实现附近的人搜索中，需要根据位置经纬度点，进行一些距离和范围的计算，比如求球面外接正方形的坐标点，球面两坐标点的距离等，可以引入Spatial4j 库。

<dependency>
    <groupId>com.spatial4j</groupId>
    <artifactId>spatial4j</artifactId>
    <version>0.5</version>
</dependency>

建表举例：

CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL COMMENT '名称',
`longitude` double DEFAULT NULL COMMENT '经度',
`latitude` double DEFAULT NULL COMMENT '纬度',
`create_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

public class User {
    private int id;
    private String name;
    private double longitude;//经度,
    private double latitude;//纬度,
    private LocalDateTime createTime;//创建时间,
}

Controller方法

public class GeoTestController {
 
    private SpatialContext spatialContext = SpatialContext.GEO;
 
    /**
     * 获取附近x米的人
     *
     * @param distance 距离范围 单位km
     * @param userLng  当前经度
     * @param userLat  当前纬度
     * @return json
     */
    @GetMapping("/nearby")
    public String nearBySearch(@RequestParam("distance") double distance,
                               @RequestParam("userLng") double userLng,
                               @RequestParam("userLat") double userLat) {
        //1.获取外接正方形
        Rectangle rectangle = getRectangle(distance, userLng, userLat);
        //2.获取位置在正方形内的所有用户
        List<User> users = userMapper.selectUser(rectangle.getMinX(), rectangle.getMaxX(), rectangle.getMinY(), rectangle.getMaxY());
        //3.剔除半径超过指定距离的多余用户
        users = users.stream()
                .filter(a -> getDistance(a.getLongitude(), a.getLatitude(), userLng, userLat) <= distance)
                .collect(Collectors.toList());
        return JSON.toJSONString(users);
    }
 
    /**
     * 中心坐标和半径距离，获取方形经纬度范围
     *
     * @param distance 距离半径
     * @param lon      经度
     * @param lat      纬度
     * @return
     */
    private Rectangle getRectangle(double distance, double lon, double lat) {
        Rectangle rectangle = spatialContext.getDistCalc()
                .calcBoxByDistFromPt(spatialContext.makePoint(lon, lat),
                        distance * DistanceUtils.KM_TO_DEG, spatialContext, null);
        return rectangle;
    }
}

 Mapper文件的SQL语句：

<select id="selectUser" resultMap="BaseResultMap">
    SELECT * FROM user
    WHERE 1=1
    and (longitude BETWEEN ${minlng} AND ${maxlng})
    and (latitude BETWEEN ${minlat} AND ${maxlat})
</select>

方案二：Mysql+geohash

引入了geohash算法，同时在查询上借助索引

geohash被广泛应用于位置搜索类的业务中，本文不对它进行展开说明，有兴趣的同学可以看一下这篇博客:  https://www.cnblogs.com/LBSer/p/3310455.html

GeoHash算法将经纬度坐标点编码成一个字符串,距离越近的坐标，转换后的geohash字符串越相似,例如下表数据：

其中根据经纬度计算得到的geohash字符串，不同精度（字符串长度）代表了不同的距离误差。具体的不同精度的距离误差可参考下表：

实现思路：

• 使用Mysql存储用户信息，其中包括用户的经纬度信息和geohash字符串。
• 添加新用户时计算该用户的geohash字符串，并存储到用户表中
• 当要查询某一gps附近指定距离的用户信息时，通过比对geohash误差表确定需要的geohash字符串精度
• 计算获得某一精度的当前坐标的geohash字符串，通过WHERE geohash Like 'geohashcode%'来查询数据集
• 如果geohash字符串的精度远大于给定的距离范围时，查询出的结果集中必然存在在范围之外的数据

计算两点之间距离，对于超出距离的数据进行剔除。

建表结构：

CREATE TABLE `user_geohash` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL COMMENT '名称',
  `longitude` double DEFAULT NULL COMMENT '经度',
  `latitude` double DEFAULT NULL COMMENT '纬度',
  `geo_code` varchar(64) DEFAULT NULL COMMENT '经纬度所计算的geohash码',
  `create_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`),
  KEY `index_geo_hash` (`geo_code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Java Bean

public class UserGeohash {
 
    private int id;
    private String name;
    private double longitude;//经度,
    private double latitude;//纬度,
    private String geoCode;
    private LocalDateTime createTime;//创建时间,
 ｝

控制层

public class GeoHashController {
 
    private SpatialContext spatialContext = SpatialContext.GEO;
 
    /***
     * 添加用户
     * @return
     */
    @PostMapping("/addUser")
    public boolean add(@RequestBody UserGeohash user) {
        //默认精度12位
        String geoHashCode = GeohashUtils.encodeLatLon(user.getLatitude(), user.getLongitude());
        return userGeohashService.save(user.setGeoCode(geoHashCode), user.setCreateTime(LocalDateTime.now()));
    }
 
 
    /**
     * 获取附近指定范围的人
     *
     * @param distance 距离范围 单位km
     * @param len      geoHash的精度
     * @param userLng  当前经度
     * @param userLat  当前纬度
     * @return json
     */
    @GetMapping("/nearby")
    public String nearBySearch(@RequestParam("distance") double distance,
                               @RequestParam("len") int len,
                               @RequestParam("userLng") double userLng,
                               @RequestParam("userLat") double userLat) {
        //1.根据要求的范围，确定geoHash码的精度，获取到当前用户坐标的geoHash码
        String geoHashCode = GeohashUtils.encodeLatLon(userLat, userLng, len);
        QueryWrapper<UserGeohash> queryWrapper = new QueryWrapper<UserGeohash>()
                .likeRight("geo_code", geoHashCode);
        //2.匹配指定精度的geoHash码
        List<UserGeohash> users = userGeohashService.list(queryWrapper);
        //3.过滤超出距离的
        users = users.stream()
                .filter(a -> getDistance(a.getLongitude(), a.getLatitude(), userLng, userLat) <= distance)
                .collect(Collectors.toList());
        return JSON.toJSONString(users);
    }
 
    /***
     * 球面中，两点间的距离
     * @param longitude 经度1
     * @param latitude  纬度1
     * @param userLng   经度2
     * @param userLat   纬度2
     * @return 返回距离，单位km
     */
    private double getDistance(Double longitude, Double latitude, double userLng, double userLat) {
        double distance = spatialContext.calcDistance(spatialContext.makePoint(userLng, userLat),
                spatialContext.makePoint(longitude, latitude)) * DistanceUtils.DEG_TO_KM;
        return distance;
    }
}

通过上面几步，就可以实现这一业务场景，不仅提高了查询效率，并且保护了用户的隐私，不对外暴露坐标位置。并且对于同一位置的频繁请求，如果是同一个geohash字符串，可以加上缓存，减缓数据库的压力。

边界优化问题：

geohash算法将地图分为一个个矩形，对每个矩形进行编码，得到geohash码，但是当前点与待搜索点距离很近但是恰好在两个区域，用上面的方法则就不适用了。解决这一问题的办法：获取当前点所在区域附近的8个区域的geohash码，一并进行筛选。

如何求解附近的8个区域的geohash码可参考 : https://blog.csdn.net/dokd229933/article/details/47021515  了解了思路，这里我们可以使用第三方开源库ch.hsr.geohash来计算，通过maven引入

<dependency>
    <groupId>ch.hsr</groupId>
    <artifactId>geohash</artifactId>
    <version>1.0.10</version>
</dependency>

/**
 * 获取附近指定范围的人
 *
 * @param distance 距离范围 单位km
 * @param len      geoHash的精度
 * @param userLng  当前经度
 * @param userLat  当前纬度
 * @return json
 */
@GetMapping("/nearby")
public String nearBySearch(@RequestParam("distance") double distance,
                           @RequestParam("len") int len,
                           @RequestParam("userLng") double userLng,
                           @RequestParam("userLat") double userLat) {
 
    //1.根据要求的范围，确定geoHash码的精度，获取到当前用户坐标的geoHash码
    GeoHash geoHash = GeoHash.withCharacterPrecision(userLat, userLng, len);
    //2.获取到用户周边8个方位的geoHash码
    GeoHash[] adjacent = geoHash.getAdjacent();
 
    QueryWrapper<UserGeohash> queryWrapper = new QueryWrapper<UserGeohash>()
            .likeRight("geo_code",geoHash.toBase32());
    Stream.of(adjacent).forEach(a -> queryWrapper.or().likeRight("geo_code",a.toBase32()));
 
    //3.匹配指定精度的geoHash码
    List<UserGeohash> users = userGeohashService.list(queryWrapper);
    //4.过滤超出距离的
    users = users.stream()
            .filter(a ->getDistance(a.getLongitude(),a.getLatitude(),userLng,userLat)<= distance)
            .collect(Collectors.toList());
    return JSON.toJSONString(users);
}