PostgreSQL+GeoHash地图点位聚合

PG数据库安装扩展

需要用到pg数据库的空间扩展postgis，在进行操作之前需要在数据库中安装扩展。

1. CREATE EXTENSION postgis;
2. CREATE EXTENSION postgis_topology;
3. CREATE EXTENSION postgis_geohash;

复制代码

GeoHash

GeoHash是一种地址编码方法。他能够把二维的空间经纬度数据编码成一个字符串。具体原理这里不再详细说明，GeoHash算法大体上分为三步：

• 将经纬度变成二进制
  
• 将经纬度的二进制合并
  
• 通过Base32对合并后的二进制进行编码
  

Geohash比直接用经纬度的高效很多，而且使用者可以发布地址编码，既能表明自己位于北海公园附近，又不至于暴露自己的精确坐标，有助于隐私保护。

• GeoHash用一个字符串表示经度和纬度两个坐标。在数据库中可以实现在一列上应用索引（某些情况下无法在两列上同时应用索引）
  
• GeoHash表示的并不是一个点，而是一个矩形区域
  
• GeoHash编码的前缀可以表示更大的区域。例如wx4g0ec1，它的前缀wx4g0e表示包含编码wx4g0ec1在内的更大范围。 这个特性可以用于附近地点搜索
  
• 编码越长，表示的范围越小，位置也越精确。因此我们就可以通过比较GeoHash匹配的位数来判断两个点之间的大概距离
  

建表

在创建数据库表时，表中除了经纬度字段以外，再创建两个字段：
① 经纬度对应的Geometry字段（类型：geometry）
② 经纬度对应的geoHash值字段（类型：varchar）
如：alter table 表名 add 字段名 geometry(point, 4326); // 创建geometry字段
alter table 表名 add 字段名 varchar; // 创建geoHash字段
JPA中定义

1. @Type(type="jts_geometry")
2. @Column(name="geometry",columnDefinition = "geometry(Point,4326)")
3. @JsonIgnore
4. private Geometry geometry; // 实体类的Geometry字段

复制代码

根据经纬度计算 geometry 和 geoHash

Java生成geometry和geoHash

geometry字段 和 geoHash字段均可以在java代码中根据经纬度生成。

根据经纬度生成geometry
使用org.locationtech.jts.io包下的WKTReader类，可以根据经纬度生成Geometry对象。

1. String wkt = "POINT("+longitude+" "+latitude+")"; // longitude 经度，latitude纬度
2. WKTReader wktReader = new WKTReader();
3. Geometry geometry = wktReader.read(wkt); // Geometry对象
4. if(geometry!=null) {
5.     geometry.setSRID(4326);
6. }

复制代码

根据经纬度生成geoHash

1. import org.apache.commons.lang3.StringUtils;
2. import org.springframework.stereotype.Component;
3. import java.util.ArrayList;
4. import java.util.List;
6. @Component
7. public class GeoHashUtil {
8.     public final double Max_Lat = 90;
9.     public final double Min_Lat = -90;
10.     public final double Max_Lng = 180;
11.     public final double Min_Lng = -180;
13.     private final String[] base32Lookup = {
14.             "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "b", "c", "d", "e", "f", "g", "h", "j", "k",
15.             "m", "n", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"
16.     };
18.     /**
19.      * 根据geoHash串获取中心点经纬度
20.      * @param geoHashCode
21.      * @return  lng->x  lat->y
22.      */
23.     public double[] getSpaceCoordinate(String geoHashCode) {
24.         if(StringUtils.isBlank(geoHashCode)){
25.             return new double[2];
26.         }
27.         List<Integer> list = base32Decode(geoHashCode);
28.         String str = convertToIndex(list);
29.         GeoHashPoint geoHashPoint = splitLatAndLng(str);
30.         double y = revert(Min_Lat, Max_Lat, geoHashPoint.getLatList());
31.         double x = revert(Min_Lng, Max_Lng, geoHashPoint.getLngList());
32.         return new double[]{x, y};
33.     }
36.     /**
37.      * 根据精度获取GeoHash串
38.      * @param lng 经度 x
39.      * @param lat 纬度 y
40.      * @param precise 精度
41.      * @return
42.      */
43.     public String getGeoHash( double lng, double lat, int precise) {
44.         // 纬度二值串长度
45.         int latLength;
46.         //  经度二值串长度
47.         int lngLength;
48.         if (precise < 1 || precise > 12) {
49.             precise = 12;
50.         }
51.          latLength = (precise * 5) / 2;
52.         if (precise % 2 == 0) {
53.             lngLength = latLength;
54.         } else {
55.             lngLength = latLength + 1;
56.         }
57.         return encode(lat, lng, latLength, lngLength);
58.     }
60.     /**
61.      * 经纬度二值串合并：偶数位放经度，奇数位放纬度，把2串编码组合生成新串
62.      *
63.      */
64.     public String encode(double lat, double lng, int latLength, int lngLength) {
65.         if (latLength < 1 || lngLength < 1) {
66.             return StringUtils.EMPTY;
67.         }
68.         List<Character> latList = new ArrayList<>(latLength);
69.         List<Character> lngList = new ArrayList<>(lngLength);
70.         // 获取维度二值串
71.         convert(Min_Lat, Max_Lat, lat, latLength, latList);
72.         // 获取经度二值串
73.         convert(Min_Lng, Max_Lng, lng, lngLength, lngList);
74.         StringBuilder sb = new StringBuilder();
75.         for (int index = 0; index < latList.size(); index++) {
76.             sb.append(lngList.get(index)).append(latList.get(index));
77.         }
78. //        如果二者长度不一样，说明要求的精度为奇数，经度长度比纬度长度大1
79.         if (lngLength != latLength) {
80.             sb.append(lngList.get(lngList.size() - 1));
81.         }
83.         return base32Encode(sb.toString());
84.     }
86.     /**
87.      * 将合并的二值串转为base32串
88.      *
89.      * @param str 合并的二值串
90.      * @return base32串
91.      */
92.     private String base32Encode(final String str) {
93.         String unit = "";
94.         StringBuilder sb = new StringBuilder();
95.         for (int start = 0; start < str.length(); start = start + 5) {
96.             unit = str.substring(start, start + 5);
97.             sb.append(base32Lookup[convertToIndex(unit)]);
98.         }
99.         return sb.toString();
100.     }
102.     /**
103.      * 每五个一组将二进制转为十进制
104.      *
105.      * @param str 五个为一个unit
106.      * @return 十进制数
107.      */
108.     private int convertToIndex(String str) {
109.         int length = str.length();
110.         int result = 0;
111.         for (int index = 0; index < length; index++) {
112.             result += str.charAt(index) == '0' ? 0 : 1 << (length - 1 - index);
113.         }
114.         return result;
115.     }
118.     private void convert(double min, double max, double value, int count, List<Character> list) {
119.         if (list.size() > (count - 1)) {
120.             return;
121.         }
122.         double mid = (max + min) / 2;
123.         if (value < mid) {
124.             list.add('0');
125.             convert(min, mid, value, count, list);
126.         } else {
127.             list.add('1');
128.             convert(mid, max, value, count, list);
129.         }
130.     }
134.     /**
135.      * 将二值串转换为经纬度值
136.      *
137.      * @param min  区间最小值
138.      * @param max  区间最大值
139.      * @param list 二值串列表
140.      */
141.     private double revert(double min, double max, List<String> list) {
142.         double value = 0;
143.         double mid;
144.         if (list.size() <= 0) {
145.             return (max + min) / 2.0;
146.         }
147.         for (String flag : list) {
148.             mid = (max + min) / 2;
149.             if ("0".equals(flag)) {
150.                 max = mid;
151.             }
152.             if ("1".equals(flag)) {
153.                 min = mid;
154.             }
155.             value = (max + min) / 2;
156.         }
157.         return Double.parseDouble(String.format("%.6f", value));
158.     }
160.     /**
161.      * 分离经度与纬度串
162.      *
163.      * @param latAndLngStr 经纬度二值串
164.      */
165.     private GeoHashPoint splitLatAndLng(String latAndLngStr) {
166.         GeoHashPoint geoHashPoint = new GeoHashPoint();
167.         // 纬度二值串
168.         List<String> latList = new ArrayList<>();
169.        // 经度二值串
170.         List<String> lngList = new ArrayList<>();
171.         for (int i = 0; i < latAndLngStr.length(); i++) {
172. //            奇数位，纬度
173.             if (i % 2 == 1) {
174.                 latList.add(String.valueOf(latAndLngStr.charAt(i)));
175.             } else {
176. //                偶数位，经度
177.                 lngList.add(String.valueOf(latAndLngStr.charAt(i)));
178.             }
180.         }
181.         geoHashPoint.setLatList(latList);
182.         geoHashPoint.setLngList(lngList);
183.         return geoHashPoint;
184.     }
186.     /**
187.      * 将十进制数转为五个二进制数
188.      *
189.      * @param nums 十进制数
190.      * @return 五个二进制数
191.      */
192.     private String convertToIndex(List<Integer> nums) {
193.         StringBuilder str = new StringBuilder();
194.         for (Integer num : nums) {
195.             StringBuilder sb = new StringBuilder(Integer.toBinaryString(num));
196.             int length = sb.length();
197.             if (length < 5) {
198.                 for (int i = 0; i < 5 - length; i++) {
199.                     sb.insert(0, "0");
200.                 }
201.             }
202.             str.append(sb);
203.         }
204.         return str.toString();
205.     }
207.     /**
208.      * 将base32串转为合并的二值串
209.      *
210.      * @param str base32串
211.      * @return 合并的二值串
212.      */
213.     private List<Integer> base32Decode(String str) {
214.         List<Integer> list = new ArrayList<>();
215.         for (int i = 0; i < str.length(); i++) {
216.             String ch = String.valueOf(str.charAt(i));
217.             for (int j = 0; j < base32Lookup.length; j++) {
218.                 if (base32Lookup[j].equals(ch)) {
219.                     list.add(j);
220.                 }
221.             }
222.         }
223.         return list;
224.     }
226.     public static class GeoHashPoint{
227.         /**
228.          * 纬度二值串
229.          */
230.         private List<String> latList;
231.         /**
232.          * 经度二值串
233.          */
234.         private  List<String> lngList;
236.         public List<String> getLatList() {
237.             return latList;
238.         }
240.         public void setLatList(List<String> latList) {
241.             this.latList = latList;
242.         }
244.         public List<String> getLngList() {
245.             return lngList;
246.         }
248.         public void setLngList(List<String> lngList) {
249.             this.lngList = lngList;
250.         }
251.     }
253.     public static void main(String[] args) {
255.         GeoHashUtil geoHashUtil = new GeoHashUtil();
257.         // 根据精度获取GeoHash串
258.         String geoHash = geoHashUtil.getGeoHash( 120.234133,30.402616, 12);
259.         System.out.println(geoHash);
261.         // 根据geoHash串获取中心点经纬度
262.         double[] spaceCoordinate = geoHashUtil.getSpaceCoordinate(geoHash);
263.         System.out.println(spaceCoordinate[0]+","+spaceCoordinate[1]);
265.     }
267. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！