学习geohash算法

  基于地址进行数据的检索，这个貌似有点难度，如果是小的应用的话，可以根据经纬度信息来直接进行查询或者通过数据库本身的空间数据检索方案，但是如果数据量以及访问请求变大时，这中方案就显然不是很合适，往往会使请求变的很慢。

          经过一系列的沟通下来，可以通过geohash的方案来解决这个问题。

基本流程可以是这样:

      （1）原始详细地址数据--->经纬度数值--->geohash字符串编码--->数据冗余保存，主键换为geohash，然后原始数据后置保存

      （2）请求接口，参数为详细地址，详细地址进行转换成geohash，然后基于geohash编码来进行搜索和排序，返回结果

        详细地址转换为经纬度这个可以直接调取成熟的geocoding服务来进行解决，地址规范的情况下，定位到街道应该不会很大，虽然有时候有一定的偏差，但是民用的话基本可以接受呵呵。

         所以目前的流程的话卡在了geohash算法这里，所以写这篇文章详细的介绍一下。

geohash的最简单解释：将一个经纬度信息，转换成一个可排序、可比较的字符串编码。

         将经纬度的信息，按照（-90，90）（-180,180）来转换成平面坐标系。

         借用一篇文章中的例子来说明一下编码生成的过程：

         首先将纬度范围(-90, 90)平分成两个区间(-90, 0)、(0, 90)，如果目标纬度位于前一个区间，则编码为0，否则编码为1。

         由于39.92324属于(0, 90)，所以取编码为1。

         然后再将(0, 90)分成 (0, 45), (45, 90)两个区间，而39.92324位于(0, 45)，所以编码为0。

         以此类推，直到精度符合要求为止，得到纬度编码为1011 1000 1100 0111 1001。

                                

           经度也用同样的算法，对(-180, 180)依次细分，得到116.3906的编码为1101 0010 1100 0100 0100。

                              

           接下来将经度和纬度的编码合并，奇数位是纬度，偶数位是经度，得到编码 11100 11101 00100 01111 00000 01101 01011 00001。

           最后，用0-9、b-z（去掉a, i, l, o）这32个字母进行base32编码，得到(39.92324, 116.3906)的编码为wx4g0ec1。

                                

           解码算法与编码算法相反，先进行base32解码，然后分离出经纬度，最后根据二进制编码对经纬度范围进行细分即可，这里不再赘述。

           不过由于geohash表示的是区间，编码越长越精确，但不可能解码出完全一致的地址。

           引用阿里云以为技术专家的博客上的讨论：

              

          常见的一些应用场景

          A、如果想查询附近的点？如何操作

                 查出改点的gehash值，然后到数据库里面进行前缀匹配就可以了。

          B、如果想查询附近点，特定范围内，例如一个点周围500米的点，如何搞？

                可以查询结果，在结果中进行赛选，将geohash进行解码为经纬度，然后进行比较

         1、在纬度相等的情况下：

              经度每隔0.00001度，距离相差约1米

              经度每隔0.0001度，距离相差约10米

              经度每隔0.001度，距离相差约100米

              经度每隔0.01度，距离相差约1000米

              经度每隔0.1度，距离相差约10000米

          2、在经度相等的情况下：

              纬度每隔0.00001度，距离相差约1.1米

              纬度每隔0.0001度，距离相差约11米

              纬度每隔0.001度，距离相差约111米

              纬度每隔0.01度，距离相差约1113米

              纬度每隔0.1度，距离相差约11132米

        代码直接贴出来，感兴趣的直接运行一下吧呵呵。

[html]  view plain copy

1. import java.text.DecimalFormat;  
2. import java.util.BitSet;  
3. import java.util.HashMap;  
4.   
5. public class Geohash {  
6.   
7.     private static int numbits = 6 * 5;  
8.     private static String data = "y8dcb88bgcqs#KP2#wx4g0ebcgcnw#KP2#wx4g0ec9er26#KP2#wx4g0ec9g30q";  
9.     final static char[] digits = { '0', '1', '2', '3', '4', '5', '6', '7', '8',  
10.             '9', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 'p',  
11.             'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };  
12.   
13.     final static HashMap<Character, Integer> lookup = new HashMap<Character, Integer>();  
14.     static {  
15.         int i = 0;  
16.         for (char c : digits)  
17.             lookup.put(c, i++);  
18.     }  
19.   
20.     public static void main(String[] args) throws Exception {  
21.         double lon = 116.39036, lat = 39.92324;  
22.         System.out.println(new Geohash().encode(39.92325, 116.39136));  
23.         System.out.println(getFinalResult(data, 100, lon, lat));  
24.     }  
25.   
26.     public static double[] decode(String geohash) {  
27.         StringBuilder buffer = new StringBuilder();  
28.         for (char c : geohash.toCharArray()) {  
29.   
30.             int i = lookup.get(c) + 32;  
31.             buffer.append(Integer.toString(i, 2).substring(1));  
32.         }  
33.   
34.         BitSet lonset = new BitSet();  
35.         BitSet latset = new BitSet();  
36.   
37.         // even bits  
38.         int j = 0;  
39.         for (int i = 0; i < numbits * 2; i += 2) {  
40.             boolean isSet = false;  
41.             if (i < buffer.length())  
42.                 isSet = buffer.charAt(i) == '1';  
43.             lonset.set(j++, isSet);  
44.         }  
45.   
46.         // odd bits  
47.         j = 0;  
48.         for (int i = 1; i < numbits * 2; i += 2) {  
49.             boolean isSet = false;  
50.             if (i < buffer.length())  
51.                 isSet = buffer.charAt(i) == '1';  
52.             latset.set(j++, isSet);  
53.         }  
54.   
55.         double lon = decode(lonset, -180, 180);  
56.         double lat = decode(latset, -90, 90);  
57.   
58.         return new double[] { lon, lat };  
59.     }  
60.   
61.     private static double decode(BitSet bs, double floor, double ceiling) {  
62.         double mid = 0;  
63.         for (int i = 0; i < bs.length(); i++) {  
64.             mid = (floor + ceiling) / 2;  
65.             if (bs.get(i))  
66.                 floor = mid;  
67.             else  
68.                 ceiling = mid;  
69.         }  
70.         return mid;  
71.     }  
72.   
73.     public String encode(double lat, double lon) {  
74.         BitSet latbits = getBits(lat, -90, 90);  
75.         BitSet lonbits = getBits(lon, -180, 180);  
76.         StringBuilder buffer = new StringBuilder();  
77.         for (int i = 0; i < numbits; i++) {  
78.             buffer.append((lonbits.get(i)) ? '1' : '0');  
79.             buffer.append((latbits.get(i)) ? '1' : '0');  
80.         }  
81.         return base32(Long.parseLong(buffer.toString(), 2));  
82.     }  
83.   
84.     private BitSet getBits(double lat, double floor, double ceiling) {  
85.         BitSet buffer = new BitSet(numbits);  
86.         for (int i = 0; i < numbits; i++) {  
87.             double mid = (floor + ceiling) / 2;  
88.             if (lat >= mid) {  
89.                 buffer.set(i);  
90.                 floor = mid;  
91.             } else {  
92.                 ceiling = mid;  
93.             }  
94.         }  
95.         return buffer;  
96.     }  
97.   
98.     public static String base32(long i) {  
99.         char[] buf = new char[65];  
100.         int charPos = 64;  
101.         boolean negative = (i < 0);  
102.         if (!negative)  
103.             i = -i;  
104.         while (i <= -32) {  
105.             buf[charPos--] = digits[(int) (-(i % 32))];  
106.             i /= 32;  
107.         }  
108.         buf[charPos] = digits[(int) (-i)];  
109.   
110.         if (negative)  
111.             buf[--charPos] = '-';  
112.         return new String(buf, charPos, (65 - charPos));  
113.     }  
114.     /**  
115.      * 获取圆内的所有结果  
116.      * @param myData sql中like前4位(wq32%)  
117.      * @param radius 附近距离相当于一个圆的半径  
118.      * @param longitude 经度  
119.      * @param latitude 纬度  
120.      * @return  
121.      */  
122.     public static String getFinalResult(String myData, int radius,  
123.             double longitude, double latitude) {  
124.         String finalResult = "";  
125.         try {  
126.             if (myData != null && !"".equals(myData)) {  
127.                 // 实际经度半径  
128.                 double lonRadius = radius % 1000 == 0 ? (0.01 * radius / 1000)  
129.                         : (radius % 100 == 0 ? (0.001 * radius / 100)  
130.                                 : (radius % 10 == 0 ? (0.0001 * radius / 10)  
131.                                         : (0.00001 * radius)));  
132.                 // 实际纬度半径  
133.                 double latRadius = radius % 1000 == 0 ? (0.01 * radius * radius / (1113 * 1000))  
134.                         : (radius % 100 == 0 ? (0.001 * radius * radius / (100 * 111))  
135.                                 : (radius % 10 == 0 ? (0.0001 * radius * radius / (10 * 11))  
136.                                         : (0.00001 * radius * radius / 1.1)));  
137.                 String[] dataSplit = myData.split("#KP2#");  
138.                 for (int i = 0; i < dataSplit.length; i++) {  
139.                     String myTemp = dataSplit[i];  
140.                     //当前的纬度  
141.                     double currentLat = Geohash.decode(myTemp)[1];  
142.                     //当前的经度  
143.                     double currentLon = Geohash.decode(myTemp)[0];  
144.                     //当前的纬度和圆中心的纬度差  
145.                     double y = getFiveDecimal(Math.abs(latitude - currentLat)) * radius / latRadius;  
146.                     //当前的经度和圆中心的经度差  
147.                     double x = getFiveDecimal(Math.abs(longitude - currentLon)) * radius / lonRadius;  
148.                     //判断当前点是否在圆内  
149.                     if ((x * x + y * y) <= (radius * radius)) {  
150.                         finalResult += myTemp + "#KP2#";  
151.                     }  
152.                 }  
153.             }  
154.         } catch (Exception e) {  
155.             e.printStackTrace();  
156.             finalResult = "";  
157.         }  
158.         if (finalResult != null && !"".equals(finalResult)) {  
159.             finalResult = finalResult.substring(0, finalResult.length() - 5);  
160.         }  
161.         return finalResult;  
162.     }  
163.   
164.     // 获取最多保留5位小数点  
165.     public static double getFiveDecimal(double d) {  
166.         DecimalFormat df = new DecimalFormat("0.00000");  
167.         return Double.parseDouble(df.format(d));  
168.     }  
169.   
170. }