Marco de agregación

Requisitos previos

Debe configurar los siguientes componentes para ejecutar los ejemplos de código en esta guía:

• A test.restaurants colección poblada con documentos del archivo restaurants.json en la documentación activos GitHub.

• Las siguientes instrucciones de importación:

import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoClient;
import com.mongodb.reactivestreams.client.MongoCollection;
import com.mongodb.reactivestreams.client.MongoDatabase;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Accumulators;
import com.mongodb.client.model.Projections;
import com.mongodb.client.model.Filters;
import org.bson.Document;

Conecta a una implementación de MongoDB

En primer lugar, conéctate a una implementación de MongoDB y, a continuación, declara y define las instancias MongoDatabase y MongoCollection.

El código siguiente se conecta a una implementación autónoma de MongoDB que se ejecuta en localhost en el puerto 27017. Luego, define la variable database para referirse a la base de datos test y la variable collection para referirse a la colección restaurants:

MongoClient mongoClient = MongoClients.create();
MongoDatabase database = mongoClient.getDatabase("test");
MongoCollection<Document> collection = database.getCollection("restaurants");

Para aprender más sobre cómo conectar implementaciones de MongoDB, consulta el tutorial Conectar a MongoDB.

Realizar agregación

Para realizar la agregación, pasa una lista de etapas de agregación al método MongoCollection.aggregate(). El driver proporciona la clase asistente Aggregates que contiene desarrolladores para etapas de agregación.

En este ejemplo, la pipeline de agregación realiza las siguientes tareas:

• Utiliza una etapa $match para filtrar los documentos en los que el campo de arreglo categories contiene el elemento "Bakery". El ejemplo utiliza Aggregates.match() para construir la etapa $match.

• Utiliza una etapa $group para agrupar los documentos coincidentes por el campo stars, acumulando un conteo de documentos para cada valor distinto de stars. El ejemplo utiliza Aggregates.group() para compilar la etapa $group y Accumulators.sum() para compilar la expresión acumuladora. Para las expresiones de acumulador que se utilizarán dentro de la etapa $group, el driver proporciona la clase asistente Accumulators.

collection.aggregate(
    Arrays.asList(
        Aggregates.match(Filters.eq("categories", "Bakery")),
        Aggregates.group("$stars", Accumulators.sum("count", 1))
    )
).subscribe(new PrintDocumentSubscriber());

collection.aggregate(
    Arrays.asList(
        Aggregates.project(
            Projections.fields(
                Projections.excludeId(),
                Projections.include("name"),
                Projections.computed(
                    "firstCategory",
                        new Document("$arrayElemAt", Arrays.asList("$categories", 0))
                )
            )
        )
    )
).subscribe(new PrintDocumentSubscriber());

collection.aggregate(
    Arrays.asList(
        Aggregates.match(Filters.eq("categories", "Bakery")),
        Aggregates.group("$stars", Accumulators.sum("count", 1))))
    .explain()
    .subscribe(new PrintDocumentSubscriber());

MongoDB búsqueda

Puedes realizar una consulta de búsqueda de MongoDB creando y ejecutando un pipeline de agregación que contenga una de las siguientes etapas de pipeline:

• $search

• $searchMeta

El controlador de Java Reactive Streams proporciona las funciones Aggregates.search() y Aggregates.searchMeta() métodos para realizar consultas de MongoDB Search.

Para aprender más sobre las etapas del pipeline de agregación de MongoDB Search, consulta Choose the Aggregation Pipeline Stage en la documentación de Atlas.

{
  "mappings": {
    "dynamic": true,
    "fields": {
      "title": {
        "analyzer": "lucene.keyword",
        "type": "string"
      },
      "genres": {
        "normalizer": "lowercase",
        "type": "token"
      }
    }
  }
}

Bson searchStageFilters = Aggregates.search(
        SearchOperator.compound()
                .filter(
                        List.of(
                                SearchOperator.in(fieldPath("genres"), List.of("Comedy")),
                                SearchOperator.phrase(fieldPath("fullplot"), "new york"),
                                SearchOperator.numberRange(fieldPath("year")).gtLt(1950, 2000),
                                SearchOperator.wildcard(fieldPath("title"), "Love *")
                        )));
Bson projection = Aggregates.project(Projections.fields(
        Projections.include("title", "year", "genres")
));
List<Bson> aggregateStages = List.of(searchStageFilters, projection);
Publisher<Document> publisher = movies.aggregate(aggregateStages);
publisher.subscribe(new SubscriberHelpers.PrintDocumentSubscriber());
Mono.from(publisher).block();

{"_id": ..., "genres": ["Comedy", "Romance"], "title": "Love at First Bite", "year": 1979}
{"_id": ..., "genres": ["Comedy", "Drama"], "title": "Love Affair", "year": 1994}

Información Adicional

Para obtener una lista completa de las etapas de agregación, consulta Etapas de agregación en el manual de MongoDB Server.

Para aprender sobre cómo ensamblar una pipeline de agregación y ver ejemplos, consulte Pipeline de agregación en el manual del MongoDB Server.

Para aprender más sobre cómo explicar las operaciones de MongoDB, consulta Salida de explicación y Planes de consultas en el manual de MongoDB Server.