Encontrar documentos

Visão geral

Neste guia, você pode aprender como recuperar documentos de seu banco de dados MongoDB . Você pode encontrar seus documentos usando o seguinte:

Recupere um subconjunto de documentos da sua coleção usando uma operação find
Executar transformações em documentos recuperados de sua coleção usando uma operação agregada
Monitore alterações em tempo real em seu banco de dados de dados usando change streams

Dados de amostra para exemplos

As seções a seguir contém exemplos de como o proprietário de uma loja de tintas administra os pedidos de seus clientes. Para cada pedido, o proprietário mantém o controle da cor e quantidade, que corresponde aos campos color e qty em sua collection de paint_order:

{ "_id": 1, "color": "purple", "qty": 10 }
{ "_id": 2, "color": "green", "qty": 8 }
{ "_id": 3, "color": "purple", "qty": 4 }
{ "_id": 4, "color": "green", "qty": 11 }

Encontrar operação

Use a operação Localizar para recuperar seus documentos do MongoDB. Você pode especificar quais documentos devem ser recuperados, em que ordem devem ser recuperados e quantos devem ser recuperados.

Ligue para o método find() em uma instância de um MongoCollection para filtrar documentos que correspondam à query fornecida. Para obter mais informações sobre como especificar uma query, consulte nosso guia Especificar uma consulta.

Você pode então usar métodos como forEach() ou cursor() para recuperar documentos correspondentes. Para obter mais informações, consulte a documentação da API FindIterable.

Para recuperar um único documento, você pode adicionar o método first() à sua chamada find(). Para escolher um documento específico, você pode usar a operação sort() antes de selecionar o primeiro documento. Você também pode usar o método limit() para otimizar o uso da memória. Para obter mais informações, consulte o manual do servidor para obter mais informações sobre a otimização da memória ao usar a operação de classificação.

Exemplo

O proprietário gostaria de saber quais pedidos contêm mais de três, mas menos de nove latas de tinta de sua coleção paint_order.

Para abordar este cenário, o proprietário encontra encomendas que correspondam aos critérios:

Bson filter = Filters.and(Filters.gt("qty", 3), Filters.lt("qty", 9));
// Retrieves documents that match the filter and prints them as JSON
collection.find(filter).forEach(doc -> System.out.println(doc.toJson()));

Para obter mais informações sobre como criar filtros, consulte nosso guia Construtores de filtros .

O seguinte mostra a saída da query anterior:

{ "_id": 2, "color": "green", "qty": 8 }
{ "_id": 3, "color": "purple", "qty": 4 }

Depois que o proprietário executa esta query, ele encontra dois pedidos que correspondem aos critérios.

Exemplo de localização: arquivo completo

Observação

Exemplo de configuração

Esse exemplo se conecta a uma instância do MongoDB usando um URI de conexão. Para saber mais sobre como se conectar à sua instância do MongoDB, consulte o guia Como criar um MongoClient. Este exemplo também utiliza a coleção do movies no banco de dados do sample_mflix incluído nos conjuntos de dados de amostra do Atlas. Você pode carregá-los em seu banco de dados na camada grátis do MongoDB Atlas seguindo o Guia de Introdução ao Atlas.

Este exemplo é um arquivo completo e autônomo que executa as seguintes ações:

Chama o método find() para recuperar 10 documentos que têm um valor de runtime menor que 15 minutos, aplicando uma projeção e classificação aos resultados
Chama os métodos find() e first() para recuperar o documento com a maior imdb.rating que tenha um valor de runtime menor que 15 minutos, aplicando uma projeção ao resultado

// Retrieves documents that match a query filter by using the Java driver
package org.example;
import static com.mongodb.client.model.Filters.lt;
import org.bson.Document;
import org.bson.conversions.Bson;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Projections;
import com.mongodb.client.model.Sorts;
import static com.mongodb.client.model.Filters.eq;
public class Find {
    public static void main( String[] args ) {
        // Replace the uri string with your MongoDB deployment's connection string
        String uri = "<connection string uri>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
            MongoCollection<Document> collection = database.getCollection("movies");
            // Projects "title" and "imdb" fields, excludes "_id"
            Bson projectionFields = Projections.fields(
                    Projections.include("title", "imdb"),
                    Projections.excludeId());
            // Retrieves documents with a runtime of less than 15 minutes, applying the
            // projection and a sorting in alphabetical order
            FindIterable<Document> docs = collection.find(lt("runtime", 15))
                    .projection(projectionFields)
                    .sort(Sorts.ascending("title"))
                    .limit(10);
            // Prints the titles of the queried documents
            System.out.println("10 movies under 15 minutes: ");
            docs.forEach(doc -> System.out.println("- " + doc.get("title")));
            System.out.println();
            // Retrieves the document with the best imdb rating that is less
            // than 15 minutes long, applying the projection
            Document doc = collection.find(lt("runtime", 15))
                    .projection(projectionFields)
                    .sort(Sorts.ascending("imdb.rating"))
                    .first();
            // Prints title of the queried document
            if (doc == null) {
                System.out.println("No results found.");
            } else {
                System.out.println("The highest rated movie under 15 minutes: " + doc.toJson().get("title"));
            }
        }
    }
}

10 movies under 15 minutes: 10 Minutes, 3x3, 7:35 in the Morning, 8, 9, A Chairy Tale, A Corner in Wheat, A Gentle Spirit, A Is for Autism, A Movie,
The highest rated movie under 15 minutes: {"title": "Andrè and Wally B.", "imdb": {"rating": 5.4, "votes": 3294, "id": 86855}}

Operação agregada

Use a operação agregada para executar os estágios em uma aggregation pipeline. Uma aggregation pipeline é uma transformação em várias etapas que produz um resultado agregado.

Para executar uma operação agregada, chame o método aggregate() em uma instância de um MongoCollection. Este método aceita expressões de agregação para executar em sequência. Para realizar agregações, você pode definir estágios de agregação que especificam como fazer a correspondência entre documentos, renomear campos e agrupar valores. Para obter mais informações, consulte nosso guia de aggregation e a página Operações de expressão de aggregation.

Exemplo

O proprietário gostaria de saber qual cor de tinta é a mais comprada (maior quantidade vendida) de sua paint_order collection.

Para entender a situação, o proprietário cria uma aggregation pipeline que irá:

Corresponder a todos os documentos na collection paint_order
Agrupar pedidos por cores
Resume o campo de quantidade por cor
Ordenar os resultados pela quantidade mais alta para a mais baixa

Bson filter = Filters.empty();
// Prints the collection's "color" values and each value's frequency in descending frequency order
collection.aggregate(Arrays.asList(
    Aggregates.match(filter), 
    Aggregates.group("$color", Accumulators.sum("qty", "$qty")),
    Aggregates.sort(Sorts.descending("qty"))))
    .forEach(doc -> System.out.println(doc.toJson()));

O seguinte mostra a saída da agregação anterior:

{ "_id": "green", "qty": 19 }
{ "_id": "purple", "qty": 14 }

Depois que o proprietário executa a agregação, ele descobre que "verde" é a cor mais comprada.

Para obter mais informações sobre como construir um pipeline de agregação, consulte a página manual do MongoDB Server em Agregação.

Informações adicionais

Documentação da API

Para obter mais informações sobre os métodos e classes usados para recuperar documentos nesta página, consulte a seguinte documentação da API:

Entradas manuais do servidor

Voltar

Especificar uma query

Contagem de documentos