Framework de aggregation

Nesta página

Pré-requisitos

Conecte-se a um MongoDB deployment
Fazer aggregation
Usar expressões de agregação
Explicar uma agregação

O pipeline de agregação é uma estrutura para agregação de dados, modelada sobre o conceito de pipelines de processamento de dados.

Para saber mais sobre agregação, consulte Aggregation Pipeline no manual do servidor.

Pré-requisitos

Você deve configurar os seguintes componentes para executar os exemplos de código neste guia:

Uma test.restaurants coleção preenchida com documentos do restaurants.json arquivo nos ativos de documentação GitHub.
As seguintes declarações de importação:

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

Este guia usa implementações personalizadas de Subscriber , que são descritas no guia Amostra de implementações personalizadas de assinantes .

Conecte-se a um MongoDB deployment

Primeiro, conecte a um MongoDB deployment e, em seguida, declare e defina as instâncias MongoDatabase e MongoCollection .

O código a seguir se conecta a uma MongoDB deployment standalone em execução em localhost na porta 27017. Em seguida, define a variável database para fazer referência ao banco de dados test e a variável collection para fazer referência à coleção restaurants :

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

Para saber mais sobre como se conectar a sistemas do MongoDB, consulte o tutorial Conectar ao MongoDB .

Fazer aggregation

Para executar a agregação, passe uma lista de estágios de agregação para o método MongoCollection.aggregate() . O driver fornece a classe assistente Aggregates que contém construtores para estágios de agregação .

Neste exemplo, o aggregation pipeline executa as seguintes tarefas:

Usa um estágio $match para filtrar documentos nos quais o campo de array categories contém o elemento "Bakery". O exemplo utiliza Aggregates.match() para construir o estágio $match .

Utiliza um estágio $group para agrupar os documentos correspondentes pelo campo stars , acumulando uma contagem de documentos para cada valor distinto de stars. O exemplo utiliza Aggregates.group() para construir o estágio $group e Accumulators.sum() para construir a expressão acumulador . Para as expressões acumulador para uso no estágio $group , o driver fornece Accumulators classe assistente .

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

Usar expressões de agregação

Para expressões de acumulador do $group , o driver fornece a classe assistente do Accumulators . Para outras expressões de agregação , construa manualmente a expressão utilizando a classe Document .

No exemplo a seguir, o aggregation pipeline usa um estágio $project para retornar somente o campo name e o campo calculado firstCategory cujo valor é o primeiro elemento na array categories . O exemplo utiliza Aggregates.project() e vários métodos de classe Projections para construir o estágio $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());

Explicar uma agregação

Para $explain um pipeline de agregação , chame o 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());

Voltar

Indexes

Segurança