spring mongodb geo 位置搜索服务 示例

最新推荐文章于 2024-07-05 11:15:56 发布
最新推荐文章于 2024-07-05 11:15:56 发布
阅读量2.5k 收藏 5
点赞数
分类专栏： mongodb 学习笔记 mongodb 随手笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhiwengang/article/details/53099580
版权

1、项目关联jar文件


2、配置mongodb.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mongo="http://www.springframework.org/schema/data/mongo"
	xsi:schemaLocation="http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.1.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
	<!-- Default bean name is 'mongo' -->
	<mongo:mongo host="192.168.1.88" port="27017" />
	<mongo:db-factory dbname="database" mongo-ref="mongo" />
	
	<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
		<constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />		
	</bean>
	
	<bean id="businessDao" class="com.spring.operation.BusinessDao"></bean>
	<bean id="businessPositionDao" class="com.spring.operation.BusinessPositionDao"></bean>
	<bean id="mongoDaoImpl" class="com.spring.operation.MongoDaoImpl"></bean>
</beans>

3、mongodb 父接口类 

<span style="font-size:12px;">package com.spring.mongodb;

import java.util.List;
import com.mongodb.DBObject;  
  
/** 
 * mongodb 父接口类 
 * @author zhouzhigang 
 * @version 1.1 
 * @date 2016年11月09日-下午1:42:23 
 */  
public interface  MongoDao {  
      
    public DBObject findOne(String collection, DBObject query, DBObject fields);  
       
    public List<DBObject> find(String collection, DBObject query, DBObject fields, DBObject orderBy, int pageNum, int pageSize);  
   
    public List<DBObject> find(String collection, DBObject query, DBObject fields, DBObject orderBy, int limit);  
   
    public void delete(String collection, DBObject dbObject);  
   
    public void save(String collection, DBObject dbObject);  
   
    public void update(String collection, DBObject query, DBObject update, boolean upsert, boolean multi);  
   
    public Long count(String collection, DBObject query);  
   
    public List<?> distinct(String collection, String key, DBObject query);  
   
}  </span>


4、Mondodb 地址运算 接口类 

<span style="font-size:12px;">package com.spring.mongodb;


import com.mongodb.DBObject;  
import com.spring.entity.Point;
import java.util.List;  
/**
 * Mondodb 地址运算 接口类
 * 
 * @author zhouzhigang
 * @version 1.1
 * @date 2016年11月09日-下午1:50:06
 */
public interface MongoGeoDao extends MongoDao {
	/**
	 * 聚合查询，查询一个点附近的点，并返回每一个点到该中心点的距离，在坐标表分片的情况下$nearSphere不支持， 可以使用该方法进行查询
	 * 
	 * @param collection
	 *            集合名称
	 * @param query
	 *            查询条件
	 * @param point
	 *            中心点坐标
	 * @param limit
	 *            返回记录数量限制
	 * @param maxDistance
	 *            最大距离
	 * @return 非NULL的list
	 */
	public List<DBObject> geoNear(String collection, DBObject query,
			Point point, int limit, long maxDistance);

	/**
	 * 查询在圆形区域内的坐标点，需要指定中心点坐标和半径，半径单位是米
	 * 
	 * @param collection
	 *            集合名称
	 * @param locationField
	 *            坐标字段
	 * @param center
	 *            中心点坐标[经度，纬度]
	 * @param radius
	 *            半径 单位:米
	 * @param fields
	 *            查询字段
	 * @param query
	 *            查询条件
	 * @param limit
	 *            返回记录限制数量
	 * @return 非NULL的list
	 */
	public List<DBObject> withinCircle(String collection, String locationField,
			Point center, long radius, DBObject fields, DBObject query,
			int limit);

	/**
	 * 指定一个点，返回该点附近的坐标点且是由近到远,$nearSphere 需要建立索引2dsphere 或者2d,并且支持GeoJSON和一般坐标对
	 * 注意: $nearSphere在分片的集群中无效，使用geoNear
	 * 
	 * @param collection
	 *            集合名称
	 * @param locationField
	 *            坐标字段
	 * @param center
	 *            中心点坐标[经度，纬度]
	 * @param minDistance
	 *            最近距离
	 * @param maxDistance
	 *            最远距离
	 * @param query
	 *            查询条件
	 * @param fields
	 *            查询字段
	 * @param limit
	 *            返回记录限制数量
	 * @return 非NULL的list
	 */
	public List<DBObject> nearSphere(String collection, String locationField,
			Point center, long minDistance, long maxDistance, DBObject query,
			DBObject fields, int limit);

	/**
	 * 查询位于指定一个封闭多边形内的所有坐标点，给定的多边形坐标点必须首位相接形成封闭的多边形 如三角形 final
	 * LinkedList<double[]> polygon = new LinkedList<>(); polygon.addLast(new
	 * double[] { 121.36, 31.18 }); polygon.addLast(new double[] { 121.35, 31.36
	 * }); polygon.addLast(new double[] { 121.39, 31.17 }); polygon.addLast(new
	 * double[] { 121.36, 31.18 });
	 * 
	 * MongoDB将多边形的边界也作为查询形状的一部分
	 * 
	 * @param collection
	 *            集合名称
	 * @param locationField
	 *            坐标字段
	 * @param polygon
	 *            多边形坐标
	 * @param fields
	 *            查询字段
	 * @param query
	 *            查询条件
	 * @param limit
	 *            返回记录限制数量
	 * @return 非NULL的list
	 */
	public List<DBObject> withinPolygon(String collection,
			String locationField, List<double[]> polygon, DBObject fields,
			DBObject query, int limit);

	/**
	 * 查询位于指定多个封闭多边形内的所有坐标点，给定的多边形坐标点必须首位相接形成封闭的多边形
	 * 
	 * @param collection
	 *            集合名称
	 * @param locationField
	 *            坐标字段
	 * @param polygons
	 *            多边形坐标 数组
	 * @param fields
	 *            查询字段
	 * @param query
	 *            查询条件
	 * @param limit
	 *            返回记录限制数量
	 * @return 非NULL的list
	 */
	public List<DBObject> withinMultiPolygon(String collection,
			String locationField, List<List<double[]>> polygons,
			DBObject fields, DBObject query, int limit);

	/**
	 * 在矩形区域内查找坐标点，该方法仅仅在2d索引是支持，在2dsphere中不支持
	 * 
	 * @param collection
	 *            集合名称
	 * @param locationField
	 *            坐标字段
	 * @param bottomLeft
	 *            左下角
	 * @param upperRight
	 *            右上角
	 * @param fields
	 *            查询字段
	 * @param query
	 *            查询条件
	 * @param limit
	 *            返回记录限制数量
	 * @return 非NULL的list
	 */
	@Deprecated
	public List<DBObject> withinBox(String collection, String locationField,
			Point bottomLeft, Point upperRight, DBObject fields,
			DBObject query, int limit);

}</span><span style="font-size: 15px;">
</span>


5、mongodb 服务实现类

package com.spring.operation;

import com.mongodb.AggregationOptions;  
import com.mongodb.BasicDBObject;  
import com.mongodb.Cursor;  
import com.mongodb.DBObject;  
import com.spring.entity.Point;
import com.spring.mongodb.MongoGeoDao;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.data.mongodb.core.MongoTemplate;   
import java.util.ArrayList;  
import java.util.LinkedList;  
import java.util.List;  

public class MongoDaoImpl implements MongoGeoDao {  
    
    private static Logger logger = LoggerFactory.getLogger(MongoDaoImpl.class);  
      
    @Autowired  
    private MongoTemplate mongoTemplate;  
   
   
    public DBObject findOne(String collection, DBObject query, DBObject fields) {  
        return mongoTemplate.getCollection(collection).findOne(query, fields);  
    }  
   
   
    public List<DBObject> find(String collection, DBObject query, DBObject fields, DBObject orderBy, int pageNum, int pageSize) {  
        List<DBObject> list = new ArrayList<DBObject>();  
        Cursor cursor = mongoTemplate.getCollection(collection).find(query, fields).skip((pageNum - 1) * pageSize).limit(pageSize).sort(orderBy);  
        while (cursor.hasNext()) {  
            list.add(cursor.next());  
        }  
        return list.size() > 0 ? list : null;  
    }  
   
 
    public List<DBObject> find(String collection, DBObject query, DBObject fields, DBObject orderBy, int limit) {  
        List<DBObject> list = new ArrayList<DBObject>();  
        Cursor cursor = mongoTemplate.getCollection(collection).find(query, fields).sort(orderBy).limit(limit);  
        while (cursor.hasNext()) {  
            list.add(cursor.next());  
        }  
        return list.size() > 0 ? list : null;  
    }  
   
   
    public void delete(String collection, DBObject dbObject) {  
        mongoTemplate.getCollection(collection).remove(dbObject);  
    }  
   
  
    public void save(String collection, DBObject dbObject) {  
        mongoTemplate.getCollection(collection).save(dbObject);  
    }  
   
 
    public void update(String collection, DBObject query, DBObject update, boolean upsert, boolean multi) {  
        mongoTemplate.getCollection(collection).update(query, update, upsert, multi);  
    }  
   
   
    public Long count(String collection, DBObject query) {  
        return mongoTemplate.getCollection(collection).count(query);  
    }  
   

    public List<?> distinct(String collection, String key, DBObject query) {  
        return mongoTemplate.getCollection(collection).distinct(key, query);  
    }  
   
  
    public List<DBObject> geoNear(String collection, DBObject query, Point point, int limit, long maxDistance) {  
        if(query==null)  
            query = new BasicDBObject();  
   
        List<DBObject> pipeLine = new ArrayList<DBObject>();  
        BasicDBObject aggregate = new BasicDBObject("$geoNear",  
        	    new BasicDBObject("near",new BasicDBObject("type","Point").append("coordinates",new double[]{point.getLng(), point.getLat()}))    
        				.append("distanceField","dist.calculated")  
                        .append("query", query)  
                        .append("num", limit)  
                        .append("maxDistance", maxDistance)  
                        .append("spherical",true)  
                );  
        pipeLine.add(aggregate);  
        Cursor cursor=mongoTemplate.getCollection(collection).aggregate(pipeLine, AggregationOptions.builder().build());  
        List<DBObject> list = new LinkedList<DBObject>();  
        while (cursor.hasNext()) {  
            list.add(cursor.next());  
        }  
        return list;  
    }  
   
 
    public List<DBObject> withinCircle(String collection,String locationField, Point center,  
                                       long radius, DBObject fields, DBObject query, int limit) {  
        LinkedList<Object> circle = new LinkedList<Object>();  
        //Set the center coordinate  
        circle.addLast(new double[]{center.getLng(),center.getLat()});  
        //Set the radius. unit:meter  
        circle.addLast(radius/6378137.0);  
   
        if(query==null)  
            query = new BasicDBObject();  
        query.put(locationField, new BasicDBObject("$geoWithin", new BasicDBObject("$centerSphere", circle)));  
        logger.info("withinCircle:{}",query.toString());  
        return mongoTemplate.getCollection(collection).find(query, fields).limit(limit).toArray();  
    }  
   
  
    public List<DBObject> nearSphere(String collection, String locationField, Point center,  
                                     long minDistance, long maxDistance, DBObject query, DBObject fields, int limit) {  
        if(query==null)  
            query = new BasicDBObject();  
   
        query.put(locationField,  
                new BasicDBObject("$nearSphere",  
                    new BasicDBObject("$geometry",  
                            new BasicDBObject("type","Point")  
                                    .append("coordinates",new double[]{center.getLng(),center.getLat()}))  
                            .append("$minDistance",minDistance)  
                            .append("$maxDistance",maxDistance)  
        ));  
        logger.info("nearSphere:{}",query.toString());  
        return mongoTemplate.getCollection(collection).find(query, fields).limit(limit).toArray();  
    }  
   
  
    public List<DBObject> withinPolygon(String collection, String locationField,  
                                        List<double[]> polygon, DBObject fields, DBObject query, int limit) {  
        if(query==null)  
            query = new BasicDBObject();  
   
        List<List<double[]>> polygons = new LinkedList<List<double[]>>();  
        polygons.add(polygon);  
        query.put(locationField, new BasicDBObject("$geoWithin",  
                new BasicDBObject("$geometry",  
                        new BasicDBObject("type","Polygon")  
                        .append("coordinates",polygons))));  
        logger.info("withinPolygon:{}",query.toString());  
        return mongoTemplate.getCollection(collection).find(query, fields).limit(limit).toArray();  
    }  
   
  
    public List<DBObject> withinMultiPolygon(String collection, String locationField, List<List<double[]>> polygons, DBObject fields, DBObject query, int limit) {  
        if(query==null)  
            query = new BasicDBObject();  
   
        List<List<List<double[]>>> list = new LinkedList<List<List<double[]>>>();  
        for (List<double[]> polygon : polygons) {  
            List<List<double[]>> temp = new LinkedList<List<double[]>>();  
            temp.add(polygon);  
            list.add(temp);  
        }  
        query.put(locationField, new BasicDBObject("$geoWithin",  
                new BasicDBObject("$geometry",  
                        new BasicDBObject("type","MultiPolygon")  
                                .append("coordinates",list))));  
        logger.info("withinMultiPolygon:{}",query.toString());  
        return mongoTemplate.getCollection(collection).find(query, fields).limit(limit).toArray();  
    }  
   
 
    public List<DBObject> withinBox(String collection, String locationField, Point bottomLeft, Point upperRight, DBObject fields, DBObject query, int limit) {  
        if(query==null)  
            query = new BasicDBObject();  
   
        LinkedList<double[]> box = new LinkedList<double[]>();  
        box.add(new double[]{bottomLeft.getLng(), bottomLeft.getLat()});  
        box.add(new double[]{upperRight.getLng(), upperRight.getLat()});  
   
        query.put(locationField, new BasicDBObject("$geoWithin", new BasicDBObject("$box", box)));  
        logger.info("withinBox:{}",query.toString());  
        return mongoTemplate.getCollection(collection).find(query, fields).limit(limit).toArray();  
    }  
   
}

6、添加数据 

db.point.test.insert({"address" : "南京 禄口国际机场","loc" : { "type": "Point", "coordinates": [118.783799,31.979234]}})  
db.point.test.insert({"address" : "南京 浦口公园","loc" : { "type": "Point", "coordinates": [118.639523,32.070078]}})  
db.point.test.insert({"address" : "南京 火车站","loc" : { "type": "Point", "coordinates": [118.803032,32.09248]}})  
db.point.test.insert({"address" : "南京 新街口","loc" : { "type": "Point", "coordinates": [118.790611,32.047616]}})  
db.point.test.insert({"address" : "南京 张府园","loc" : { "type": "Point", "coordinates": [118.790427,32.03722]}})  
db.point.test.insert({"address" : "南京 三山街","loc" : { "type": "Point", "coordinates": [118.788135,32.029064]}})  
db.point.test.insert({"address" : "南京 中华门","loc" : { "type": "Point", "coordinates": [118.781161,32.013023]}})  
db.point.test.insert({"address" : "南京 安德门","loc" : { "type": "Point", "coordinates": [118.768964,31.99646]}})


7、必须加索引 （为什么：https://docs.mongodb.com/manual/reference/operator/aggregation/geoNear/） 
db.集合名称.ensureIndex( { loc : "2dsphere" } )

8、调用实例 

package com.spring.main;

import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import com.spring.entity.BusinessPosition;
import com.spring.entity.Point;
import com.spring.entity.Positions;
import com.spring.operation.BusinessPositionDao;
import com.spring.operation.MongoDaoImpl;

@RunWith(SpringJUnit4ClassRunner.class)  //使用junit4进行测试    
@ContextConfiguration(locations={"classpath*:mongodb.xml"}) 

public class DistanceMain {
	@Autowired 
	private BusinessPositionDao businessPositionDao;
	@Autowired 
	private MongoDaoImpl mongoDaoImpl;

	 @Test  
	 public void test1(){  		 
		 DBObject object = new BasicDBObject();
		 object.put("address", "南京 安德门");
		 DBObject subObject = new BasicDBObject();
		 subObject.put("type", "Point");
		 double[] addre = new double[2];
		 addre[0] = 118.768964;
		 addre[1] = 31.99646;
		 subObject.put("coordinates",addre);
		 object.put("loc", subObject);
		 mongoDaoImpl.save("positions",object);
		 System.out.println("数据插入成功");
	 }
	 
	 @Test  
	 public void test2(){  
		double lng = 118.768964;
		double lat = 31.99656;
		
		Point point = new Point(); 
		point.setLat(lat);
		point.setLng(lng);
		DBObject query = new BasicDBObject();
		int limit =10;
		long maxDistance = 1000;
		List<DBObject> list = mongoDaoImpl.geoNear("positions", query, point, limit, maxDistance);
		if(list !=null && list.size()>0){
			for(DBObject obj:list){
				System.out.println("商家地址："+(String)obj.get("address"));
			}
		}
		
		
		
		
	 }

}<span style="font-size: 15px;">
</span>





在奋斗的大道
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mongodb计算地理空间距离实例
java框架技术
09-17 919
[size=large]需求：有很多条件，其中包括根据附近多少米查找信息，这个需要先定位当前人所在的位置（即经纬度），然后在进行这个经纬度的附近进行查找信息，因为之前根据经纬度算地理空间位置是在mysql中进行的，但是发现在mysql中计算很耗CPU，现特改成mongodb来做，mongodb不支持union all功能，所以mongodb还是不满足[/size]： [code="java"] ...
使用Mongodb中的$nearSphere实现查询附近的元素
weixin_40378837的博客
07-28 2161
产品背景：需要根据客户端传过来的用户gps坐标查看附近1km是否有跑步路线。 技术背景：该项目使用的数据库是mongodb。 (内心背景:想顺便学习mongodb) 经查阅mongodb相关文档，发现Mongodb中的$nearSphere很适合这个场景，于是经技术评审后决定采用$nearSphere来做。 定义 $nearSphere 指定地理空间查询从最近到最远返回文档的点。 MongoDB 使用球面几何计算$nearSphere的距离。 $nearSphere需要地理空间索.
mongodb java 部分示例
feiying00544的博客
08-05 114
package com.commons.core.storage.mongoDb; import com.commons.core.CommonErrorCode; import com.commons.core.storage.mongoDb.config.MongoDbConfig; import com.commons.core.storage.mongoDb.config.MongoD...
无涯教程-MongoDB - 地理空间命令(GEO)
最新发布
无涯教程
07-05 490
Geospatial命令只包含一个命令，它是。它用于执行利用索引函数的地理空间查询。它通过创建由第二个标准分组的对象的存储桶来增加搜索。
mongodb 3.6 aggregate 报错 The 'cursor' option is required
发歌的数据架构
04-12 2229
高版本3.6导致聚合操作失败 报错如下 The 'cursor' option is required, except for aggregate with the explain argument 解决办法： 1，升级spring 版本 upgrade your Spring Data MongoDB dependency to 1.10.10.RELEASE upgrade you...
java对MongoDB的聚合操作(BasicDBObject)
shinyprince的专栏
05-21 1万+
//list ArrayList list = new ArrayList(); BasicDBObject or = new BasicDBObject(); or.put("date", new BasicDBObject("$gte", t.getStart()).append("$lte", t.getEnd())); list.add(or);
SpringMongodb参考文档.docx
06-08
Spring Data MongoDB 2.1中的新特性 5.2。Spring Data MongoDB 2.0中的新特性 5.3。Spring Data MongoDB 1.10中的新特性 5.4。Spring Data MongoDB 1.9中的新特性 5.5。Spring Data MongoDB 1.8中的新特性 5.6。...
Spring Mongodb Maven示例
11-16
Spring MongoDB Maven 示例是一个集成Spring框架、MongoDB数据库和Maven构建工具的项目，旨在提供一个基础的、易于理解的学习平台，帮助开发者快速上手MongoDB在Spring应用中的使用。在这个项目中，你将看到如何配置...
Spring Data MongoDB中文文档
02-22
- **Spring Data MongoDB** 还提供了一些高级特性，例如 GridFS 支持、地理空间查询、全文搜索等。 - 这些特性极大地丰富了与 MongoDB 交互的方式，使得 **Spring Data MongoDB** 成为了与 MongoDB 集成的理想选择。...
node.js基于mongodb的搜索分页示例
10-20
在Node.js中，结合MongoDB实现搜索分页是一项常见的任务，尤其在构建Web应用程序时。以下将详细讲解如何使用Node.js和Mongoose库来完成这一功能。 首先，我们需要引入Mongoose库，它是一个用于MongoDB的数据建模...
Spring+MongoDB实现登录注册功能
08-30
Spring+MongoDB实现登录注册功能 本文主要介绍了使用Spring框架和MongoDB...本文详细介绍了使用Spring框架和MongoDB数据库实现登录注册功能的详细步骤和代码实现，旨在提供一个完整的解决方案，供读者参考和学习。
MongoDB 位置信息存储及查询
02-27
MongoDB 位置信息存储及查询，批量插入或更新位置信息，查询位置点是否在指定区域内（圆形区域、矩形区域、多边形区域）。
springboot+mongodb实现对指定经纬度，半径范围内的数据进行搜索
万米高空的博客
11-22 7082
目前公司开的线下店铺有这麽一个要求：需要知道店铺附近1000米内是否存在中小学，以供后续的业务逻辑操作。 数据前提：大数据的同学已经把公司将要入驻和已经入住的城市的中小学数据通过爬虫将数据存放到mongodb中。所以需要在mongodb中查询指定店铺所在经纬度的一公里范围内的学校信息。 而mongodb正好提供了这种地理经纬度搜索的能力，只要数据符合指定的结构，给要搜索的字段加上特定的索引，即可...
如何在Spring Boot项目使用参数校验
热门推荐
三劫散仙
11-02 3万+
开发web项目有时候我们需要对controller层传过来的参数进行一些基本的校验，比如非空，非null，整数值的范围，字符串的个数，日期，邮箱等等。最常见的就是我们直接写代码校验，这样以后比较繁琐，而且不够灵活。 Bean Validation 1.0（JSR-303）是一个校验规范，在Spring Boot项目由于自带了Hibernate validator 5(http://hiber
mongodb-mongotemplate进行地理坐标操作
石头视角
09-13 1971
因为项目中使用的springboot + mongotemplate, 所以还是需要mongotemplate的操作方式 首先建立一个bean:    package com.iwhere.easy.travel.entity; import java.io.Serializable; import java.util.Arrays; import org.springframewor...
Spring-Data-MongoDB 坐标操作——Geo2d
diaohan1348的博客
06-04 346
1.在实体类的坐标字段加上注解@GeoSpatialIndexed @Document(collection="location") public class LocationPO extends BaseEntity { @Id private ObjectId id; @GeoSpatialIndexed private doubl...
mongoDB地理位置检索
yunxiaoHOU的博客
03-03 1343
查询附近 @Test public void testNear() { //构造坐标点 GeoJsonPoint point = new GeoJsonPoint(116.404, 39.915); //构造半径 Distance distanceObj = new Distance(1, Metrics.KILOMETERS); //画了一个圆圈 Circle circle = new Circle(point, distanceObj); //
mongodb指南（翻译）（二十） - developer zone - 索引（四）地理信息索引
weixin_30318645的博客
01-18 94
v1.4+ MongoDB支持2维地理信息索引。它被设计用来进行脑海中基于位置的查询，诸如“查找距离我的位置最近的N个场所”。它还可以高效的处理额外的查询条件，比如“查找距离我的位置最近的N个博物馆”。 为了可以使用这种索引，你需要在你的对象中设置一个字段，该字段可以是一个子对象或者前两个元素为x，y坐标的数组（或者y,x-只要一致就行；为了确保一致性，推荐在你的客户端代码中使用保持排序的词典...
MongoDB-JAVA-Driver 3.2版本常用代码全整理(4) - 地理空间索引
weixin_30448603的博客
05-18 126
MongoDB的3.x版本Java驱动相对2.x做了全新的设计，类库和使用方法上有很大区别。例如用Document替换BasicDBObject、通过Builders类构建Bson替代直接输入$命令等，本文整理了基于3.2版本的常用增删改查操作的使用方法。为了避免冗长的篇幅，分为增删改、查询、聚合、地理索引等几部分。 随着移动设备的普及，基于坐标和经纬度的位置查询变得越来越流行，例如查找...
spring mongodb
09-06
Spring MongoDB是一个用于在Spring应用程序中与MongoDB数据库交互的模块。它提供了与MongoDB进行连接、查询、更新和删除等操作的简化API。 使用Spring MongoDB，你可以通过注解或XML配置来定义数据模型，以及使用注解来定义数据库操作。它还提供了一些便捷的功能，如分页查询、排序和聚合操作等。 在Spring Boot项目中，你可以通过添加spring-boot-starter-data-mongodb依赖来引入Spring MongoDB模块。这个模块会自动配置MongoDB连接和操作相关的Bean，使得在应用中使用MongoDB变得更加方便。 另外，你还可以使用Spring Data MongoDB来进一步简化与MongoDB的交互。Spring Data MongoDB是Spring Data项目的一部分，它提供了更高级的抽象和功能，如Repository接口、自动化查询、事务管理等。 总之，Spring MongoDB是一个强大的工具，可以帮助你在Spring应用程序中轻松地集成和使用MongoDB数据库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值