Início rápido

Visão geral

Os exemplos de código neste guia vêm do QuickTour.scala no repositório do Github do código fonte do driver.

Observação

Para obter instruções sobre como instalar o driver Scala, consulte o guia deinstalação .

Observação

Este guia usa os implícitos do Observable como abordados no Quick Start Primary.

Pré-requisitos

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

Servidor MongoDB em execução na porta padrão para o MongoDB (27017)
Dependência do driver instalada em seu projeto

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

import org.mongodb.scala._
import org.mongodb.scala.model.Aggregates._
import org.mongodb.scala.model.Filters._
import org.mongodb.scala.model.Projections._
import org.mongodb.scala.model.Sorts._
import org.mongodb.scala.model.Updates._
import org.mongodb.scala.model._
import scala.collection.JavaConverters._

Faça uma conexão

Use o MongoClient objeto complementar para fazer uma conexão com um MongoDB deployment em execução.

A instância MongoClient representa um pool de conexões com o banco de dados. Você precisa de apenas uma instância de MongoClient , mesmo ao usar threads de operação simultâneas.

Importante

Normalmente, você cria apenas uma instância do MongoClient para uma determinada implantação do MongoDB, como uma implantação independente, um conjunto de réplicas ou um cluster fragmentado, e usa o cliente em seu aplicativo. No entanto, se você criar várias instâncias, tenha em mente o seguinte:

Todos os limites de uso de recursos (por exemplo, conexões máximas) se aplicam a cada instância do MongoClient .
Para descartar uma instância, chame o método MongoClient.close() para limpar recursos.

Conecte-se a uma única MongoDB deployment

O exemplo a seguir mostra várias maneiras de se conectar a uma única implantação do MongoDB.

Você pode se conectar a um único MongoDB deployment das seguintes maneiras:

Instancie um objeto MongoClient sem nenhum parâmetro para se conectar a um servidor MongoDB em execução no localhost na porta 27017:
```
val mongoClient: MongoClient = MongoClient()
```

Especifique explicitamente o hostname para se conectar a uma instância do MongoDB em execução no host especificado na porta 27017:

val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("hostOne")).asJava))
    .build())

Especifique explicitamente o hostname e o port:

val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("hostOne", 27017)).asJava))
    .build())

Especifique o ConnectionString:
```
val mongoClient: MongoClient = MongoClient("mongodb://hostOne:27017")
```

Acessar um banco de dados

Após conectar uma instância do MongoClient a um MongoDB deployment, utilize o método MongoClient.getDatabase() para acessar um banco de dados.

Especifique o nome do banco de dados para o método getDatabase() . Se um banco de dados não existir, o MongoDB criará o banco de dados quando você armazenar os dados pela primeira vez para esse banco de dados.

O exemplo a seguir acessa o banco de dados do mydb :

val database: MongoDatabase = mongoClient.getDatabase("mydb")

MongoDatabase as instâncias são imutáveis.

Acessar uma coleção

Depois de ter uma instância MongoDatabase , use o método getCollection() para acessar uma coleção.

Especifique o nome da coleção para o método getCollection() . Se uma coleção não existir, o MongoDB criará a coleção quando você armazenar os dados pela primeira vez para essa coleção.

Por exemplo, usando a instância do banco de dados de dados, a seguinte declaração acessa a coleção chamada test no banco de banco de dados mydb :

val collection: MongoCollection[Document] = database.getCollection("test")

MongoCollection as instâncias são imutáveis.

Criar um documento

Para criar o documento usando o driver, use o Documento aula.

Por exemplo, considere o seguinte JSON document:

{
   "name" : "MongoDB",
   "type" : "database",
   "count" : 1,
   "info" : { x : 203, y : 102 }
}

Para criar o documento usando o driver, instancie um objeto Document :

val doc: Document = Document("_id" -> 0, "name" -> "MongoDB", "type" -> "database",
                             "count" -> 1, "info" -> Document("x" -> 203, "y" -> 102))

Insira um documento

Depois de ter o objeto MongoCollection , você pode inserir documentos na coleção.

Inserir um documento

Para inserir um documento em uma coleção, use o método insertOne() . Em seguida, use o assistente implícito results() para bloquear até que o observador seja concluído:

collection.insertOne(doc).results()

Aviso

O driver fornece dois tipos de documento , um Document imutável e um Document mutável.

Ao usar um documento imutável, você deve adicionar explicitamente um valor de _id , se precisar saber esse valor de _id no futuro.

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, mas esse _id não será devolvido ao usuário.

Importante

Na API, todos os métodos que retornam uma instância Observable são fluxos frios, o que significa que nada acontece até que eles sejam inscritos.

Por exemplo, o exemplo abaixo não faz nada:

val observable: Observable[InsertOneResult] = collection.insertOne(doc)

A operação acontece somente quando um Observable é inscrito e os dados são solicitados.

observable.subscribe(new Observer[InsertOneResult] {
  override def onSubscribe(subscription: Subscription): Unit = subscription.request(1)
  override def onNext(result: InsertOneResult): Unit = println(s"onNext $result")
  override def onError(e: Throwable): Unit = println("Failed")
  override def onComplete(): Unit = println("Completed")
})

Após o documento ser inserido, o método onNext() é chamado e imprime onNext seguido do resultado. Finalmente, o método onComplete() imprime Completed. Se houver um erro por qualquer motivo, o método onError() imprimirá Failed.

Insira vários documentos

Para inserir vários documentos, você pode usar o método insertMany() da coleção, que recebe uma lista de documentos a serem inseridos.

O exemplo a seguir adiciona vários documentos no seguinte formato:

{ "i" : value }

Crie os documentos em um loop e adicione-os à lista documents :

val documents = (1 to 100) map { i: Int => Document("i" -> i) }

Para inserir estes documentos na coleção, passe a lista de documentos para o método insertMany() :

val insertObservable = collection.insertMany(documents)

O exemplo anterior bloqueia no Observable para terminar. Isso garante que os dados estejam no banco de dados antes da execução da próxima operação.

Contagem de documentos em uma coleção

Para contar o número de documentos em uma collection, você pode usar o método count() da collection. O código a seguir deve imprimir 101, descrevendo os 100 documentos inseridos usando insertMany() e o 1 inserido usando insertOne().

Encadeie as duas operações usando uma compreensão for . O código a seguir insere os documentos, conta o número de documentos e imprime os resultados:

val insertAndCount = for {
  insertResult <- insertObservable
  countResult <- collection.countDocuments()
} yield countResult
println(s"Total # of documents:  ${insertAndCount.headResult()}")

Consulte a coleção

Para fazer query da coleção, você pode usar o método find() da coleção. Você pode chamar o método sem argumentos para consultar todos os documentos em uma coleção ou passar um filtro para consultar documentos que correspondam aos critérios do filtro.

Encontre o primeiro documento em uma coleção

Para retornar o primeiro documento da coleção, use o método find() sem nenhum parâmetro e encadeie o método first() .

Dica

A construção find().first() é útil para queries que devem corresponder apenas a um único documento ou se você estiver interessado apenas no primeiro documento correspondente.

O exemplo a seguir imprime o primeiro documento encontrado na coleção:

collection.find().first().printHeadResult()

O exemplo deve imprimir o seguinte documento:

{
  "_id" : { "$oid" : "551582c558c7b4fbacf16735" },
  "name" : "MongoDB",
  "type" : "database",
  "count" : 1,
  "info" : { "x" : 203, "y" : 102 }
}

Observação

O elemento _id foi adicionado automaticamente pelo MongoDB ao seu documento e seu valor será diferente do mostrado. O MongoDB reserva os nomes de campo que começam com _ e $ para uso interno.

Encontre todos os documentos em uma coleção

Para recuperar todos os documentos na coleção, use o método find() . O método find() retorna uma instância do FindObservable que fornece uma interface fluente para encadear ou controlar operações de localização. O seguinte código recupera e imprime todos os documentos na coleção:

collection.find().printResults()

Especificar um filtro de query

Para fazer query de documentos que correspondam a determinadas condições, passe um objeto de filtro para o método find() . Para facilitar a criação de objetos de filtro, o driver fornece métodos assistente Filters .

Obtenha um único documento que corresponda a um filtro

Para localizar o primeiro documento no qual o campo i tem o valor 71, passe uma definição de filtro eq() para especificar a condição de igualdade:

collection.find(equal("i", 71)).first().printHeadResult()

O exemplo imprime um documento:

{ "_id" : { "$oid" : "..." }, "i" : 71 }

Obter todos os documentos que correspondem a um filtro

O exemplo a seguir retorna e imprime todos os documentos no qual o valor de i é maior que 50:

collection.find(gt("i", 50)).printResults()

Para especificar um filtro para uma faixa, como 50 < i <= 100, você pode usar o auxiliar and() :

collection.find(and(gt("i", 50), lte("i", 100))).printResults()

Atualize documentos

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

Passe os seguintes parâmetros para os métodos:

Filtre objeto para determinar o documento ou documentos a serem atualizados. Para facilitar a criação de objetos de filtro, o driver fornece métodos assistente Filters . Para especificar um filtro vazio e corresponder a todos os documentos na coleção, use um objeto Document vazio.
Atualizar documento que especifica as modificações. Para exibir uma lista dos operadores disponíveis, consulte Operadores de atualização no manual do servidor MongoDB.

Os métodos de atualização retornam um tipo de UpdateResult que fornece informações sobre a operação, incluindo o número de documentos modificados pela atualização.

Atualizar um único documento

Para atualizar um único documento, use o método updateOne() .

O exemplo a seguir atualiza o primeiro documento no qual i está 10 e define o valor de i como 110:

collection.updateOne(equal("i", 10), set("i", 110)).printHeadResult("Update Result: ")

Atualizar vários documentos

Para atualizar todos os documentos correspondentes a um filtro de query, use o método updateMany() .

O exemplo a seguir incrementa o valor de i em 100 em todos os documentos nos quais o valor de i é menor que 100:

collection.updateMany(lt("i", 100), inc("i", 100)).printHeadResult("Update Result: ")

Exclua documentos

Para excluir documentos de uma collection, você pode usar os métodos deleteOne() e deleteMany() da collection.

Passe um objeto de filtro para determinar o documento ou documentos a serem excluídos. Para facilitar a criação de objetos de filtro, o driver fornece métodos assistente Filters . Para especificar um filtro vazio e corresponder a todos os documentos na coleção, use um objeto Document vazio.

Os métodos de exclusão retornam um DeleteResult que fornece informações sobre a operação, incluindo o número de documentos excluídos.

Excluir um único documento que corresponda a um filtro

Para excluir um único documento que corresponda ao filtro, use o método deleteOne() .

O exemplo a seguir exclui o primeiro documento em que o valor de i é igual a 110:

collection.deleteOne(equal("i", 110)).printHeadResult("Delete Result: ")

Excluir todos os documentos que correspondem a um filtro

Para excluir todos os documentos que correspondem ao filtro, use o método deleteMany() .

O exemplo a seguir exclui todos os documentos em que o valor de i é maior ou igual a 100:

collection.deleteMany(gte("i", 100)).printHeadResult("Delete Result: ")

Crie índices

Para criar um índice em um campo ou campos, passe um documento de especificação de índice para o método createIndex() . Um documento de especificação da chave de índice contém os campos a serem indexados e o tipo de índice para cada campo, conforme modelado pelo seguinte documento:

Document(<field1> -> <type1>, <field2>, <type2>, ...)

Para criar um tipo de índice ascendente, especifique 1 para <type>. Para criar um tipo de índice descendente, especifique -1 para <type>.

O exemplo seguinte cria um índice ascendente no campo i :

collection.createIndex(Document("i" -> 1)).printHeadResult("Create Index Result: %s")

Para exibir uma lista de outros tipos de índice, consulte o guia Criar índices .

Informações adicionais

O guia Início Rápido (Exemplos de Classes de Caso) demonstra como usar o driver com classes de caso.

Você pode encontrar tutoriais adicionais na seção Tutoriais .

Voltar

Primário

Início rápido (exemplos de classes de caso)