JAVA实现空间索引编码（GeoHash）

转载请注明出处：http://blog.csdn.net/xiaojimanman/article/details/50358506

http://www.llwjy.com/blogdetail/95468c5334d1c3fe52ae2149abfb0da0.html

个人博客站已经上线了，网址 www.llwjy.com ~欢迎各位吐槽~

-------------------------------------------------------------------------------------------------

      之前自己在做基于Lucene的内容检索过程中，了解到Lucene可以实现对文本信息，数值信息的内容检索，对于空间距离好像并为为源码中实现；最近半年自己接触到Solr，里面有一个空间距离检索（经纬度），最近对其中的实现做了下学习，了解到在实现空间距离检索的有一个比较常用的技术——GeoHash，下面就介绍下GeoHash。

GeoHash特点

1）GeoHash用一个字符串表示经度和纬度两个坐标，比如我现在所在位置的GeoHash值为 wx4sv61q；

2）GeoHash标识的并不是一个点，而是一个区域，比如 wx4sv61q 对应的就是一个矩形区域；

3）编码的前缀可以标识更大的区域，比如 wx4sv61 编码代表的区域要大于 wx4sv61q 代表的区域，但是 wx4sv61q 代表的区域一定在 wx4sv61 代表的区域内。

      因此我们再去做距离检索的时候，只需要对GeoHash进行前缀匹配即可，具体的原因在后面内容进行介绍。

GeoHash原理

      GeoHash最简单的解释就是将一个位置信息转化成一个可以排序、可以比较的字符串编码。下面就详细介绍以下其实现过程：

      维基百科对GeoHash的介绍：https://en.wikipedia.org/wiki/Geohash

      首先我们将纬度(-90, 90)平均分成两个区间(-90, 0)、(0, 90)，如果坐标位置的纬度值在第一区间，则编码是0，否则编码为1。我们用 40.222012 举例，由于40.222012 属于 (0, 90)，所以编码为1，然后我们继续将(0, 90)分成(0, 45)、(45, 90)两个区间，而40.222012 位于(0, 45)，所以编码是0，依次类推，我们进行20次拆分，最后计算40.222012 的编码是 10111001001101000110。

      对于经度采用同样的的方法，得到 116.248283 的编码是 11010010101010100101。

      接下来我们对经纬度的编码合并，奇数为是纬度，偶数为是经度，得到的编码是 1110011101001001100011011001100000110110（这里需要特别注意，这里说的奇数、偶数是值数组的下标，从0开始的）；

      最后用base32编码，二进制串对应的十进制分别为 28, 29, 4, 24, 27, 6, 1, 22，转化为base32是wx4sv61q，因此就 得到(40.222012, 116.248283) 的编码为 wx4sv61q。（下图介绍了base32的对应关系）

      编码 wx4sv61q 在地图上对应的位置如下图：

      这里我们GeoHash的编码长度为8，这时精度在19米，下表列出了不同的编码长度对应的精度：

      由上面的精度可知，如果要选取和我(40.222012, 116.248283)相距2km内的物品，我们只需要查找物品坐标对应的GeoHash以wx4sv为前缀的即可。

GeoHash延伸

      到目前为止我们对空间索引有了一定的了解，但是上面介绍的内容对下面的一种情况就无法实现（下面这幅图出自他人的博客）：

      我们从图中可以看出，红点与上方的绿点距离较近，与下方的绿点距离较远，但是红点与下方的绿点的编码字符串一样，都是wx4g0。对于GeoHash这种边界问题解决思路也十分简单，我们在做检索或者查询的时候，对周围的八个区域进行匹配，这样就很好的解决了边界问题。下面我们就对GeoHash用java进行实现。

JAVA实现

      在实现之前，我们首先定义一个LocationBean，用它来表示经纬度信息：

1. /**
2. *@Description: 存储经纬度信息
3. */
4. package com.lulei.geo.bean;
6. public class LocationBean {
7. public static final double MINLAT = - 90;
8. public static final double MAXLAT = 90;
9. public static final double MINLNG = - 180;
10. public static final double MAXLNG = 180;
11. private double lat; //纬度[-90,90]
12. private double lng; //经度[-180,180]
14. public LocationBean(double lat, double lng) {
15. this.lat = lat;
16. this.lng = lng;
17. }
18. public double getLat() {
19. return lat;
20. }
21. public void setLat(double lat) {
22. this.lat = lat;
23. }
24. public double getLng() {
25. return lng;
26. }
27. public void setLng(double lng) {
28. this.lng = lng;
29. }
30. }

      然后我们编写一个类，来实现GeoHash，在实现GeoHash的过程中，我们需要用 定义一些常量以及经纬度信息，具体如下：

1. public class GeoHash {
2. private LocationBean location;
3. /**
4. * 1 2500km;2 630km;3 78km;4 30km
5. * 5 2.4km; 6 610m; 7 76m; 8 19m
6. */
7. private int hashLength = 8; //经纬度转化为geohash长度
8. private int latLength = 20; //纬度转化为二进制长度
9. private int lngLength = 20; //经度转化为二进制长度
11. private double minLat; //每格纬度的单位大小
12. private double minLng; //每个经度的倒下
13. private static final char[] CHARS = { '0', '1', '2', '3', '4', '5', '6', '7',
14. '8', '9', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n',
15. 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
16. }

      在GeoHash实例化时，我们需要对一些 属性进行赋值：

1. public GeoHash(double lat, double lng) {
2. location = new LocationBean(lat, lng);
3. setMinLatLng();
4. }
6. public int gethashLength() {
7. return hashLength;
8. }
10. /**
11. * @Author:lulei
12. * @Description: 设置经纬度的最小单位
13. */
14. private void setMinLatLng() {
15. minLat = LocationBean.MAXLAT - LocationBean.MINLAT;
16. for ( int i = 0; i < latLength; i++) {
17. minLat /= 2.0;
18. }
19. minLng = LocationBean.MAXLNG - LocationBean.MINLNG;
20. for ( int i = 0; i < lngLength; i++) {
21. minLng /= 2.0;
22. }
23. }

      我们在使用GeoHash的时候，需要 设置最终编码的长度，因此编写一个方法实现对GeoHash长度的设置

1. public boolean sethashLength(int length) {
2. if (length < 1) {
3. return false;
4. }
5. hashLength = length;
6. latLength = (length * 5) / 2;
7. if (length % 2 == 0) {
8. lngLength = latLength;
9. } else {
10. lngLength = latLength + 1;
11. }
12. setMinLatLng();
13. return true;
14. }

      有了这些设置之后，我们需要 将经度、纬度转化为对应的二进制编码

1. private boolean[] getHashArray( double value, double min, double max, int length) {
2. if (value < min || value > max) {
3. return null;
4. }
5. if (length < 1) {
6. return null;
7. }
8. boolean[] result = new boolean[length];
9. for ( int i = 0; i < length; i++) {
10. double mid = (min + max) / 2.0;
11. if (value > mid) {
12. result[i] = true;
13. min = mid;
14. } else {
15. result[i] = false;
16. max = mid;
17. }
18. }
19. return result;
20. }

      分别获取经纬度的二进制编码后，我们需要 将两个二进制字符串合并成一个

1. private boolean[] merge( boolean[] latArray, boolean[] lngArray) {
2. if (latArray == null || lngArray == null) {
3. return null;
4. }
5. boolean[] result = new boolean[lngArray.length + latArray.length];
6. Arrays.fill(result, false);
7. for ( int i = 0; i < lngArray.length; i++) {
8. result[ 2 * i] = lngArray[i];
9. }
10. for ( int i = 0; i < latArray.length; i++) {
11. result[ 2 * i + 1] = latArray[i];
12. }
13. return result;
14. }

      最后我们需要将获得的 二进制转进行base32转化

1. /**
2. * @param lat
3. * @param lng
4. * @return
5. * @Author:lulei
6. * @Description: 获取经纬度的base32字符串
7. */
8. private String getGeoHashBase32(double lat, double lng) {
9. boolean[] bools = getGeoBinary(lat, lng);
10. if (bools == null) {
11. return null;
12. }
13. StringBuffer sb = new StringBuffer();
14. for ( int i = 0; i < bools.length; i = i + 5) {
15. boolean[] base32 = new boolean[ 5];
16. for ( int j = 0; j < 5; j++) {
17. base32[j] = bools[i + j];
18. }
19. char cha = getBase32Char(base32);
20. if ( ' ' == cha) {
21. return null;
22. }
23. sb.append(cha);
24. }
25. return sb.toString();
26. }
28. /**
29. * @param base32
30. * @return
31. * @Author:lulei
32. * @Description: 将五位二进制转化为base32
33. */
34. private char getBase32Char(boolean[] base32) {
35. if (base32 == null || base32.length != 5) {
36. return ' ';
37. }
38. int num = 0;
39. for ( boolean bool : base32) {
40. num <<= 1;
41. if (bool) {
42. num += 1;
43. }
44. }
45. return CHARS[num % CHARS.length];
46. }

      对于如何获取周围八个区域的GeoHash值这个问题我们可以做如下转化，我们已经知道当前点的经纬度值，我们也知道每一个区域内的经度、纬度的宽度，如果经度加上或减去这个宽度，我们就可以位于该区域左侧和右侧区域的经度，如果纬度加上或减去这个宽度，我们就可以获取该区域上部和下部的纬度，这样我们就可以分别获取到该区域周围八个区域内的一个点的坐标，我们分别计算这八个点的坐标，也就是八个区域对应的GeoHash编码。

1. public List<String> getGeoHashBase32For9() {
2. double leftLat = location.getLat() - minLat;
3. double rightLat = location.getLat() + minLat;
4. double upLng = location.getLng() - minLng;
5. double downLng = location.getLng() + minLng;
6. List<String> base32For9 = new ArrayList<String>();
7. //左侧从上到下 3个
8. String leftUp = getGeoHashBase32(leftLat, upLng);
9. if (!(leftUp == null || "".equals(leftUp))) {
10. base32For9.add(leftUp);
11. }
12. String leftMid = getGeoHashBase32(leftLat, location.getLng());
13. if (!(leftMid == null || "".equals(leftMid))) {
14. base32For9.add(leftMid);
15. }
16. String leftDown = getGeoHashBase32(leftLat, downLng);
17. if (!(leftDown == null || "".equals(leftDown))) {
18. base32For9.add(leftDown);
19. }
20. //中间从上到下 3个
21. String midUp = getGeoHashBase32(location.getLat(), upLng);
22. if (!(midUp == null || "".equals(midUp))) {
23. base32For9.add(midUp);
24. }
25. String midMid = getGeoHashBase32(location.getLat(), location.getLng());
26. if (!(midMid == null || "".equals(midMid))) {
27. base32For9.add(midMid);
28. }
29. String midDown = getGeoHashBase32(location.getLat(), downLng);
30. if (!(midDown == null || "".equals(midDown))) {
31. base32For9.add(midDown);
32. }
33. //右侧从上到下 3个
34. String rightUp = getGeoHashBase32(rightLat, upLng);
35. if (!(rightUp == null || "".equals(rightUp))) {
36. base32For9.add(rightUp);
37. }
38. String rightMid = getGeoHashBase32(rightLat, location.getLng());
39. if (!(rightMid == null || "".equals(rightMid))) {
40. base32For9.add(rightMid);
41. }
42. String rightDown = getGeoHashBase32(rightLat, downLng);
43. if (!(rightDown == null || "".equals(rightDown))) {
44. base32For9.add(rightDown);
45. }
46. return base32For9;
47. }

运行结果

完整代码

      上面的博客中已经有完整的LoacationBean代码，这里就不再写了。

1. /**
2. *@Description: GeoHash实现经纬度的转化
3. */
4. package com.lulei.geo;
6. import java.util.ArrayList;
7. import java.util.Arrays;
8. import java.util.List;
10. import com.lulei.geo.bean.LocationBean;
11. import com.lulei.util.JsonUtil;
13. public class GeoHash {
14. private LocationBean location;
15. /**
16. * 1 2500km;2 630km;3 78km;4 30km
17. * 5 2.4km; 6 610m; 7 76m; 8 19m
18. */
19. private int hashLength = 8; //经纬度转化为geohash长度
20. private int latLength = 20; //纬度转化为二进制长度
21. private int lngLength = 20; //经度转化为二进制长度
23. private double minLat; //每格纬度的单位大小
24. private double minLng; //每个经度的倒下
25. private static final char[] CHARS = { '0', '1', '2', '3', '4', '5', '6', '7',
26. '8', '9', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n',
27. 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
29. public GeoHash(double lat, double lng) {
30. location = new LocationBean(lat, lng);
31. setMinLatLng();
32. }
34. public int gethashLength() {
35. return hashLength;
36. }
38. /**
39. * @Author:lulei
40. * @Description: 设置经纬度的最小单位
41. */
42. private void setMinLatLng() {
43. minLat = LocationBean.MAXLAT - LocationBean.MINLAT;
44. for ( int i = 0; i < latLength; i++) {
45. minLat /= 2.0;
46. }
47. minLng = LocationBean.MAXLNG - LocationBean.MINLNG;
48. for ( int i = 0; i < lngLength; i++) {
49. minLng /= 2.0;
50. }
51. }
53. /**
54. * @return
55. * @Author:lulei
56. * @Description: 求所在坐标点及周围点组成的九个
57. */
58. public List<String> getGeoHashBase32For9() {
59. double leftLat = location.getLat() - minLat;
60. double rightLat = location.getLat() + minLat;
61. double upLng = location.getLng() - minLng;
62. double downLng = location.getLng() + minLng;
63. List<String> base32For9 = new ArrayList<String>();
64. //左侧从上到下 3个
65. String leftUp = getGeoHashBase32(leftLat, upLng);
66. if (!(leftUp == null || "".equals(leftUp))) {
67. base32For9.add(leftUp);
68. }
69. String leftMid = getGeoHashBase32(leftLat, location.getLng());
70. if (!(leftMid == null || "".equals(leftMid))) {
71. base32For9.add(leftMid);
72. }
73. String leftDown = getGeoHashBase32(leftLat, downLng);
74. if (!(leftDown == null || "".equals(leftDown))) {
75. base32For9.add(leftDown);
76. }
77. //中间从上到下 3个
78. String midUp = getGeoHashBase32(location.getLat(), upLng);
79. if (!(midUp == null || "".equals(midUp))) {
80. base32For9.add(midUp);
81. }
82. String midMid = getGeoHashBase32(location.getLat(), location.getLng());
83. if (!(midMid == null || "".equals(midMid))) {
84. base32For9.add(midMid);
85. }
86. String midDown = getGeoHashBase32(location.getLat(), downLng);
87. if (!(midDown == null || "".equals(midDown))) {
88. base32For9.add(midDown);
89. }
90. //右侧从上到下 3个
91. String rightUp = getGeoHashBase32(rightLat, upLng);
92. if (!(rightUp == null || "".equals(rightUp))) {
93. base32For9.add(rightUp);
94. }
95. String rightMid = getGeoHashBase32(rightLat, location.getLng());
96. if (!(rightMid == null || "".equals(rightMid))) {
97. base32For9.add(rightMid);
98. }
99. String rightDown = getGeoHashBase32(rightLat, downLng);
100. if (!(rightDown == null || "".equals(rightDown))) {
101. base32For9.add(rightDown);
102. }
103. return base32For9;
104. }
106. /**
107. * @param length
108. * @return
109. * @Author:lulei
110. * @Description: 设置经纬度转化为geohash长度
111. */
112. public boolean sethashLength(int length) {
113. if (length < 1) {
114. return false;
115. }
116. hashLength = length;
117. latLength = (length * 5) / 2;
118. if (length % 2 == 0) {
119. lngLength = latLength;
120. } else {
121. lngLength = latLength + 1;
122. }
123. setMinLatLng();
124. return true;
125. }
127. /**
128. * @return
129. * @Author:lulei
130. * @Description: 获取经纬度的base32字符串
131. */
132. public String getGeoHashBase32() {
133. return getGeoHashBase32(location.getLat(), location.getLng());
134. }
136. /**
137. * @param lat
138. * @param lng
139. * @return
140. * @Author:lulei
141. * @Description: 获取经纬度的base32字符串
142. */
143. private String getGeoHashBase32(double lat, double lng) {
144. boolean[] bools = getGeoBinary(lat, lng);
145. if (bools == null) {
146. return null;
147. }
148. StringBuffer sb = new StringBuffer();
149. for ( int i = 0; i < bools.length; i = i + 5) {
150. boolean[] base32 = new boolean[ 5];
151. for ( int j = 0; j < 5; j++) {
152. base32[j] = bools[i + j];
153. }
154. char cha = getBase32Char(base32);
155. if ( ' ' == cha) {
156. return null;
157. }
158. sb.append(cha);
159. }
160. return sb.toString();
161. }
163. /**
164. * @param base32
165. * @return
166. * @Author:lulei
167. * @Description: 将五位二进制转化为base32
168. */
169. private char getBase32Char(boolean[] base32) {
170. if (base32 == null || base32.length != 5) {
171. return ' ';
172. }
173. int num = 0;
174. for ( boolean bool : base32) {
175. num <<= 1;
176. if (bool) {
177. num += 1;
178. }
179. }
180. return CHARS[num % CHARS.length];
181. }
183. /**
184. * @param lat
185. * @param lng
186. * @return
187. * @Author:lulei
188. * @Description: 获取坐标的geo二进制字符串
189. */
190. private boolean[] getGeoBinary( double lat, double lng) {
191. boolean[] latArray = getHashArray(lat, LocationBean.MINLAT, LocationBean.MAXLAT, latLength);
192. boolean[] lngArray = getHashArray(lng, LocationBean.MINLNG, LocationBean.MAXLNG, lngLength);
193. return merge(latArray, lngArray);
194. }
196. /**
197. * @param latArray
198. * @param lngArray
199. * @return
200. * @Author:lulei
201. * @Description: 合并经纬度二进制
202. */
203. private boolean[] merge( boolean[] latArray, boolean[] lngArray) {
204. if (latArray == null || lngArray == null) {
205. return null;
206. }
207. boolean[] result = new boolean[lngArray.length + latArray.length];
208. Arrays.fill(result, false);
209. for ( int i = 0; i < lngArray.length; i++) {
210. result[ 2 * i] = lngArray[i];
211. }
212. for ( int i = 0; i < latArray.length; i++) {
213. result[ 2 * i + 1] = latArray[i];
214. }
215. return result;
216. }
218. /**
219. * @param value
220. * @param min
221. * @param max
222. * @return
223. * @Author:lulei
224. * @Description: 将数字转化为geohash二进制字符串
225. */
226. private boolean[] getHashArray( double value, double min, double max, int length) {
227. if (value < min || value > max) {
228. return null;
229. }
230. if (length < 1) {
231. return null;
232. }
233. boolean[] result = new boolean[length];
234. for ( int i = 0; i < length; i++) {
235. double mid = (min + max) / 2.0;
236. if (value > mid) {
237. result[i] = true;
238. min = mid;
239. } else {
240. result[i] = false;
241. max = mid;
242. }
243. }
244. return result;
245. }
248. public static void main(String[] args) {
249. // TODO Auto-generated method stub
250. GeoHash g = new GeoHash( 40.222012, 116.248283);
251. System.out.println(g.getGeoHashBase32());
252. System.out.println(JsonUtil.parseJson(g.getGeoHashBase32For9()));
253. }
255. }

-------------------------------------------------------------------------------------------------
小福利
-------------------------------------------------------------------------------------------------
      个人在极客学院上《Lucene案例开发》课程已经上线了（目前上线到第二课），欢迎大家吐槽~

第一课：Lucene概述

第二课：Lucene 常用功能介绍

第三课：网络爬虫

第四课：数据库连接池

第五课：小说网站的采集

第六课：小说网站数据库操作

第七课：小说网站分布式爬虫的实现

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/xiaojimanman/article/details/50358506