查询文档

您可以使用 和 类来表示您的查询。 它们具有镜像本机 MongoDB 运算符名称的方法名称，例如 、 等。 和 类遵循 Fluent API 样式，因此您可以将多个方法条件和查询链接在一起，同时拥有易于理解的代码。 为了提高可读性，静态导入允许您避免使用 'new' 关键字来创建实例。 您还可以使用从纯 JSON 字符串创建实例，如以下示例所示：QueryCriterialtlteisQueryCriteriaQueryCriteriaBasicQueryQueryspring-doc.cn

示例 1.从纯 JSON 字符串创建 Query 实例
BasicQuery query = new BasicQuery("{ age : { $lt : 50 }, accounts.balance : { $gt : 1000.00 }}");
List<Person> result = mongoTemplate.find(query, Person.class);

查询集合中的文档

之前，我们了解了如何使用 和 方法检索单个文档。 这些方法以正确的方式返回单个域对象，或者使用响应式 API 发出单个元素。 我们还可以查询要作为域对象列表返回的文档集合。 假设我们在集合中存储了许多具有 name 和 age 的对象作为文档，并且每个人都有一个具有余额的嵌入式帐户文档，我们现在可以使用以下代码运行查询：findOnefindByIdMongoTemplateMonoPersonspring-doc.cn

使用 MongoTemplate 查询文档
import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Query.query;

// ...

List<Person> result = template.query(Person.class)
  .matching(query(where("age").lt(50).and("accounts.balance").gt(1000.00d)))
  .all();
import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Query.query;

// ...

Flux<Person> result = template.query(Person.class)
  .matching(query(where("age").lt(50).and("accounts.balance").gt(1000.00d)))
  .all();

所有 find 方法都采用对象作为参数。 此对象定义用于执行查询的条件和选项。 这些条件是通过使用具有名为 Instantiating new object 的静态工厂方法的对象来指定的。 我们建议对 and 使用静态导入，以使查询更具可读性。QueryCriteriawhereCriteriaorg.springframework.data.mongodb.core.query.Criteria.whereQuery.queryspring-doc.cn

查询应返回满足指定条件的对象的 or。 本节的其余部分列出了与 MongoDB 中提供的运算符相对应的 and 类的方法。 大多数方法返回对象，以便为 API 提供 Fluent 样式。ListFluxPersonCriteriaQueryCriteriaspring-doc.cn

Criteria 类的方法

该类提供以下方法，所有这些方法都对应于 MongoDB 中的运算符：Criteriaspring-doc.cn

  • Criteria 都 使用运算符(Object o)$allspring-doc.cn

  • Criteria 和 将具有指定 chained 的 chained 添加到当前 中，并返回新创建的(String key)CriteriakeyCriteriaspring-doc.cn

  • Criteria andOperator 使用运算符为所有提供的条件创建 and 查询（需要 MongoDB 2.0 或更高版本）(Criteria…​ criteria)$andspring-doc.cn

  • Criteria andOperator 使用运算符为所有提供的条件创建 and 查询（需要 MongoDB 2.0 或更高版本）(Collection<Criteria> criteria)$andspring-doc.cn

  • Criteria elemMatch 使用运算符(Criteria c)$elemMatchspring-doc.cn

  • Criteria 存在 使用运算符(boolean b)$existsspring-doc.cn

  • Criteria 燃气轮机 使用运算符(Object o)$gtspring-doc.cn

  • Criteria GTE 使用运算符(Object o)$gtespring-doc.cn

  • Criteria 在 使用 varargs 参数的运算符创建标准。(Object…​ o)$inspring-doc.cn

  • Criteria 在 使用运算符和集合创建标准(Collection<?> collection)$inspring-doc.cn

  • Criteria 是 使用字段匹配 （） 创建标准。如果指定的值是文档，则字段中的顺序和文档中的完全相等性很重要。(Object o){ key:value }spring-doc.cn

  • Criteria 中尉 使用运算符(Object o)$ltspring-doc.cn

  • Criteria LTE 使用运算符(Object o)$ltespring-doc.cn

  • Criteria 国防部 使用运算符(Number value, Number remainder)$modspring-doc.cn

  • Criteria NE 使用运算符(Object o)$nespring-doc.cn

  • Criteria 宁 使用运算符(Object…​ o)$ninspring-doc.cn

  • Criteria norOperator 运算符 使用运算符为所有提供的条件创建 nor 查询(Criteria…​ criteria)$norspring-doc.cn

  • Criteria norOperator 运算符 使用运算符为所有提供的条件创建 nor 查询(Collection<Criteria> criteria)$norspring-doc.cn

  • Criteria 不 使用 meta 运算符创建一个条件，该运算符直接影响 clause 后面的子句()$notspring-doc.cn

  • Criteria orOperator 运算符 使用运算符为所有提供的条件创建 or 查询(Criteria…​ criteria)$orspring-doc.cn

  • Criteria orOperator 运算符 使用运算符为所有提供的条件创建 or 查询(Collection<Criteria> criteria)$orspring-doc.cn

  • Criteria 正则表达式 使用(String re)$regexspring-doc.cn

  • Criteria 采样率 使用运算符(double sampleRate)$sampleRatespring-doc.cn

  • Criteria 大小 使用运算符(int s)$sizespring-doc.cn

  • Criteria 类型 使用运算符(int t)$typespring-doc.cn

  • Criteria matchingDocumentStructure 使用 JSON 架构标准的运算符创建标准。 只能应用于查询的顶层，而不能应用于特定于属性。使用架构的属性与嵌套字段进行匹配。(MongoJsonSchema schema)$jsonSchema$jsonSchemapropertiesspring-doc.cn

  • Criteria bits（） 是 MongoDB 按位查询运算符的网关，如 .$bitsAllClearspring-doc.cn

Criteria 类还为地理空间查询提供了以下方法。spring-doc.cn

  • Criteria 在 使用运算符创建地理空间标准。(Circle circle)$geoWithin $centerspring-doc.cn

  • Criteria 在 使用操作创建地理空间条件。(Box box)$geoWithin $boxspring-doc.cn

  • Criteria 其中 使用运算符创建地理空间标准。(Circle circle)$geoWithin $centerspring-doc.cn

  • Criteria 近 使用操作创建地理空间标准(Point point)$nearspring-doc.cn

  • Criteria 近球体 使用操作创建地理空间条件。这仅适用于 MongoDB 1.7 及更高版本。(Point point)$nearSphere$centerspring-doc.cn

  • Criteria minDistance （最小距离） 使用该操作创建地理空间标准，以便与 $near 一起使用。(double minDistance)$minDistancespring-doc.cn

  • Criteria maxDistance 使用该操作创建地理空间标准，以便与 $near 一起使用。(double maxDistance)$maxDistancespring-doc.cn

该类有一些额外的方法，允许选择某些字段以及限制和排序结果。Queryspring-doc.cn

Query 类的方法

  • Query addCriteria 用于向查询添加其他条件(Criteria criteria)spring-doc.cn

  • Field fields 用于定义要包含在查询结果中的字段()spring-doc.cn

  • Query limit 用于将返回结果的大小限制为提供的 limit （用于分页）(int limit)spring-doc.cn

  • Query skip 用于跳过结果中提供的文档数（用于分页）(int skip)spring-doc.cn

  • Query with used 为结果提供排序定义(Sort sort)spring-doc.cn

  • Query with 用于提供滚动位置（基于 Offset 或 Keyset 的分页）以开始或恢复(ScrollPosition position)Scrollspring-doc.cn

模板 API 允许直接使用结果投影，使您能够针对给定域类型映射查询，同时将操作结果投影到另一个域，如下所述。spring-doc.cn

class

template.query(SWCharacter.class)
    .as(Jedi.class)

有关结果投影的更多信息，请参阅文档的 Projections 部分。spring-doc.cn

选择字段

MongoDB 支持投影查询返回的字段。 投影可以根据字段的名称包含和排除字段（除非明确排除，否则字段始终包含在内）。_idspring-doc.cn

示例 2.选择结果字段
public class Person {

    @Id String id;
    String firstname;

    @Field("last_name")
    String lastname;

    Address address;
}

query.fields().include("lastname");              (1)

query.fields().exclude("id").include("lastname") (2)

query.fields().include("address")                (3)

query.fields().include("address.city")           (4)
1 Result 将同时包含 和 通过 。_idlast_name{ "last_name" : 1 }
2 Result 将仅包含通过 .last_name{ "_id" : 0, "last_name" : 1 }
3 Result 将通过 ._idaddress{ "address" : 1 }
4 Result 将包含 and 对象，该对象仅包含字段 via 。_idaddresscity{ "address.city" : 1 }

从 MongoDB 4.4 开始，您可以将聚合表达式用于字段投影，如下所示：spring-doc.cn

例 3.使用表达式计算结果字段
query.fields()
  .project(MongoExpression.create("'$toUpper' : '$last_name'"))         (1)
  .as("last_name");                                                     (2)

query.fields()
  .project(StringOperators.valueOf("lastname").toUpper())               (3)
  .as("last_name");

query.fields()
  .project(AggregationSpELExpression.expressionOf("toUpper(lastname)")) (4)
  .as("last_name");
1 使用本机表达式。使用的字段名称必须引用数据库文档中的字段名称。
2 分配表达式结果投影到的字段名称。生成的字段名称不会映射到域模型。
3 使用 .除 native 之外，字段名称将映射到域模型中使用的名称。AggregationExpressionMongoExpression
4 将 SpEL 与 一起用于调用表达式函数。字段名称将映射到域模型中使用的字段名称。AggregationExpression

@Query(fields="…")允许在级别使用表达式字段投影，如 MongoDB 基于 JSON 的查询方法和字段限制中所述。Repositoryspring-doc.cn

其他查询选项

MongoDB 提供了多种将元信息（如注释或批处理大小）应用于查询的方法。使用 API 这些选项直接有几种方法。Queryspring-doc.cn

提示

索引提示可以通过两种方式应用，即使用索引名称或其字段定义。spring-doc.cn

template.query(Person.class)
    .matching(query("...").withHint("index-to-use"));

template.query(Person.class)
    .matching(query("...").withHint("{ firstname : 1 }"));

游标批处理大小

游标批处理大小定义每个响应批处理中要返回的文档数。spring-doc.cn

Query query = query(where("firstname").is("luke"))
    .cursorBatchSize(100)

排序规则

将排序规则与集合操作一起使用是在查询或操作选项中指定实例的问题，如以下两个示例所示：Collationspring-doc.cn

Collation collation = Collation.of("de");

Query query = new Query(Criteria.where("firstName").is("Amél"))
    .collation(collation);

List<Person> results = template.find(query, Person.class);

读取首选项

可以直接在要运行的对象上设置 to use，如下所述。ReadPreferenceQueryspring-doc.cn

template.find(Person.class)
    .matching(query(where(...)).withReadPreference(ReadPreference.secondary()))
    .all();
在实例上设置的首选项将取代默认值 。QueryReadPreferenceMongoTemplate

评论

查询可以配备注释，这使得它们更容易在服务器日志中查找。spring-doc.cn

template.find(Person.class)
    .matching(query(where(...)).comment("Use the force luke!"))
    .all();

查询非重复值

MongoDB 提供了一个操作，通过使用结果文档中的查询来获取单个字段的不同值。 结果值不需要具有相同的数据类型，该功能也不限于简单类型。 对于检索，实际结果类型对于转换和键入很重要。以下示例演示如何查询非重复值：spring-doc.cn

示例 4.检索非重复值
template.query(Person.class)  (1)
  .distinct("lastname")       (2)
  .all();                     (3)
1 查询集合。Person
2 选择字段的不同值。字段名称根据 domain types 属性声明进行映射，同时考虑潜在的注释。lastname@Field
3 将所有非重复值检索为 of（由于未指定显式结果类型）。ListObject

将不同值检索到 of 是最灵活的方法，因为它会尝试确定域类型的属性值并将结果转换为所需的类型或映射结构。CollectionObjectDocumentspring-doc.cn

有时候，当 desired field 的所有值都固定为某种类型时，直接获取一个 code typed 会更方便，如下例所示：Collectionspring-doc.cn

例 5.检索强类型非重复值
template.query(Person.class)  (1)
  .distinct("lastname")       (2)
  .as(String.class)           (3)
  .all();                     (4)
1 查询 的集合。Person
2 选择字段的不同值。字段名称根据 domain types 属性声明进行映射，同时考虑潜在的注释。lastname@Field
3 检索到的值将转换为所需的目标类型 — 在本例中为 .如果存储的字段包含文档，也可以将值映射到更复杂的类型。String
4 检索所有非重复值作为 的 。如果该类型无法转换为所需的目标类型，则此方法会抛出 .ListStringDataAccessException

+= 地理空间查询spring-doc.cn

MongoDB 通过使用 、 、 和 等运算符来支持地理空间查询。该类中提供了特定于地理空间查询的方法。还有一些形状类 （、 和 ） 与地理空间相关方法结合使用。$near$withingeoWithin$nearSphereCriteriaBoxCirclePointCriteriaspring-doc.cn

在 MongoDB 事务中使用地理空间查询时需要注意，请参阅事务内的特殊行为。

要了解如何执行 GeoSpatial 查询，请考虑以下类（取自集成测试并依赖于 rich）：VenueMappingMongoConverterspring-doc.cn

Venue.java 
@Document(collection="newyork")
public class Venue {

  @Id
  private String id;
  private String name;
  private double[] location;

  @PersistenceConstructor
  Venue(String name, double[] location) {
    super();
    this.name = name;
    this.location = location;
  }

  public Venue(String name, double x, double y) {
    super();
    this.name = name;
    this.location = new double[] { x, y };
  }

  public String getName() {
    return name;
  }

  public double[] getLocation() {
    return location;
  }

  @Override
  public String toString() {
    return "Venue [id=" + id + ", name=" + name + ", location="
        + Arrays.toString(location) + "]";
  }
}

要在 中查找位置，您可以使用以下查询：Circlespring-doc.cn

Circle circle = new Circle(-73.99171, 40.738868, 0.01);
List<Venue> venues =
    template.find(new Query(Criteria.where("location").within(circle)), Venue.class);

要使用球面坐标查找 内的场所，您可以使用以下查询：Circlespring-doc.cn

Circle circle = new Circle(-73.99171, 40.738868, 0.003712240453784);
List<Venue> venues =
    template.find(new Query(Criteria.where("location").withinSphere(circle)), Venue.class);

要在 中查找 地点，可以使用以下查询：Boxspring-doc.cn

//lower-left then upper-right
Box box = new Box(new Point(-73.99756, 40.73083), new Point(-73.988135, 40.741404));
List<Venue> venues =
    template.find(new Query(Criteria.where("location").within(box)), Venue.class);

要查找 附近的 场所，可以使用以下查询：Pointspring-doc.cn

Point point = new Point(-73.99171, 40.738868);
List<Venue> venues =
    template.find(new Query(Criteria.where("location").near(point).maxDistance(0.01)), Venue.class);
Point point = new Point(-73.99171, 40.738868);
List<Venue> venues =
    template.find(new Query(Criteria.where("location").near(point).minDistance(0.01).maxDistance(100)), Venue.class);

要使用球面坐标查找附近的场馆，可以使用以下查询：Pointspring-doc.cn

Point point = new Point(-73.99171, 40.738868);
List<Venue> venues =
    template.find(new Query(
        Criteria.where("location").nearSphere(point).maxDistance(0.003712240453784)),
        Venue.class);

Geo-near 查询

在 2.2 中更改！
MongoDB 4.2 删除了对以前用于运行 .geoNearNearQueryspring-doc.cn

Spring Data MongoDB 2.2 使用聚合而不是命令来运行 .MongoOperations#geoNear$geoNeargeoNearNearQueryspring-doc.cn

以前在包装器类型中返回的计算距离（使用 geoNear 命令时）现在已嵌入 添加到生成的文档中。 如果给定的域类型已包含具有该名称的属性，则计算的距离 使用可能随机的后缀命名。discalculated-distancespring-doc.cn

目标类型可能包含一个以返回的距离命名的属性，以便（另外）将其直接读回域类型，如下所示。spring-doc.cn

GeoResults<VenueWithDistanceField> = template.query(Venue.class) (1)
    .as(VenueWithDistanceField.class)                            (2)
    .near(NearQuery.near(new GeoJsonPoint(-73.99, 40.73), KILOMETERS))
    .all();
1 用于标识目标集合和潜在查询映射的域类型。
2 包含类型为 的字段的目标类型 。disNumber

MongoDB 支持查询数据库以获取地理位置，并同时计算与给定起点的距离。使用地理位置接近查询，您可以表达诸如“查找周围 10 英里内的所有餐馆”之类的查询。为此，提供了将 a 作为参数的方法（以及已经熟悉的实体类型和集合），如以下示例所示：MongoOperationsgeoNear(…)NearQueryspring-doc.cn

Point location = new Point(-73.99171, 40.738868);
NearQuery query = NearQuery.near(location).maxDistance(new Distance(10, Metrics.MILES));

GeoResults<Restaurant> = operations.geoNear(query, Restaurant.class);

我们使用构建器 API 设置查询，以返回给定 10 英里周围的所有实例。 这里使用的 enum 实际上实现了一个接口，以便其他指标也可以插入到一个距离中。 A 由乘数提供支持，用于将给定度量的距离值转换为本机距离。 此处显示的示例将 10 视为英里。使用内置量度之一（英里和公里）会自动触发在查询上设置的球形标志。 如果要避免这种情况，请将 plain values 传递给 . 有关更多信息，请参阅 NearQuery 的 Javadoc 和 。NearQueryRestaurantPointMetricsMetricdoublemaxDistance(…)Distancespring-doc.cn

geo-near 操作返回封装实例的包装器对象。 换行允许访问所有结果的平均距离。 单个对象包含找到的实体及其与原点的距离。GeoResultsGeoResultGeoResultsGeoResultspring-doc.cn

GeoJSON 支持

MongoDB 支持地理空间数据的 GeoJSON 和简单（传统）坐标对。这些格式都可用于存储和查询数据。请参阅有关 GeoJSON 支持的 MongoDB 手册，了解要求和限制。spring-doc.cn

域类中的 GeoJSON 类型

在域类中使用 GeoJSON 类型非常简单。该包包含诸如 、 等类型。这些类型是现有类型的扩展。以下示例使用 GeoJsonPoint：org.springframework.data.mongodb.core.geoGeoJsonPointGeoJsonPolygonorg.springframework.data.geospring-doc.cn

public class Store {

	String id;

	/**
	 * { "type" : "Point", "coordinates" : [ x, y ] }
	 */
	GeoJsonPoint location;
}

如果 GeoJSON 对象的 the 表示纬度和经度对，则经度在前，然后是纬度。
因此，将 as longitude 和 as latitude 视为 经度。coordinatesGeoJsonPointgetX()getY()spring-doc.cn

存储库查询方法中的 GeoJSON 类型

使用 GeoJSON 类型作为存储库查询参数会在创建查询时强制使用运算符，如下例所示：$geometryspring-doc.cn

public interface StoreRepository extends CrudRepository<Store, String> {

	List<Store> findByLocationWithin(Polygon polygon);  (1)

}

/*
 * {
 *   "location": {
 *     "$geoWithin": {
 *       "$geometry": {
 *         "type": "Polygon",
 *         "coordinates": [
 *           [
 *             [-73.992514,40.758934],
 *             [-73.961138,40.760348],
 *             [-73.991658,40.730006],
 *             [-73.992514,40.758934]
 *           ]
 *         ]
 *       }
 *     }
 *   }
 * }
 */
repo.findByLocationWithin(                              (2)
  new GeoJsonPolygon(
    new Point(-73.992514, 40.758934),
    new Point(-73.961138, 40.760348),
    new Point(-73.991658, 40.730006),
    new Point(-73.992514, 40.758934)));                 (3)

/*
 * {
 *   "location" : {
 *     "$geoWithin" : {
 *        "$polygon" : [ [-73.992514,40.758934] , [-73.961138,40.760348] , [-73.991658,40.730006] ]
 *     }
 *   }
 * }
 */
repo.findByLocationWithin(                              (4)
  new Polygon(
    new Point(-73.992514, 40.758934),
    new Point(-73.961138, 40.760348),
    new Point(-73.991658, 40.730006)));
1 使用 commons 类型的存储库方法定义允许使用 GeoJSON 和旧格式调用它。
2 使用 GeoJSON 类型来使用 operator。$geometry
3 请注意，GeoJSON 多边形需要定义一个封闭的环。
4 使用 legacy format 运算符。$polygon

度量和距离计算

然后，MongoDB 运算符允许使用 GeoJSON 点或旧坐标对。$geoNearspring-doc.cn

NearQuery.near(new Point(-73.99171, 40.738868))
{
  "$geoNear": {
    //...
    "near": [-73.99171, 40.738868]
  }
}
NearQuery.near(new GeoJsonPoint(-73.99171, 40.738868))
{
  "$geoNear": {
    //...
    "near": { "type": "Point", "coordinates": [-73.99171, 40.738868] }
  }
}

尽管语法不同，但无论集合中的目标 Document 是什么格式，服务器都可以接受两者 正在使用。spring-doc.cn

距离计算存在巨大差异。使用传统格式操作 在地球上的弧度（如球体）上，而 GeoJSON 格式使用米。

为避免严重的头痛，请确保将 设置为 所需的度量单位，以确保 distance 才能正确计算。Metricspring-doc.cn

换句话说：spring-doc.cn

假设您有 5 个文档，如下所示：spring-doc.cn

{
    "_id" : ObjectId("5c10f3735d38908db52796a5"),
    "name" : "Penn Station",
    "location" : { "type" : "Point", "coordinates" : [  -73.99408, 40.75057 ] }
}
{
    "_id" : ObjectId("5c10f3735d38908db52796a6"),
    "name" : "10gen Office",
    "location" : { "type" : "Point", "coordinates" : [ -73.99171, 40.738868 ] }
}
{
    "_id" : ObjectId("5c10f3735d38908db52796a9"),
    "name" : "City Bakery ",
    "location" : { "type" : "Point", "coordinates" : [ -73.992491, 40.738673 ] }
}
{
    "_id" : ObjectId("5c10f3735d38908db52796aa"),
    "name" : "Splash Bar",
    "location" : { "type" : "Point", "coordinates" : [ -73.992491, 40.738673 ] }
}
{
    "_id" : ObjectId("5c10f3735d38908db52796ab"),
    "name" : "Momofuku Milk Bar",
    "location" : { "type" : "Point", "coordinates" : [ -73.985839, 40.731698 ] }
}

使用 GeoJSON 的：[-73.99171, 40.738868]spring-doc.cn

例 6.GeoNear 与 GeoJSON
{
    "$geoNear": {
        "maxDistance": 400, (1)
        "num": 10,
        "near": { type: "Point", coordinates: [-73.99171, 40.738868] },
        "spherical":true, (2)
        "key": "location",
        "distanceField": "distance"
    }
}

返回以下 3 个文档：spring-doc.cn

{
    "_id" : ObjectId("5c10f3735d38908db52796a6"),
    "name" : "10gen Office",
    "location" : { "type" : "Point", "coordinates" : [ -73.99171, 40.738868 ] }
    "distance" : 0.0 (3)
}
{
    "_id" : ObjectId("5c10f3735d38908db52796a9"),
    "name" : "City Bakery ",
    "location" : { "type" : "Point", "coordinates" : [ -73.992491, 40.738673 ] }
    "distance" : 69.3582262492474 (3)
}
{
    "_id" : ObjectId("5c10f3735d38908db52796aa"),
    "name" : "Splash Bar",
    "location" : { "type" : "Point", "coordinates" : [ -73.992491, 40.738673 ] }
    "distance" : 69.3582262492474 (3)
}
1 距中心点的最大距离（以米为单位）。
2 GeoJSON 始终在球体上运行。
3 距中心点的距离（以米为单位）。

现在，当使用传统坐标对时，如前所述对 Radians 进行操作。所以我们使用 command。确保 distance multiplier 设置正确。Metrics#KILOMETERS when constructing the `$geoNearMetricspring-doc.cn

例 7.具有传统坐标对的 GeoNear
{
    "$geoNear": {
        "maxDistance": 0.0000627142377, (1)
        "distanceMultiplier": 6378.137, (2)
        "num": 10,
        "near": [-73.99171, 40.738868],
        "spherical":true, (3)
        "key": "location",
        "distanceField": "distance"
    }
}

返回 3 个文档，就像 GeoJSON 变体一样：spring-doc.cn

{
    "_id" : ObjectId("5c10f3735d38908db52796a6"),
    "name" : "10gen Office",
    "location" : { "type" : "Point", "coordinates" : [ -73.99171, 40.738868 ] }
    "distance" : 0.0 (4)
}
{
    "_id" : ObjectId("5c10f3735d38908db52796a9"),
    "name" : "City Bakery ",
    "location" : { "type" : "Point", "coordinates" : [ -73.992491, 40.738673 ] }
    "distance" : 0.0693586286032982 (4)
}
{
    "_id" : ObjectId("5c10f3735d38908db52796aa"),
    "name" : "Splash Bar",
    "location" : { "type" : "Point", "coordinates" : [ -73.992491, 40.738673 ] }
    "distance" : 0.0693586286032982 (4)
}
1 距中心点的最大距离（以弧度为单位）。
2 距离乘数，因此我们得到 Kilometers 作为结果距离。
3 确保我们对 2d_sphere 索引进行操作。
4 距中心点的距离（以公里为单位） - 取其乘以 1000 以匹配 GeoJSON 变体的米。

全文搜索

从 MongoDB 2.6 版本开始，您可以使用 operator 运行全文查询。和中提供了特定于全文查询的方法和操作。执行全文搜索时，请参阅 MongoDB 参考，了解其行为和限制。$textTextQueryTextCriteriaspring-doc.cn

在实际使用全文搜索之前，必须正确设置搜索索引。 有关如何创建索引结构的更多详细信息，请参阅 Text Index 。 以下示例显示如何设置全文搜索：spring-doc.cn

db.foo.createIndex(
{
  title : "text",
  content : "text"
},
{
  weights : {
              title : 3
            }
}
)

可以定义和运行搜索的查询，如下所示：coffee cakespring-doc.cn

例 8.全文查询
Query query = TextQuery
  .queryText(new TextCriteria().matchingAny("coffee", "cake"));

List<Document> page = template.find(query, Document.class);

根据 use 按相关性对结果进行排序 .weightsTextQuery.sortByScorespring-doc.cn

例 9.全文查询 - 按分数排序
Query query = TextQuery
  .queryText(new TextCriteria().matchingAny("coffee", "cake"))
  .sortByScore() (1)
  .includeScore(); (2)

List<Document> page = template.find(query, Document.class);
1 使用 score 属性按触发 的相关性对结果进行排序。.sort({'score': {'$meta': 'textScore'}})
2 用于将计算的相关性包含在结果中 .TextQuery.includeScore()Document

您可以通过在词语前加上 或 using 来排除搜索词，如以下示例所示（请注意，这两行具有相同的效果，因此是多余的）：-notMatchingspring-doc.cn

// search for 'coffee' and not 'cake'
TextQuery.queryText(new TextCriteria().matching("coffee").matching("-cake"));
TextQuery.queryText(new TextCriteria().matching("coffee").notMatching("cake"));

TextCriteria.matching按原样采用提供的术语。 因此，您可以通过将短语放在双引号之间来定义短语（例如，或使用 by以下示例显示了定义短语的两种方法：\"coffee cake\")TextCriteria.phrase.spring-doc.cn

// search for phrase 'coffee cake'
TextQuery.queryText(new TextCriteria().matching("\"coffee cake\""));
TextQuery.queryText(new TextCriteria().phrase("coffee cake"));

您可以使用 上的相应方法为 和 设置标志。 请注意，这两个可选标志已在 MongoDB 3.2 中引入，除非明确设置，否则不会包含在查询中。$caseSensitive$diacriticSensitiveTextCriteriaspring-doc.cn

按示例查询

Query by Example 可用于模板 API 级别的运行示例查询。spring-doc.cn

以下截图显示了如何通过示例进行查询：spring-doc.cn

类型化示例查询
Person probe = new Person();
probe.lastname = "stark";

Example example = Example.of(probe);

Query query = new Query(new Criteria().alike(example));
List<Person> result = template.find(query, Person.class);

默认情况下是严格类型的。这意味着映射的查询具有包含的类型匹配，从而将其限制为探测可分配类型。 例如，当坚持使用默认类型键 （） 时，查询具有 （） 等限制。Example_class_class : { $in : [ com.acme.Person] }spring-doc.cn

通过使用 ，可以绕过默认行为并跳过类型限制。因此，只要字段名称匹配，几乎任何域类型都可以用作创建引用的探测器，如下例所示：UntypedExampleMatcherspring-doc.cn

例 10.无类型化示例查询
class JustAnArbitraryClassWithMatchingFieldName {
  @Field("lastname") String value;
}

JustAnArbitraryClassWithMatchingFieldNames probe = new JustAnArbitraryClassWithMatchingFieldNames();
probe.value = "stark";

Example example = Example.of(probe, UntypedExampleMatcher.matching());

Query query = new Query(new Criteria().alike(example));
List<Person> result = template.find(query, Person.class);

在 Spring Data Mongo 中包含值时，它使用嵌入式文档匹配而不是点表示法属性匹配。 这样做会强制嵌入文档中的所有属性值和属性顺序进行精确文档匹配。nullExampleSpecspring-doc.cn

UntypedExampleMatcher如果要在单个集合中存储不同的实体或选择不编写类型提示，则可能是正确的选择。spring-doc.cn

此外，请记住，使用 需要预先初始化 .为此，请配置为确保读取操作的正确别名解析。@TypeAliasMappingContextinitialEntitySetspring-doc.cn

Spring Data MongoDB 支持不同的匹配选项：spring-doc.cn

StringMatcher选项
匹配 逻辑结果

DEFAULT（区分大小写）spring-doc.cn

{"firstname" : firstname}spring-doc.cn

DEFAULT（不区分大小写）spring-doc.cn

{"firstname" : { $regex: firstname, $options: 'i'}}spring-doc.cn

EXACT（区分大小写）spring-doc.cn

{"firstname" : { $regex: /^firstname$/}}spring-doc.cn

EXACT（不区分大小写）spring-doc.cn

{"firstname" : { $regex: /^firstname$/, $options: 'i'}}spring-doc.cn

STARTING（区分大小写）spring-doc.cn

{"firstname" : { $regex: /^firstname/}}spring-doc.cn

STARTING（不区分大小写）spring-doc.cn

{"firstname" : { $regex: /^firstname/, $options: 'i'}}spring-doc.cn

ENDING（区分大小写）spring-doc.cn

{"firstname" : { $regex: /firstname$/}}spring-doc.cn

ENDING（不区分大小写）spring-doc.cn

{"firstname" : { $regex: /firstname$/, $options: 'i'}}spring-doc.cn

CONTAINING（区分大小写）spring-doc.cn

{"firstname" : { $regex: /.*firstname.*/}}spring-doc.cn

CONTAINING（不区分大小写）spring-doc.cn

{"firstname" : { $regex: /.*firstname.*/, $options: 'i'}}spring-doc.cn

REGEX（区分大小写）spring-doc.cn

{"firstname" : { $regex: /firstname/}}spring-doc.cn

REGEX（不区分大小写）spring-doc.cn

{"firstname" : { $regex: /firstname/, $options: 'i'}}spring-doc.cn

查询集合以匹配 JSON Schema

您可以使用架构查询与 JSON 架构定义的给定结构匹配的文档的任何集合，如下例所示：spring-doc.cn

例 11.查询与$jsonSchema
MongoJsonSchema schema = MongoJsonSchema.builder().required("firstname", "lastname").build();

template.find(query(matchingDocumentStructure(schema)), Person.class);

请参阅 JSON 架构部分，了解有关 Spring Data MongoDB 中的架构支持的更多信息。spring-doc.cn