Marco de agregación

Requisitos previos

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

• A test.restaurants Colección rellenada con documentos del restaurants.json archivo en los activos de documentación de GitHub.

• Las siguientes declaraciones 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;

Conectarse a una implementación de MongoDB

Primero, conéctese a una implementación de MongoDB, luego declare y defina las instancias MongoDatabase y MongoCollection.

El siguiente código se conecta a una implementación independiente 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 obtener más información sobre cómo conectarse a implementaciones de MongoDB, consulte el tutorial Conectarse a MongoDB.

Realizar agregación

Para realizar la agregación, pase una lista de etapas de agregación al método MongoCollection.aggregate(). El controlador proporciona la clase auxiliar Aggregates, que contiene los constructores para las etapas de agregación.

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

• Utiliza una etapa $match para filtrar documentos cuyo campo de matriz categories contiene el elemento "Bakery". El ejemplo utiliza Aggregates.match() para generar la etapa $match.

• Utiliza una etapa $group para agrupar los documentos coincidentes por el campo stars, acumulando un recuento de documentos para cada valor distinto de stars. El ejemplo utiliza Aggregates.group() para generar la etapa $group y Accumulators.sum() para generar la expresión del acumulador. Para las expresiones del acumulador que se utilizan en la etapa $group, el controlador proporciona la clase auxiliar 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

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

• $search

• $searchMeta

El controlador Java Reactive Streams proporciona los métodos Aggregates.search() y Aggregates.searchMeta() para realizar consultas de búsqueda de MongoDB.

Para obtener más información sobre las etapas de la canalización de búsqueda de MongoDB, consulte Elegir la etapa de la canalización de agregación 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 obtener más información sobre cómo ensamblar una canalización de agregación y ver ejemplos, consulte Canalización de agregación en el manual de MongoDB Server.

Para obtener más información sobre cómo explicar las operaciones de MongoDB, consulte Explicar los planes de salida y consulta en el manual del servidor MongoDB.