Menu Docs
Página inicial do Docs
/ / /
Driver de fluxos reativos do Java
/

Operações de Escrita

Nesta página

  • Pré-requisitos
  • Conecte-se a um MongoDB deployment
  • Insira um documento
  • Insira vários documentos
  • Atualizar documentos existentes
  • Filtros
  • Operadores de atualização
  • Atualizar um único documento
  • Atualizar vários documentos
  • UpdateOptions
  • Substituir um documento existente
  • Filtros
  • Substituir um documento
  • UpdateOptions
  • Exclua documentos
  • Filtros
  • Excluir um único documento
  • Excluir vários documentos
  • Escreva preocupação

Você pode executar operações de gravação para inserir novos documentos, atualizar documentos existentes, substituir um documento existente ou excluir documentos existentes de uma coleção.

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 na documentação de ativos do Github.

  • As seguintes declarações de importação:

import com.mongodb.*;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import static com.mongodb.client.model.Filters.*;
import static com.mongodb.client.model.Updates.*;
import com.mongodb.client.model.UpdateOptions;
import com.mongodb.client.result.*;
import org.bson.Document;
import org.bson.types.ObjectId;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;

Importante

Este guia usa as implementações do Subscriber , que são descritas noPrimário de início rápidodo .

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 .

Para inserir um único documento na coleção, você pode usar o método insertOne() da coleção:

Document document = new Document("name", "Café Con Leche")
.append("contact", new Document("phone", "228-555-0149")
.append("email", "cafeconleche@example.com")
.append("location",Arrays.asList(-73.92502, 40.8279556)))
.append("stars", 3)
.append("categories", Arrays.asList("Bakery", "Coffee", "Pastries"));
collection.insertOne(document).subscribe(new ObservableSubscriber<Void>());

Observação

Se nenhum campo id de nível superior for especificado no documento, o MongoDB gerará automaticamente um valor e adicionará esse campo ao documento inserido.

Para inserir vários documentos, você pode usar o método insertMany() da collection, que recebe uma lista de documentos a serem inseridos como parâmetro.

O exemplo a seguir insere dois documentos na coleção:

Document doc1 = new Document("name", "Amarcord Pizzeria")
.append("contact", new Document("phone", "264-555-0193")
.append("email", "amarcord.pizzeria@example.net")
.append("location",Arrays.asList(-73.88502, 40.749556)))
.append("stars", 2)
.append("categories", Arrays.asList("Pizzeria", "Italian", "Pasta"));
Document doc2 = new Document("name", "Blue Coffee Bar")
.append("contact", new Document("phone", "604-555-0102")
.append("email", "bluecoffeebar@example.com")
.append("location",Arrays.asList(-73.97902, 40.8479556)))
.append("stars", 5)
.append("categories", Arrays.asList("Coffee", "Pastries"));
List<Document> documents = new ArrayList<Document>();
documents.add(doc1);
documents.add(doc2);
collection.insertMany(documents).subscribe(new ObservableSubscriber<Void>());;

Observação

Se nenhum campo id de nível superior for especificado no documento, o MongoDB gerará automaticamente um valor e adicionará esse campo ao documento inserido.

Para atualizar documentos existentes em uma collection, você pode usar os métodos updateOne() ou updateMany() da collection.

Você pode passar um documento de filtro para os métodos para especificar quais documentos atualizar. A especificação do documento de filtro é a mesma que para operações de leitura. Para facilitar a criação de objetos de filtro, o driver fornece a classe auxiliar Filters .

Para especificar um filtro vazio e corresponder a todos os documentos em uma coleção, use um objeto Document vazio como filtro.

Para alterar um campo em um documento, o MongoDB fornece operadores de atualização. Para especificar a modificação a ser executada usando os operadores de atualização, crie um documento de atualização. Para saber mais sobre operadores de atualização, consulte Operadores de atualização no manual do servidor MongoDB.

Para facilitar a criação de documentos de atualização, o driver fornece a classe assistente Updates .

Importante

O campo id é imutável, então você não pode alterar o valor do campo id em um documento.

O método updateOne() atualiza um único documento, mesmo que a condição do filtro corresponda a vários documentos na coleção.

A operação a seguir na collection restaurants atualiza um documento no qual o valor do campo id é ObjectId("57506d62f57802807471dd41"):

collection.updateOne(
eq("_id", new ObjectId("57506d62f57802807471dd41")),
combine(set("stars", 1), set("contact.phone", "228-555-9999"), currentDate("lastModified"))
).subscribe(new ObservableSubscriber<UpdateResult>());

Especificamente, a operação utiliza os seguintes métodos:

  • Updates.set() para definir o valor do campo stars como 1 e do campo contact.phone como "228-555-9999"

  • Updates.currentDate() para modificar o campo lastModified para a data atual. Se o campo lastModified não existir, o operador adicionará o campo ao documento.

O método updateMany() atualiza todos os documentos que correspondem à condição do filtro.

A seguinte operação na collection restaurants atualiza todos os documentos nos quais o valor do campo stars é 2:

collection.updateMany(
eq("stars", 2),
combine(set("stars", 0), currentDate("lastModified"))
).subscribe(new ObservableSubscriber<UpdateResult>());

Especificamente, a operação utiliza os seguintes métodos:

  • Updates.set() para definir o valor do campo stars como 0

  • Updates.currentDate() para definir o campo lastModified para a data atual. Se o campo lastModified não existir, o operador adicionará o campo ao documento.

Ao usar os métodos updateOne() e updateMany() , você pode incluir um documento UpdateOptions para especificar a opção upsert ou a opção bypassDocumentationValidation :

collection.updateOne(
eq("_id", 1),
combine(set("name", "Fresh Breads and Tulips"), currentDate("lastModified")),
new UpdateOptions().upsert(true).bypassDocumentValidation(true)
).subscribe(new ObservableSubscriber<UpdateResult>());

Para substituir um documento existente em uma coleção, você pode usar o método replaceOne() da coleção.

Importante

O campo id é imutável, então você não pode substituir o campo id em um documento.

Você pode passar um documento de filtro para o método replaceOne() para especificar qual documento substituir. A especificação do documento de filtro é a mesma que para operações de leitura. Para facilitar a criação de objetos de filtro, o driver fornece a classe auxiliar Filters .

Para especificar um filtro vazio e corresponder a todos os documentos em uma coleção, use um objeto Document vazio como filtro.

O método replaceOne() substitui, no máximo, um único documento, mesmo que a condição do filtro corresponda a vários documentos na coleção.

Para substituir um documento, passe um novo documento para o método replaceOne() .

Importante

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo id , pois o campo id é imutável. No entanto, se você incluir o campo id , não poderá especificar um valor diferente para o campo id .

A seguinte operação na coleção restaurants substitui o documento no qual o valor do campo id é ObjectId("57506d62f57802807471dd41"):

collection.replaceOne(
eq("_id", new ObjectId("57506d62f57802807471dd41")),
new Document("name", "Green Salads Buffet")
.append("contact", "TBD")
.append("categories", Arrays.asList("Salads", "Health Foods", "Buffet"))
).subscribe(new ObservableSubscriber<UpdateResult>());

Ao usar o método replaceOne() , você pode incluir um documento UpdateOptions para especificar a opção upsert ou a opção bypassDocumentationValidation :

collection.replaceOne(
eq("name", "Orange Patisserie and Gelateria"),
new Document("stars", 5)
.append("contact", "TBD")
.append("categories", Arrays.asList("Cafe", "Pastries", "Ice Cream")),
new UpdateOptions().upsert(true).bypassDocumentValidation(true)
).subscribe(new ObservableSubscriber<UpdateResult>());

Para excluir documentos em uma coleção, você pode usar os métodos deleteOne() e deleteMany() .

Você pode passar um documento de filtro para os métodos para especificar quais documentos excluir. A especificação do documento de filtro é a mesma que para operações de leitura. Para facilitar a criação de objetos de filtro, o driver fornece a classe auxiliar Filters .

Para especificar um filtro vazio e corresponder a todos os documentos em uma coleção, use um objeto Document vazio como filtro.

O método deleteOne() exclui no máximo um único documento, mesmo que a condição do filtro corresponda a vários documentos na coleção.

A seguinte operação na collection restaurants exclui um documento no qual o valor do campo _id é ObjectId("57506d62f57802807471dd41"):

collection
.deleteOne(eq("_id", new ObjectId("57506d62f57802807471dd41")))
.subscribe(new ObservableSubscriber<DeleteResult>());

O método deleteMany() exclui todos os documentos que correspondem à condição do filtro.

A operação a seguir na collection restaurants exclui todos os documentos nos quais o valor do campo stars é 4:

collection
.deleteMany(eq("stars", 4))
.subscribe(new ObservableSubscriber<DeleteResult>());

Preocupação de gravação descreve o nível de confirmação solicitado do MongoDB para operações de gravação.

É possível configurar uma write concern nos seguintes níveis:

  • Em um MongoClient das seguintes maneiras:

    • Ao criar uma instância do MongoClientSettings :

      MongoClient mongoClient = MongoClients.create(MongoClientSettings.builder()
      .applyConnectionString(new ConnectionString("mongodb://host1,host2"))
      .writeConcern(WriteConcern.MAJORITY)
      .build());
    • Ao criar uma instância do ConnectionString :

      MongoClient mongoClient = MongoClients.create("mongodb://host1:27017,host2:27017/?w=majority");
  • Em um MongoDatabase usando o método withWriteConcern() :

    MongoDatabase database = mongoClient.getDatabase("test").withWriteConcern(WriteConcern.MAJORITY);
  • Em um MongoCollection usando o método withWriteConcern() :

    MongoCollection<Document> collection = database
    .getCollection("restaurants")
    .withWriteConcern(WriteConcern.MAJORITY);

MongoDatabase e MongoCollection instâncias são imutáveis. Chamar withWriteConcern() em uma instância MongoDatabase ou MongoCollection existente retorna uma nova instância e não afeta a instância na qual o método é chamado.

No exemplo a seguir, a instância collWithWriteConcern tem a write concern de majority , enquanto a read preference do collection não é afetada:

MongoCollection<Document> collWithWriteConcern = collection
.withWriteConcern(WriteConcern.MAJORITY);

Você pode construir instâncias do MongoClientSettings, MongoDatabase ou MongoCollection para incluir combinações de read concerns, read preferences e write concerns.

Por exemplo, o seguinte código define todos os três no nível da collection:

Collection = database.getCollection("restaurants")
.withReadPreference(ReadPreference.primary())
.withReadConcern(ReadConcern.MAJORITY)
.withWriteConcern(WriteConcern.MAJORITY);

Voltar

Criptografia do lado do cliente