/ /

Driver de Java Reactive Streams

Docs Home

Librerías de clientes

Java

Driver de Java Reactive Streams

Docs Home

Librerías de clientes

Java

Driver de Java Reactive Streams

Marco de agregación

El pipeline de agregación es un marco para la agregación de datos, modelado en el concepto de pipelines de procesamiento de datos.

Para aprender más sobre la agregación, consulte Pipeline de agregación en el manual del servidor.

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;

Importante

Esta guía utiliza implementaciones personalizadas de Subscriber, que se describen en la Guía Muestra de implementaciones personalizadas de suscriptor.

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());

Utiliza expresiones de agregación

Para las expresiones de acumulador $group, el driver proporciona la clase asistente Accumulators. Para otras expresiones de agregación, se puede compilar manualmente la expresión utilizando la clase Document.

En el siguiente ejemplo, el pipeline de agregación utiliza una etapa $project para devolver solo el campo name y el campo calculado firstCategory, cuyo valor es el primer elemento en el arreglo categories. El ejemplo usa Aggregates.project() y varios métodos de clase Projections para compilar la etapa $project:

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());

Explica una agregación

Para $explain una pipeline de agregación, llamar el método AggregatePublisher.explain():

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.

Crear etapas de búsqueda en pipeline

Puedes crear los criterios de búsqueda en la etapa de tu pipeline de MongoDB Search (Búsqueda de MongoDB) utilizando los operadores de búsqueda.

El driver de Java Reactive Streams proporciona métodos asistente para los siguientes operadores:

Operador	Descripción
Autocompletar	Realiza una búsqueda de una palabra o frase que contenga una secuencia de caracteres de una string de entrada incompleta.
compuesto	Combina dos o más operadores en una única query.
equals	Verifica si un campo coincide con un valor que especificaste. Se asigna a los métodos `equals()` y `equalsNull()`.
exists	Verifica si existe una ruta hacia un nombre de campo indexado especificado en un documento.
in	Realiza una búsqueda de un arreglo de valores de número, fecha, booleano, objectId, uuid o string BSON en la ruta determinada y retorna documentos donde el valor del campo coincide con cualquier valor en el arreglo especificado.
moreLikeThis	Devuelve documentos similares a los documentos de entrada.
near	Permite consultar y puntuar valores numéricos, fechas y valores de puntos GeoJSON.
frase	Realiza una búsqueda de documentos que contienen una secuencia ordenada de términos utilizando el analizador especificado en la configuración del índice.
queryString	Brinda soporte a las queries de una combinación de campos indexados y valores.
rango	Permite la consulta y la calificación de valores numéricos, de fecha y de string. Se asigna a los métodos `numberRange()` y `dateRange()`.
regex	Interpreta el campo de query como una expresión regular.
text	Realiza una búsqueda de texto completo utilizando el analizador que se especifique en la configuración del índice.
Comodín	Permite consultas que utilizan caracteres especiales en la string de búsqueda que pueden coincidir con cualquier carácter.

Ejemplo de etapa de búsqueda en el pipeline

Antes de que puedas ejecutar este ejemplo, debes crear un índice de búsqueda de MongoDB en la colección movies que tenga la siguiente definición:

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

Para obtener más información sobre cómo crear índices de Búsqueda de MongoDB, consulte la sección Gestión del índice de búsqueda de MongoDB de la guía de índices.

El siguiente código crea un escenario $search que tiene las siguientes especificaciones:

Comprueba que el arreglo genres incluya "Comedy"
Busca en el campo fullplot la frase "new york"
Coincide con year valores entre 1950 y 2000, ambos inclusive
Busca valores de title que comiencen con el término "Love"

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}

Para obtener más información sobre los métodos asistente de MongoDB Search, consulta la referencia de la interfaz SearchOperator en la documentación de Core API del driver.

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.

Documentación de la API

Para obtener más información sobre las clases y métodos mencionados en esta guía, consulta la siguiente documentación API:

Volver

Indexes

Autenticación