Conecte-se ao MongoDB

Depois de recuperar a string de conexão para sua implantação do MongoDB Atlas , você pode se conectar à implantação do seu aplicação Scala e consultar os conjuntos de dados de amostra do Atlas .

Criar um arquivo de aplicação

Navegue até o scala-quickstart diretório que você criou na etapa Download e instalação deste guia e crie os src/main/scala/quickstart diretórios aninhados.

Selecione a guia correspondente ao seu sistema operacional e execute os seguintes comandos para criar um arquivo Main.scala no subdiretório quickstart:

cd src/main/scala/quickstart
touch Main.scala

cd src/main/scala/quickstart
type nul > Main.scala

Adicionar métodos assistente

Adicione o seguinte Helpers.scala arquivo do código-fonte do driver ao src/main/scala/quickstart diretório:

package quickstart
import java.util.concurrent.TimeUnit
import scala.concurrent.Await
import scala.concurrent.duration.Duration
import org.mongodb.scala._
object Helpers {
  implicit class DocumentObservable[C](val observable: Observable[Document]) extends ImplicitObservable[Document] {
    override val converter: (Document) => String = (doc) => doc.toJson
  }
  implicit class GenericObservable[C](val observable: Observable[C]) extends ImplicitObservable[C] {
    override val converter: (C) => String = (doc) => Option(doc).map(_.toString).getOrElse("")
  }
  trait ImplicitObservable[C] {
    val observable: Observable[C]
    val converter: (C) => String
    def results(): Seq[C] = Await.result(observable.toFuture(), Duration(10, TimeUnit.SECONDS))
    def headResult() = Await.result(observable.head(), Duration(10, TimeUnit.SECONDS))
    def printResults(initial: String = ""): Unit = {
      if (initial.length > 0) print(initial)
      results().foreach(res => println(converter(res)))
    }
    def printHeadResult(initial: String = ""): Unit = println(s"${initial}${converter(headResult())}")
  }
}

Este arquivo permite acessar métodos assistente para imprimir resultados de consulta.

Adicionar seu código de aplicação

Copie e cole o seguinte código no arquivo Main.scala , que consulta a coleção movies no banco de banco de dados sample_mflix :

package quickstart
import org.mongodb.scala._
import org.mongodb.scala.model.Filters._
import Helpers._
object Main {
  def main(args: Array[String]): Unit = {
    val mongoClient = MongoClient("<connection string>")
    val database: MongoDatabase = 
       mongoClient.getDatabase("sample_mflix")
    val collection: MongoCollection[Document] = 
       database.getCollection("movies")
    val filter = equal("title", "The Shawshank Redemption")
    collection.find(filter).printResults()
    mongoClient.close()
    
  }
}

Atribuir a connection string

Substitua o placeholder <connection string> pela connection string que você copiou da etapa Criar uma connection string deste guia.

Execute seu aplicação Scala

No diretório raiz do projeto , execute os seguintes comandos para iniciar o shell sbt e executar seu aplicação:

sbt
run

A saída da linha de comando contém detalhes sobre o documento de filme recuperado:

{"_id": {"$oid": "..."}, ... , "genres": ["Crime", "Drama"], "rated": "R",
"metacritic": 80, "title": "The Shawshank Redemption", ... }

Se você encontrar um erro ou não vir nenhuma saída, verifique se especificou a string de conexão adequada no arquivo Main.scala e se carregou os dados de amostra.

Dica

Você pode sair do sbt shell executando o seguinte comando:

exit

Depois de concluir essas etapas, você tem um aplicação Scala que se conecta à implementação do MongoDB , executa uma query nos dados de amostra e retorna um documento correspondente.

Observação

Caso ocorra algum problema nesta etapa, peça ajuda nos Fóruns da MongoDB Community ou envie feedback pela aba Rate this page no lado direito ou no canto inferior direito desta página.

Voltar

Criar uma connection string

Próximos passos