初学者入门：springboot整合elasticsearch实现空间检索实例（根据经纬度坐标查询）

最新推荐文章于 2024-03-26 16:24:34 发布
最新推荐文章于 2024-03-26 16:24:34 发布
阅读量1.6k 收藏 9
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38736877/article/details/118702506
版权

        es的空间检索提供了通过空间距离和位置关系进行检索的能力。将es整合到springboot中，可以轻松实现空间检索模块的编写与使用。

        Springboot整合es的具体流程此处不再赘述，若有需要。可以参考如下文档：

        从零开始：SpringBoot整合ElasticSearch实现简单增删改查

一. 使用 postman 新增实例

        具体使用中，可以自己编写新增接口来向es中批量添加实例。由于上一篇文档中已经详细说明了如何编写增删改查的接口，此处不再重复编写新增接口，而是直接用postman向es中增加了若干条演示实例。

     1. 新建 es 映射

        本文档使用 city 对象来演示空间检索功能。city 对象具有 id，name 和坐标 locationPoint 的基本属性。如何使用postman在es中新建映射请查看上面提到的文档。

        city映射：

{
    "mappings": {
        "city": {
            "properties": {
                "id": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type":"keyword",
                            "ignore_above":256
                        }
                    }
                },
                "name": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type":"keyword",
                            "ignore_above":256
                        }
                    }
                },
                "locationPoint": {
                    "type": "geo_point",
                    "fields": {
                        "keyword": {
                            "type":"keyword",
                            "ignore_above":256
                        }
                    }
                }
            }
        }
    }
}

    2. 向es中添加数据

      实例如下：

{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 4,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "place",
                "_type": "city",
                "_id": "111",
                "_score": 1.0,
                "_source": {
                    "id": "111",
                    "name": "A1",
                    "locationPoint": {
                        "lat": 41.12,
                        "lon": -71.34
                    }
                }
            },
            {
                "_index": "place",
                "_type": "city",
                "_id": "222",
                "_score": 1.0,
                "_source": {
                    "id": "222",
                    "name": "A2",
                    "locationPoint": {
                        "lat": 40.12,
                        "lon": -70.34
                    }
                }
            },
            {
                "_index": "place",
                "_type": "city",
                "_id": "333",
                "_score": 1.0,
                "_source": {
                    "id": "333",
                    "name": "A3",
                    "locationPoint": {
                        "lat": 38.12,
                        "lon": -76.34
                    }
                }
            },
            {
                "_index": "place",
                "_type": "city",
                "_id": "444",
                "_score": 1.0,
                "_source": {
                    "id": "555",
                    "name": "B2",
                    "locationPoint": {
                        "lat": 40,
                        "lon": -74
                    }
                }
            }
        ]
    }
}

二. 在 springboot 中编写相关接口

     1. 新建 city 类

        City：

package com.example.elasticsearchdemo.bean;

import org.springframework.data.annotation.Id;

public class City {

    @Id
    private String id;

    //城市名
    private String name;

    //经纬度
    private EsGeoPoint locationPoint;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public EsGeoPoint getLocationPoint() {
        return locationPoint;
    }

    public void setLocationPoint(EsGeoPoint locationPoint) {
        this.locationPoint = locationPoint;
    }

    @Override
    public String toString() {
        return "City{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", locationPoint=" + locationPoint +
                '}';
    }
}

        EsGeoPoint： 

package com.example.elasticsearchdemo.bean;

public class EsGeoPoint {

    //纬度
    private double lat;

    //经度
    private double lon;

    public double getLat() {
        return lat;
    }

    public void setLat(double lat) {
        this.lat = lat;
    }

    public double getLon() {
        return lon;
    }

    public void setLon(double lon) {
        this.lon = lon;
    }

    @Override
    public String toString() {
        return "EsGeoPoint{" +
                "lat=" + lat +
                ", lon=" + lon +
                '}';
    }
}

     2. 新建 GeoSearch 查询类

        GeoSearch：

package com.example.elasticsearchdemo.bean;

import org.elasticsearch.common.geo.GeoPoint;

import java.util.List;

public class GeoSearch {

    private String type;
    // 类型{Polygon: 多边形; Circle: 圆; bounding: 矩形}

    private List<GeoPoint> points;
    // 点集

    private String radius;
    // 半径

    private GeoPoint origin;
    // 原点

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public List<GeoPoint> getPoints() {
        return points;
    }

    public void setPoints(List<GeoPoint> points) {
        this.points = points;
    }

    public String getRadius() {
        return radius;
    }

    public void setRadius(String radius) {
        this.radius = radius;
    }

    public GeoPoint getOrigin() {
        return origin;
    }

    public void setOrigin(GeoPoint origin) {
        this.origin = origin;
    }

    @Override
    public String toString() {
        return "GeoSearch{" +
                "type='" + type + '\'' +
                ", points=" + points +
                ", radius='" + radius + '\'' +
                ", origin=" + origin +
                '}';
    }
}

     3. Controller 层

        GeoSearchController：

package com.example.elasticsearchdemo.controller;

import com.alibaba.fastjson.JSONObject;
import com.example.elasticsearchdemo.bean.GeoSearch;
import com.example.elasticsearchdemo.service.GeoSearchService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

@RestController
@RequestMapping("/geoSearch")
@CrossOrigin(value = "*",  maxAge = 3600)
public class GeoSearchController {

    @Resource
    private GeoSearchService service;

    @RequestMapping(value = "/search",method = RequestMethod.POST)
    public JSONObject geoSearch(@RequestBody GeoSearch search) throws Exception{
        JSONObject output = new JSONObject();
        JSONObject result = service.geoSearch(search);
        if (result.get("msg") == "succeed") {
            output.put("msg" ,"succeed");
            output.put("data", result.get("data"));
        } else {
            output.put("msg", "failed");
            output.put("data", result.get("data"));
        }
        return output;
    }

}

     2. Service 层

        GeoSearchService：

package com.example.elasticsearchdemo.service;

import com.alibaba.fastjson.JSONObject;
import com.example.elasticsearchdemo.bean.City;
import com.example.elasticsearchdemo.bean.GeoSearch;
import com.example.elasticsearchdemo.dao.common.GeoSearchDao;
import org.elasticsearch.common.geo.GeoPoint;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@Service
public class GeoSearchService {

    @Resource
    private GeoSearchDao geoSearchDao;

    public JSONObject geoSearch(GeoSearch search) throws Exception{
        JSONObject out = new JSONObject();
        String type = search.getType();
        List result = new ArrayList<>();
        
        //type为空则返回所有数据
        if ((type == null) || (type == "")) {
            List list = geoSearchDao.getAll();
            out.put("msg", "succeed");
            out.put("data", list);
            return out;
        } 
        
        //根据type判断采用何种查询
        else if (type.equals("Polygon") || type == "Polygon") {
            List<GeoPoint> list = search.getPoints();
            result = geoSearchDao.searchGeoPolygon(list);
        }
        
        else if (type.equals("Circle") || type == "Circle") {
            String distance = search.getRadius();
            GeoPoint point = search.getOrigin();
            result = geoSearchDao.searchGeoDistance(distance, point);
        }
        
        else if (type.equals("bounding") ||type == "bounding") {
            if (search.getPoints().size() >= 2) {
                GeoPoint point1 = search.getPoints().get(0);
                GeoPoint point2 = search.getPoints().get(1);
                result = geoSearchDao.searchGeoBoundingBox(point1, point2);
            } else {
                out.put("msg", "failed");
                out.put("data", "Points error");
                return out;
            }
        } else {
            out.put("msg", "failed");
            out.put("data", "Type error");
            return out;
        }
        out.put("msg", "succeed");
        out.put("data", result);
        return out;
    }

}

     3. Dao 层

        GeoSearchDao：

package com.example.elasticsearchdemo.dao.common;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@Repository
public class GeoSearchDao {

    @Resource
    private RestHighLevelClient client;
    @Value("${elasticsearch.place.index}")
    private String cityIndex;
    @Value("${elasticsearch.city.type}")
    private String cityType;

    @Resource
    private Factory factory;

    /**查询所有*/
    public List getAll() throws IOException {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        boolQueryBuilder.should(matchAllQueryBuilder);
        searchSourceBuilder.query(boolQueryBuilder);
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices(cityIndex);
        searchRequest.types(cityType);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        List list = new ArrayList();
        for (SearchHit hit: searchResponse.getHits()) {
            String s = JSON.toJSONString(hit);
            JSONObject o = JSON.parseObject(s);
            list.add(o.getJSONObject("sourceAsMap"));
        }
        return list;
    }

    /**
     * 查询多边形中的位置
     * @param points
     * @return
     * @throws Exception
     */
    public List searchGeoPolygon(List<GeoPoint> points) throws Exception {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = factory.builtPolygonQuery("locationPoint",points);
        return search(searchSourceBuilder, boolQueryBuilder);
    }

    /**
     * 查询矩形范围内位置
     * @param point1
     * @param point2
     * @return
     * @throws Exception
     */
    public List searchGeoBoundingBox(GeoPoint point1, GeoPoint point2) throws Exception {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = factory.builderBoundingBox("locationPoint", point1, point2);
        return search(searchSourceBuilder, boolQueryBuilder);
    }

    /**
     * 查询圆内位置
     * @param distance
     * @param point
     * @return
     * @throws Exception
     */
    public List searchGeoDistance(String distance, GeoPoint point) throws Exception {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = factory.builderDistance("locationPoint", distance, point);
        return search(searchSourceBuilder, boolQueryBuilder);
    }

    public List search(SearchSourceBuilder searchSourceBuilder, BoolQueryBuilder boolQueryBuilder) throws Exception {
        searchSourceBuilder.query(boolQueryBuilder);
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices(cityIndex);
        searchRequest.types(cityType);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        List list = new ArrayList();
        for (SearchHit hit: searchResponse.getHits()) {
            String s = JSON.toJSONString(hit);
            System.out.println(s);
            JSONObject o = JSON.parseObject(s);
            list.add(o.getJSONObject("sourceAsMap"));
        }
        return list;
    }


}

        Factory：

package com.example.elasticsearchdemo.dao.common;

import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.common.unit.DistanceUnit;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository

public class Factory {

    /**
     * 查询多边形内数据
     * @param field
     * @param points
     * @return
     * @throws Exception
     */
    public BoolQueryBuilder builtPolygonQuery(String field, List<GeoPoint> points) throws Exception {
        if (points == null ||points.size() <=0) {
            throw new Exception("bad args of geo points");
        }
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        QueryBuilder matchQueryBuilder = QueryBuilders.geoPolygonQuery(field, points);
        boolQueryBuilder.should(matchQueryBuilder);
        return boolQueryBuilder;
    }

    /**
     * 查询矩形框内数据
     * @param field
     * @param point1
     * @param point2
     * @return
     * @throws Exception
     */
    public BoolQueryBuilder builderBoundingBox(String field, GeoPoint point1, GeoPoint point2) throws Exception {
        if (point1 == null ||point2 == null) {
            throw new Exception("bad args of geo points");
        }
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        QueryBuilder matchQueryBuilder = QueryBuilders.geoBoundingBoxQuery(field).setCorners(point1, point2);
        boolQueryBuilder.should(matchQueryBuilder);
        return boolQueryBuilder;
    }

    /**
     * 查询圆内数据
     * @param field
     * @param distance
     * @param point
     * @return
     * @throws Exception
     */
    public BoolQueryBuilder builderDistance(String field, String distance, GeoPoint point) throws Exception {
        if (point == null) {
            throw new Exception("bad args of geo points");
        }
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        QueryBuilder matchQueryBuilder = QueryBuilders.geoDistanceQuery(field).point(point).distance(distance, DistanceUnit.METERS);
        boolQueryBuilder.should(matchQueryBuilder);
        return boolQueryBuilder;
    }

}

三. 使用 postman 测试空间检索接口

        以 springboot 端口为 9650 为例，实际以自己配置中端口为准。

     1. 返回所有

        当 type 传入为空时，默认返回所有数据。

        POST  http://localhost:9650/geoSearch/search

        传参：

{
    "type": ""
}

        返回值：

{
    "msg": "succeed",
    "data": [
        {
            "name": "A1",
            "id": "111",
            "locationPoint": {
                "lon": -71.34,
                "lat": 41.12
            }
        },
        {
            "name": "A2",
            "id": "222",
            "locationPoint": {
                "lon": -70.34,
                "lat": 40.12
            }
        },
        {
            "name": "A3",
            "id": "333",
            "locationPoint": {
                "lon": -76.34,
                "lat": 38.12
            }
        },
        {
            "name": "B2",
            "id": "555",
            "locationPoint": {
                "lon": -74,
                "lat": 40
            }
        }
    ]
}

     2. 返回处于指定圆形范围中的数据

        传入参数中 radius 为半径（不添加单位默认为m，可指定为km），origin 为圆心坐标。

        POST  http://localhost:9650/geoSearch/search

        传参：

{
    "type": "Circle",
    "radius": "200km",
    "origin": {
        "lat": 41,
        "lon": -71
    }
}

        返回值：

{
    "msg": "succeed",
    "data": [
        {
            "name": "A1",
            "id": "111",
            "locationPoint": {
                "lon": -71.34,
                "lat": 41.12
            }
        },
        {
            "name": "A2",
            "id": "222",
            "locationPoint": {
                "lon": -70.34,
                "lat": 40.12
            }
        }
    ]
}

     3. 返回处于指定矩形范围中的数据

        传入参数中 points 为矩形左上角和右下角的坐标集。

        POST  http://localhost:9650/geoSearch/search

        传参：

{
    "type": "Bounding",
    "points": [
        {
            "lat": "42",
            "lon": "-72"
        },
        {
            "lat": "40",
            "lon": "-71"
        }
    ]
}

        返回值：

{
    "msg": "succeed",
    "data": [
        {
            "name": "A1",
            "id": "111",
            "locationPoint": {
                "lon": -71.34,
                "lat": 41.12
            }
        }
    ]
}

     3. 返回处于指定多边形范围中的数据

        传入参数中 points 为构成多边形点的坐标集。

        POST  http://localhost:9650/geoSearch/search

        传参（以三角形为例）：

{
    "type": "Polygon",
    "points": [
        {
            "lat": "42",
            "lon": "-72"
        },
        {
            "lat": "35",
            "lon": "-72"
        },
        {
            "lat": "40",
            "lon": "-60"
        }
    ]
}

        返回值：

{
    "msg": "succeed",
    "data": [
        {
            "name": "A1",
            "id": "111",
            "locationPoint": {
                "lon": -71.34,
                "lat": 41.12
            }
        },
        {
            "name": "A2",
            "id": "222",
            "locationPoint": {
                "lon": -70.34,
                "lat": 40.12
            }
        }
    ]
}

以上即为 springboot 整合 es 实现空间检索的简单实现方法。

SakamotoLz
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于spring boot实现根据经纬度坐标返回所在行政区域
09-28
本项目基于spring boot实现根据经纬度坐标返回所在行政区域。
springboo+elasticsearch+经纬度查询
zhongbaolin的专栏
09-09 1275
主要是先设一下mapping，比如entity如下： @Document(indexName = "buser",type = "person",shards = 1,replicas = 0,refreshInterval = "-1") public class Driver { @Id private String id; @Field private ...
Elasticsearch的Java客户端库QueryBuilders查询方法大全
最新发布
weixin_52438357的博客
03-26 1615
【代码】Elasticsearch的Java客户端库QueryBuilders查询方法大全。
es空间检索
仅做个人笔记
02-02 604
方案优化的探索是没有没有止境的，Lucene的核心工程师 Michael McCandless受到论文《Bkd-Tree: A Dynamic Scalable kd-Tree》启发，基于BKD tree再次升级了地理位置数据索引建模和查询功能。在前面的版本中，对于数值区间查询的处理思路本质上都是term匹配，通过前缀实现了一个term管理一个区间，从而降低了区间查询需要遍历的term数量。搜索的时候，就不再是像Quadtree从整个世界开始定位，而是基于当前的点集合形成的空间来查找。
SpringBoot操作前端传的Geojson进行空间查询
m0_59540171的博客
08-07 359
项目说明:项目技术栈:SpringBoot+MybatisPlus+postgresql。
Elasticsearch2.3.2空间查询
alalike
04-11 789
写在前面：Elasticsearch提供强大的空间处理功能，本文只是完成了他的空间查询功能使用工具：elasticsearch_head1、新建设备type请求地址：http://10.163.130.220:9200/sbindex/sbtype/_mapping/请求类型：PUT   所有字段：SBID,SDMC,DZ,ZZJGDM,ZZJGMC,LOCATION,STATE请求参数：{   ...
5.（后端技术篇java）ElasticSearch实现矩形空间查询服务
地图之家
10-29 580
听老人家说：多看美女会长寿 功能定义：利用矩形的坐标（东南西北）空间查询出该范围内的数据。 使用场景：地图上画一个矩形查询该矩形下的所有数据。 注：可传入场所类型（网吧，旅馆等）再查询。 1、Elasticsearch配置信息（请修改为自己的环境） elasticsearch.ip=10.11.0.87 elasticsearch.port=9200 elasticsearch.index=pg_gis_poi 2、Controller 类代码实现 package com.cbc.elasticsear
springboot-blog-es:Springboot + ElasticSearch构建博客检索系统
03-11
简易博客检索系统使用前阶段分离，前端使用Vue，可以使用SpringBoot数据库MySQL检索使用ElasticSearch同步数据使用logstash 笔记地址： : 视频地址： : 参考代码： : 运行效果图
SpringBoot-Elasticsearch:SpringBoot整合Elasticsearch
05-06
SpringBoot2.1.7整合Elasticsearch7.3.0 项目说明 该项目采用SpringBoot，Elasticsearch进行整合开发学习。 该项目中的Elasticsearch整合了Elasticsearch-head 可视化工具，在项目中也自行下载Kibana官方可视化工具...
springboot整合elasticsearch7实现es数据同步，查询、相关度排序、高亮显示、自动补全搜索等功能。
03-31
springboot整合elasticsearch7，进行数据同步。elasticsearch相关度查询、排序。高亮显示；自动补全等功能。代码仅供参考，代码中有具体的注释，可以根据代码及注释内容，对自己项目架构及业务进行修改、整合。
SpringBoot整合Elasticsearch7.2.0的实现方法
08-25
主要介绍了SpringBoot整合Elasticsearch7.2.0的实现方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
ElasticSearch正向匹配、反向匹配，空间查询等示例（java代码）.rar
10-29
实现如下需求： 2.（后端技术篇java）Postgres库数据同步到ElasticSearch 3.（后端技术篇java）ElasticSearch实现正向地址匹配服务 4.（后端技术篇java）ElasticSearch实现反向地址匹配服务（点周边查询服务） 5.（后端技术篇java）ElasticSearch实现矩形空间查询服务 6.（后端技术篇java）ElasticSearch实现圆形空间查询服务 7.（后端技术篇java）ElasticSearch实现多边形空间查询服务 8.（后端技术篇java）ElasticSearch实现线周边空间查询服务 下载如有问题，可私信博主。下载前建议先查看博客内容，其地址为：https://blog.csdn.net/QQ98281642/article/details/117514368
word源码java-elasticsearch:springboot整合ElasticSearch
06-05
全文检索： 数据结构： 数据总体分为两种： 结构化数据： 有固定格式或有限长度的数据 如：数据库中的数据、元数据(文件、文件夹...)等 非结构化数据： 不定长或无固定格式的数据 如：邮件，word文档等...
SpringBoot+ElasticSearch根据经纬度，简单搜索指定距离范围内的数据
weixin_44472746的博客
06-10 2693
创建geo_point类型字段映射： PUT hrm { "mappings": { "course": { "properties": { "location": { "type": "geo_point" } } } } } 学习内容： 提示：这里可以添加要学的内容 例如： 1、 搭建 Java 开发环境 2、 掌握 Java 基本语法 3、 掌握条件语句 4、 掌握循环语句 学习时间： 提示：这里
50.（leaflet篇）leaflet矩形空间查询（ElasticSearch技术实现）
GIS之家家长
04-18 352
听老人家说：多看美女会长寿 地图之家总目录（订阅之前建议先查看该博客） 关联博客： 5.（后端技术篇java）ElasticSearch实现矩形空间查询服务 文章末尾处提供保证可运行完整代码包，运行如有问题，可“私信”博主。 效果如下所示： 下面献上完整代码，代码重要位置会做相应解释 <!DOCTYPE html> <html> <head> <meta charset=utf-8/> <title>Historic Topograp
ElasticSearch地理坐标搜索
liu__hui2008ooo的博客
12-17 232
ElasticSearch之基于地理位置的搜索 https://blog.csdn.net/zhanglh046/article/details/78536084
8.（后端技术篇java）ElasticSearch实现线周边空间查询服务
地图之家
11-01 1318
听老人家说：多看美女会长寿 功能定义：利用线的坐标查询出缓冲区并空间查询出该范围内的数据。 使用场景：地图上画一个线查询该线周边几百米下的所有数据。 注：可传入场所类型（网吧，旅馆等）再查询。 1、Elasticsearch配置信息（请修改为自己的环境） elasticsearch.ip=10.11.0.87 elasticsearch.port=9200 elasticsearch.index=pg_gis_poi 2、Controller 类代码实现 package com.cbc.elastics
Elasticsearch(GEO)空间检索查询
weixin_30722589的博客
11-10 566
Elasticsearch(GEO)空间检索查询python版本 1、Elasticsearch ES的强大就不用多说了，当你安装上插件，搭建好集群，你就拥有了一个搜索系统。 当然，ES的集群优化和查询优化就是另外一个议题了。这里mark一个最近使用的es空间检索的功能。 2、ES GEO空间检索 空间检索顾名思义提供了通过空间距离和位置关系进行检索的能力。有很多空间索引算法和类库...
Elasticsearch中多类别空间查询的实现流程
wjzt7322的博客
04-09 404
空间数据从传统的关系型数据库同步到Elasticsearch中实现多类别要素空间查询的实现流程如下： 1.确定坐标系：根据应用场景确定Elasticsearch中存储的空间数据的坐标系类型。 2.坐标转换：如果数据源与Elasticsearch中的坐标系不一致，需要将数据源的坐标转换为目标坐标系。 3.格式转换：将各种格式的空间数据，如Shapefile、Geodatabase等转换为GeoJSON或WKT结构组织的数据文件。 4.建立索引模板（Index template）：Elasticsearch按照
springboot 整合 elasticsearch 实现搜索自动补全
12-27
为了实现搜索自动补全功能，我们可以使用SpringBoot来整合Elasticsearch。首先，我们需要在SpringBoot的pom.xml文件中引入Elasticsearch的依赖。然后，我们需要在application.properties中配置Elasticsearch的主机...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值