Comece com o driver Scala

Instalar dependências

Antes de desenvolver, verifique se você tem as seguintes dependências instaladas em seu ambiente de desenvolvimento:

• JDK versão 8 ou posterior

• versãosbt 1 ou posterior

Criar uma diretoria de projeto

Execute o seguinte comando em sua shell para criar um diretório chamado scala-quickstart para este projeto:

mkdir scala-quickstart

Selecione a aba correspondente ao seu sistema operacional e execute os seguintes comandos para criar um arquivo build.sbt no diretório scala-quickstart:

cd scala-quickstart
touch build.sbt

cd scala-quickstart
type nul > build.sbt

Configure seu projeto para usar o driver Scala

Navegue até seu arquivo build.sbt e adicione o seguinte código para usar o driver Scala em seu aplicação:

ThisBuild / scalaVersion := "2.13.16"
libraryDependencies += "org.mongodb.scala" %% "mongo-scala-driver" % "5.5.1"

Este código configura seu aplicação para usar a versão 2.13.16 do driver Scala e a versão 5.5.1 do driver Scala.

Crie uma MongoDB deployment gratuita no Atlas

Complete o guia Iniciar com Atlas para configurar uma nova conta Atlas e carregar dados de amostra em uma nova implantação MongoDB de camada gratuita.

Salve suas credenciais

Depois de criar o usuário do banco de dados, salve o nome de usuário e a senha desse usuário em um local seguro para uso em uma próxima etapa.

Encontre sua connection string do MongoDB Atlas

Para recuperar a string de conexão da implantação criada na etapa anterior, faça login na sua conta do Atlas e navegue até a seção Database e clique no botão Connect para a nova implantação.

Em seguida, selecione a opção Drivers no cabeçalho Connect to your application. Selecione "Scala" no menu de seleção Driver e a versão que melhor corresponde à versão instalada no menu de seleção Version.

Copie a connection string

Clique no botão à direita da string de conexão para copiá-la para a área de transferência, como mostrado na seguinte captura de tela:

Atualizar os espaços reservados

Cole esta connection string em um arquivo no editor de texto de sua preferência e substitua os placeholders <db_username> e <db_password> pelo seu nome de usuário e senha de utilizador de banco de dados.

Salve este arquivo em um local seguro para uso na próxima etapa.

Criar um arquivo de aplicação

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

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 arquivo Helpers.scala do código-fonte do driver ao diretório src/main/scala/quickstart:

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 o código da 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 string de conexão 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.

exit