Fatal编程技术网
  • mongodb/
  • Mongodb 为什么在使用GeoJsonPoint执行nearSphere查询时会出现CodeConfigurationException？

Mongodb 为什么在使用GeoJsonPoint执行nearSphere查询时会出现CodeConfigurationException？

mongodb spring-boot

Mongodb 为什么在使用GeoJsonPoint执行nearSphere查询时会出现CodeConfigurationException？,mongodb,spring-boot,geojson,spring-data-mongodb,bson,Mongodb,Spring Boot,Geojson,Spring Data Mongodb,Bson,这个问题使我困惑。因此，我有一个UserModel，在这里我使用一个org.springframework.data.mongodb.core.geo.GeoJsonPoint对象存储用户最后已知的坐标，该对象转换为 “LastKnown坐标”：{ “类型”：“点”， “坐标”：[77.596503，12.966267] } 我有一个偏移集合，它映射到偏移模型对象。每个游览都有一个geolocation属性，该属性使用GeoJsonPoint规范存储其位置，如下所示： “地理定位”：{ “坐标

这个问题使我困惑。因此，我有一个UserModel，在这里我使用一个
org.springframework.data.mongodb.core.geo.GeoJsonPoint
对象存储用户最后已知的坐标，该对象转换为

“LastKnown坐标”：{
“类型”：“点”，
“坐标”：[77.596503，12.966267]
}
我有一个偏移集合，它映射到
偏移模型
对象。每个游览都有一个geolocation属性，该属性使用
GeoJsonPoint
规范存储其位置，如下所示：

“地理定位”：{
“坐标”：[73.739978,15.606188]，
“类型”：“点”
}
现在，当用户试图添加附近的过滤器以获取指定距离内的偏移时，我在查询对象（
org.springframework.data.mongodb.core.query.query
）上添加了一个
$nearSphere
条件，如下所示

if（userRequest.getDistInMeters（）！=null）{
query.addCriteria（Criteria.where（“地理位置”）
.nearSphere（userModel.getLastKnown坐标（））
.maxDistance（userRequest.getDistInMeters（））
);
}
从技术上讲，这应转化为以下内容：

。。。
“地理定位”：{
$nearSphere：{
$geometry：{
键入：“点”，
座标：[77.596503，12.966267]
},
$maxDistance:10000
}
}...
（如果distInMeters=10000）

但是，我认为这相当于：

。。。
“地理定位”：{
“$nearSphere”：{
“$geometry”：{
“$java”：点[x=-3.703790，y=40.416775]
} 
} 
}...
请注意，
GeoJsonPoint
的转换不正确。我还得到以下异常

org.bson.codecs.configuration.CodecConfigurationException:找不到类org.springframework.data.mongodb.core.geo.GeoJsonPoint的编解码器。
产出全文：

路径为[]的上下文中Servlet[dispatcherServlet]的
Servlet.service（）引发异常[请求处理失败；嵌套异常为org.bson.codecs.configuration.CodecConfigurationException:找不到类org.springframework.data.mongodb.core.geo.GeoJsonPoint.]的编解码器，其根本原因是
org.bson.codecs.configuration.CodecConfigurationException:找不到类org.springframework.data.mongodb.core.geo.GeoJsonPoint的编解码器。
位于org.bson.internal.CodecCache.getorhrow（CodecCache.java:57）
位于org.bson.internal.ProvidersCodeRegistry.get（ProvidersCodeRegistry.java:64）
位于org.bson.internal.ChildCodecRegistry.get（ChildCodecRegistry.java:52）
位于org.bson.codecs.DocumentCodec.writeValue（DocumentCodec.java:197）
位于org.bson.codecs.DocumentCodec.writeMap（DocumentCodec.java:212）
位于org.bson.codecs.DocumentCodec.writeValue（DocumentCodec.java:195）
位于org.bson.codecs.DocumentCodec.writeMap（DocumentCodec.java:212）
位于org.bson.codecs.DocumentCodec.writeValue（DocumentCodec.java:195）
位于org.bson.codecs.DocumentCodec.writeMap（DocumentCodec.java:212）
位于org.bson.codecs.DocumentCodec.encode（DocumentCodec.java:154）
位于org.bson.codecs.DocumentCodec.encode（DocumentCodec.java:45）
位于org.bson.BsonDocumentWrapper.getUnwrapped（BsonDocumentWrapper.java:195）
位于org.bson.BsonDocumentWrapper.isEmpty（BsonDocumentWrapper.java:115）
位于com.mongodb.internal.operation.DocumentHelper.putIfNotNullOrEmpty（DocumentHelper.java:43）
位于com.mongodb.internal.operation.findoOperation.getCommand（findoOperation.java:792）
访问com.mongodb.internal.operation.findoOperation.access$1600（findoOperation.java:77）
位于com.mongodb.internal.operation.findoOperation$4.create（findoOperation.java:858）
位于com.mongodb.internal.operation.CommandOperationHelper.executeCommandWithConnection（CommandOperationHelper.java:219）
位于com.mongodb.internal.operation.findoOperation$1.call（findoOperation.java:631）
位于com.mongodb.internal.operation.findoOperation$1.call（findoOperation.java:625）
位于com.mongodb.internal.operation.OperationHelper.withReadConnectionSource（OperationHelper.java:462）
位于com.mongodb.internal.operation.findoOperation.execute（findoOperation.java:625）
位于com.mongodb.internal.operation.findoOperation.execute（findoOperation.java:77）
位于com.mongodb.client.internal.MongoClientDelegate$DelegateOperationExecutor.execute（MongoClientDelegate.java:190）
位于com.mongodb.client.internal.mongoiterableempl.execute（mongoiterableempl.java:135）
位于com.mongodb.client.internal.mongoiterableempl.iterator（mongoiterableempl.java:92）
位于com.example.commercial.backend.dao.shiftiondao.getAllExcursions（shiftionsdao.java:140）
位于com.example.commercial.backend.service.touringservice.getAllExcursions（touringService.java:70）
位于com.example.commercial.backend.controller.shiftioncontroller.getAllExcursions（shiftionController.java:38）
在sun.reflect.NativeMethodAccessorImpl.invoke0（本机方法）处
位于sun.reflect.NativeMethodAccessorImpl.invoke（NativeMethodAccessorImpl.java:62）
在sun.reflect.DelegatingMethodAccessorImpl.invoke（DelegatingMethodAccessorImpl.java:43）中
位于java.lang.reflect.Method.invoke（Method.java:498）
位于org.springframework.web.method.support.InvocableHandlerMethod.doInvoke（InvocableHandlerMethod.java:190）
位于org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest（InvocableHandlerMethod.java:138）
位于org.springframework.web.servlet.mvc.method.annotation.ServletinVaccableHandlerMethod.invokeAndHandle（ServletinVaccableHandlerMethod.java:105）
位于org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod（RequestMappingHandlerAdapter.java:878）
位于org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal（RequestMappingHandlerAdapter.java:792）
位于org.springframework.web.servlet.mvc.method.Abs

Criteria criteria = Criteria.where(key).is(value);
Query query = Query.query(criteria).skip(num).limit(num);
List<ExcursionsModel> excursions = mongoTemplate.find(query, ExcursionsModel.class);



package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.geo.Metrics;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.GeoNearOperation;
import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
import org.springframework.data.mongodb.core.index.GeoSpatialIndexType;
import org.springframework.data.mongodb.core.index.GeoSpatialIndexed;
import org.springframework.data.mongodb.core.index.GeospatialIndex;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.NearQuery;
import org.springframework.data.mongodb.core.query.Query;

import java.util.ArrayList;
import java.util.List;

@SpringBootApplication
public class So63886374Application {

    public static void main(String[] args) {
        SpringApplication.run(So63886374Application.class, args);
    }

    @Autowired
    private MongoTemplate mongoTemplate;

    public void queryData()  {
        //Distance from fort worth - 45 miles - output dallas - 200 miles - austin/dallas - 300 miles - austin/dallas/houston
        Criteria criteria = Criteria.where("geolocation").nearSphere(new GeoJsonPoint(-97.3327459, 32.753177)).maxDistance(200*1609.34);
        Query query = Query.query(criteria);
        List<ExcursionsModel> excursionsModels = mongoTemplate.find(query, ExcursionsModel.class);
        excursionsModels.forEach(es -> System.out.println(es.getGeolocation()));

        //Aggregation query to capture distance
        NearQuery nearQuery = NearQuery.near(-97.3327459, 32.753177, Metrics.MILES).maxDistance(200);
        GeoNearOperation geoNearOperation = Aggregation.geoNear(nearQuery, "distanceFromFW");
        Aggregation aggregation = Aggregation.newAggregation(geoNearOperation);
        List<ExcursionsModel> excursionsModelsAg = mongoTemplate.aggregate(aggregation, ExcursionsModel.class, ExcursionsModel.class).getMappedResults();
        excursionsModelsAg.forEach(es -> System.out.println(es.getDistanceFromFW()));
    }

    @Document
    public class ExcursionsModel {
        @GeoSpatialIndexed(name = "geoIndex", type = GeoSpatialIndexType.GEO_2DSPHERE)
        private GeoJsonPoint geolocation;
        private long distanceFromFW;
        public void setGeolocation(GeoJsonPoint geolocation) {
            this.geolocation = geolocation;
        }

        public GeoJsonPoint getGeolocation() {
            return geolocation;
        }

        public long getDistanceFromFW() {
            return distanceFromFW;
        }

        public void setDistanceFromFW(long distanceFromFW) {
            this.distanceFromFW = distanceFromFW;
        }
    }

    public void insertData()  {
        List<ExcursionsModel> excursionsModels = new ArrayList<>();
        mongoTemplate.indexOps(ExcursionsModel.class).ensureIndex(new GeospatialIndex("geolocation").named("geoIndex").typed(GeoSpatialIndexType.GEO_2DSPHERE));
        ExcursionsModel austin = new ExcursionsModel();
        austin.setGeolocation(new GeoJsonPoint( -97.7436995, 30.2711286));
        ExcursionsModel houston = new ExcursionsModel();
        houston.setGeolocation(new GeoJsonPoint(-95.3676974, 29.7589382));
        ExcursionsModel dallas = new ExcursionsModel();
        dallas.setGeolocation(new GeoJsonPoint(-96.7968559, 32.7762719));
        excursionsModels.add(austin);
        excursionsModels.add(houston);
        excursionsModels.add(dallas);
        mongoTemplate.insert(excursionsModels, ExcursionsModel.class);
    }

    public void dropData() {
        mongoTemplate.dropCollection(ExcursionsModel.class);
    }

    @Bean
    public ApplicationRunner runner() {
        return args -> {
            dropData();
            insertData();
            queryData();
        };
    }

}



Point [x=-96.796856, y=32.776272] //Dallas
Point [x=-97.743700, y=30.271129] //Austin
31
173



public void queryData()  {
    //Distance from fort worth - 45 miles - output dallas - 200 miles - austin/dallas - 300 miles - austin/dallas/houston
    MongoClient mongoClient = MongoClients.create();
    MongoDatabase database = mongoClient.getDatabase("test");
    Point refPoint = new Point(new Position(-97.3327459, 32.753177));
    Bson filters = Filters.nearSphere("geolocation", refPoint, 200*1609.34, 0.0);
    CodecRegistry pojoCodecRegistry = fromRegistries(MongoClientSettings.getDefaultCodecRegistry(),
                fromProviders(PojoCodecProvider.builder().register(ExcursionsModel.class).build()));
    FindIterable<ExcursionsModel> excursionsModels = database.getCollection("excursionsmodel", ExcursionsModel.class).withCodecRegistry(pojoCodecRegistry).find(filters);
        excursionsModels.forEach(es -> System.out.println(es.getGeolocation()));
    }

public static class ExcursionsModel {
    private Point geolocation;    
    public void setGeolocation(Point geolocation) {
        this.geolocation = geolocation;
    }
    public Point getGeolocation() {
        return geolocation;
    }
}



Point{coordinate=Position{values=[-96.7968559, 32.7762719]}}
Point{coordinate=Position{values=[-97.7436995, 30.2711286]}}



db.user.createIndex({ geolocation : "2dsphere" } );