/ /

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

Importante

Esta guía utiliza implementaciones personalizadas de Subscriber, que se describen en la Guíade implementación de suscriptores personalizados de muestra.

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

Usar 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

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 de Java Reactive Streams proporciona las funciones Aggregates.search() y Aggregates.searchMeta() métodos para realizar consultas de MongoDB Search.

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.

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 cadena 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	Comprueba si existe una ruta a un nombre de campo indexado específico 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 cadena 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 title valores 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 auxiliares de búsqueda de MongoDB, consulte la referencia de la interfaz SearchOperator en la documentación de la API de Driver Core.

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 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