1
2
3
4
5

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

1
2
3
4
5
6
7
8

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;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

   private SpatialContext spatialContext = SpatialContext.GEO;    









   @GetMapping("/nearby")
   public String nearBySearch(@RequestParam("distance") double distance,
                              @RequestParam("userLng") double userLng,
                              @RequestParam("userLat") double userLat) {
       
       Rectangle rectangle = getRectangle(distance, userLng, userLat);
       
       List<User> users = userMapper.selectUser(rectangle.getMinX(), rectangle.getMaxX(), rectangle.getMinY(), rectangle.getMaxY());
       
       users = users.stream()
           .filter(a -> getDistance(a.getLongitude(), a.getLatitude(), userLng, userLat) <= distance)
           .collect(Collectors.toList());
       return JSON.toJSONString(users);
   }
   private Rectangle getRectangle(double distance, double userLng, double userLat) {
       return spatialContext.getDistCalc()
           .calcBoxByDistFromPt(spatialContext.makePoint(userLng, userLat), 
                                distance * DistanceUtils.KM_TO_DEG, spatialContext, null);
   }

1
2
3
4
5
6

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

1
2
3
4
5
6
7
8
9
10

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;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

private SpatialContext spatialContext = SpatialContext.GEO;





@PostMapping("/addUser")
public boolean add(@RequestBody UserGeohash user) {
    
    String geoHashCode = GeohashUtils.encodeLatLon(user.getLatitude(),user.getLongitude());
    return userGeohashService.save(user.setGeoCode(geoHashCode).setCreateTime(LocalDateTime.now()));
}











@GetMapping("/nearby")
public String nearBySearch(@RequestParam("distance") double distance,
                           @RequestParam("len") int len,
                           @RequestParam("userLng") double userLng,
                           @RequestParam("userLat") double userLat) {
    
    String geoHashCode = GeohashUtils.encodeLatLon(userLat, userLng, len);
    QueryWrapper<UserGeohash> queryWrapper = new QueryWrapper<UserGeohash>()
            .likeRight("geo_code",geoHashCode);
    
    List<UserGeohash> users = userGeohashService.list(queryWrapper);
    
    users = users.stream()
            .filter(a ->getDistance(a.getLongitude(),a.getLatitude(),userLng,userLat)<= distance)
            .collect(Collectors.toList());
    return JSON.toJSONString(users);
}









private double getDistance(Double longitude, Double latitude, double userLng, double userLat) {
    return spatialContext.calcDistance(spatialContext.makePoint(userLng, userLat),
            spatialContext.makePoint(longitude, latitude)) * DistanceUtils.DEG_TO_KM;
}

1
2
3
4
5

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

@GetMapping("/nearby")
public String nearBySearch(@RequestParam("distance") double distance,
                           @RequestParam("len") int len,
                           @RequestParam("userLng") double userLng,
                           @RequestParam("userLat") double userLat) {


    
    GeoHash geoHash = GeoHash.withCharacterPrecision(userLat, userLng, len);
    
    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()));

    
    List<UserGeohash> users = userGeohashService.list(queryWrapper);
    
    users = users.stream()
            .filter(a ->getDistance(a.getLongitude(),a.getLatitude(),userLng,userLat)<= distance)
            .collect(Collectors.toList());
    return JSON.toJSONString(users);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

   @Autowired
   private RedisTemplate<String, Object> redisTemplate;


   private final static String KEY = "user_info";

   public boolean save(User user) {
       Long flag = redisTemplate.opsForGeo().add(KEY, new RedisGeoCommands.GeoLocation<>(
               user.getName(), 
               new Point(user.getLongitude(), user.getLatitude()))
       );
       return flag != null && flag > 0;
   }

   






   public String nearBySearch(double distance, double userLng, double userLat) {
       List<User> users = new ArrayList<>();
       
       GeoResults<RedisGeoCommands.GeoLocation<Object>> reslut = 
           redisTemplate.opsForGeo().radius(KEY, 
                       new Circle(new Point(userLng, userLat), new Distance(distance, Metrics.KILOMETERS)),
                       RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
                               .includeDistance()
                               .includeCoordinates().sortAscending());
       
       List<GeoResult<RedisGeoCommands.GeoLocation<Object>>> content = reslut.getContent();
       
       content.forEach(a-> users.add(
               new User().setDistance(a.getDistance().getValue())
               .setLatitude(a.getContent().getPoint().getX())
               .setLongitude(a.getContent().getPoint().getY())));
       return JSON.toJSONString(users);
   }