Começando com Kotlin e MongoDB no lado do servidor
Avalie esse Tutorial
Você é um desenvolvedor Java procurando começar a usar o Kotlin? Talvez você seja um desenvolvedor do Kotlin esperando usar MongoDB. Se este for o caso, não procure mais! Neste tutorial, abordaremos como criar uma REST API de amostra usando o Spring Boot, o MongoDB e o driver Kotlin do lado do servidor.
No MongoDB, estamos ansiosos com o Kotlin. um do lado do Kotlin servidor em 2022 em resposta à crescente Kotlin comunidade , muitos dos Java quais Kotlin (Java JVM você!) .
Este tutorial abordará como criar um aplicação usando o driver de sincronização Kotlin. Se você preferir usar o Kotlin com corrotinas para fazer programação assíncrona, leia nosso tutorial sobre como criar uma API com Ktor e MongoDB Atlas Se preferir usar Spring com Java, também temos muitos recursos para isso.
Para acompanhar este tutorial, você precisará de:
- Java 17+.
- Um IDE (estou usando IntelliJ).
- Maven ou Gradle (você escolhe — estou usando Gradle!).
O Spring Boot permite que você crie aplicativos baseados em Spring autônomo e de nível de produção com facilidade. Vamos usar o Spring Initializr para criar nosso projeto usando as seguintes opções:
- Projeto: Gradle - Kotlin
- Idioma: Kotlin
- Inicialização de primavera: Sinta-se à vontade para deixar isso na seleção padrão
Também adicionaremos uma dependência no Spring Web:
- Spring Web
Embora possamos adicionar uma dependência adicional ao Spring Data MongoDB, vamos renunciar a isso por enquanto. Isso ocorre porque queremos usar o novo driver Kotlin , e o Spring Data MongoDB, embora ofereça suporte ao Kotlin, usa o driver Java abaixo. No entanto, observe que o Spring Data MongoDB é uma ótima opção e facilita muito a introdução ao MongoDB, especialmente se você já usou outros projetos do Spring Data antes.
Descompacte o projeto no IDE de sua escolha (estou usando o IntelliJ) e estamos prontos para mergulhar de cabeça!
Para poder interagir com o MongoDB a partir do seu aplicação Kotlin , precisaremos adicionar uma dependência ao driver de sincronização do Kotlin . Você pode fazer isso acessando seu arquivo
build.gradle.kts.1 dependencies { 2 implementation("org.mongodb:mongodb-driver-kotlin-sync:5.1.4") 3 }
Sinta-se à vontade para alterar a versão da dependência para uma versão mais recente do driver do Kotlin . Estou usando o que foi lançado mais recentemente no momento em que escrevemos este artigo. Atualize o Gradle e podemos prosseguir!
Em seguida, navegue até o arquivo
application.properties do aplicação gerado automaticamente do Spring Boot (você pode encontrar isso em src > main > resources). Você desejará adicionar alguns itens, como o URI do cluster e o nome do seu banco de dados de dados. Se você não sabe qual é o URI do seu cluster, não tenha temor! Você pode encontrá-lo facilmente por meio da interface do usuário do MongoDB Atlas.Se você ainda não tiver um cluster implantado no Atlas, recomendamos pausar este tutorial e seguir este guia para configurar um cluster gratuito para sempre e carregar dados de exemplo. Precisamos de um cluster e dos dados de amostra carregados para poder continuar seguindo este tutorial.
Você pode entrar no MongoDB Atlas e obter sua string de conexão acessando a exibição Clusters e pressionando "Connect " no cluster ao qual deseja se conectar. Depois de escolher "Drivers, " "Kotlin, " e a versão apropriada na lista suspensa, você pode copiar a string de conexão mostrada no modal.
Como exemplo, veja como o meu fica:
1 spring.application.name=spring-kotlin-sync 2 spring.data.mongodb.uri = mongodb+srv://username:password@host.ejzguta.mongodb.net/?retryWrites=true&w=majority&appName=kotlin-tutorial 3 spring.data.mongodb.database=sample_mflix
Para este tutorial, usaremos a collection de filmes em
sample_mflix (parte do conjunto dedados de amostra), de modo que cada documento em nossa collection representará um filme. Você pode ver alguns dos campos no documento acessando a interface do usuário do Atlas e clicando na coleçãomovies. Você deve ver algo assim:
Pudemos criar uma classe
Movie com os seguintes campos - um id, title, o fullPlote o year que o filme foi lançado - como uma representação mínima de um filme individual na coleção. A classeMovie classe então semelhante à seguinte:1 data class Movie( 2 @Id 3 val id: ObjectId = ObjectId(), 4 val title: String = "", 5 val fullPlot: String = "", 6 val year: Int = 0 7 )
No entanto, também podemos interagir diretamente com os documentos individuais. Neste tutorial, renunciaremos à classe
Movie e , em vez disso, usaremos os documentos conforme eles aparecem na coleção.No mundo Spring, as solicitações HTTP são tratadas por um controlador (e anotadas como tal por meio da anotação
@RestController). Crie uma classeMovieController e anote-a com @RestController.Para fins de demonstração, estou criando meu
MongoClient diretamente dentro do meu MovieController, mas observe que o MongoClient normalmente deve ficar fora do controlador e pode ser injetado no controlador com o Spring (o MongoDB Developer Center tem um exemplo dessa configuração). Posso usar meu URI como parâmetro para criar um novo MongoClient, depois localizar o banco de dados de dados por meio do métodogetDatabase() e a collection por meio do métodogetCollection() nesse banco de dados de dados.Se quisermos encontrar um filme feito em um determinado ano de lançamento, precisaremos usar uma solicitação GET, pois solicitaremos dados de um recurso. Podemos usar a anotação do Spring, @GetMapping, para garantir que nossa solicitação HTTP GET seja mapeada para o método apropriado.
Vamos mapear /year para um método getMovieByYear() que pegará um ano e retornará o primeiro filme correspondente em nosso banco de dados de dados. Observe que @RequestParam é como podemos usar o parâmetro da string de query "year " em nosso método. Em termos do método real, estamos usando o método collection.find() método e limitar nosso conjunto de resultados ao primeiro documento correspondente usando .first().
1 import org.bson.Document 2 3 4 @RestController 5 @RequestMapping("/movies") 6 class MovieController { 7 8 9 val mongoClient = MongoClients.create(MONGODB_URI) 10 val database = mongoClient.getDatabase("sample_mflix") 11 val collection = database.getCollection("movies") 12 13 14 @GetMapping("/year") 15 fun findMovieByYear(@RequestParam year:Int):Document?{ 16 return collection.find(eq("year", year)).first() 17 } 18 }
Então, agora que temos os métodos certos em vigor, é hora de executar nosso aplicação! No IDE, execute seu aplicação. Depois que seu aplicação for iniciado com sucesso, navegue até seu navegador e tente encontrar um filme que corresponda a um determinado ano.
Ao navegar para http://localhost:8080/movies/year?year=1999, você obterá um resultado JSON que representa o
Moviecorrespondente em sua coleção.Podemos pegar os mesmos conceitos de encontrar um filme por ano e aplicá-los à filtragem por título. Em seu
MovieController, você pode criar outro método, talvez chamado findMovieByTitle, que receberá um título e retornará o primeiro filme correspondente em sua coleção. Certifique-se de anotar este método com outro @GetMapping, mas desta vez com /title. Para testar suas alterações, tente procurar em sua coleção no Atlas para encontrar um título correspondente e, em seguida, pesquise o mesmo título usando seu método. Se clicarmos em http://localhost:8080/movies/title?title=Toy História, o resultado deverá ser o filme que representa "Toy Story " em sua coleção.
1 @GetMapping("/title") 2 fun findMovieByTitle(@RequestParam title:String):Document?{ 3 return collection.find(eq("title", title)).first() 4 }
Agora que dominamos a leitura do MongoDB, vamos aprender como escrever no MongoDB usando o driver de sincronização do Kotlin . Talvez você queira adicionar um filme que acabou de assistir ou carregar alguns filmes mais recentes que foram criados depois que o conjunto de dados foi criado.
Criaremos outro método, desta vez para adicionar um filme e anotá-lo com
@PostMapping. Semelhante a @GetMapping anteriormente, esta anotação mapeia nossas solicitações POST para o método correto. Criei uma representaçãoMoviemínima em comparação com a Documentcompleta na minha collection, mas como o MongoDB é inerentemente flexível nos dados que pode conter, isso está completamente bem!1 @PostMapping("/add")`` fun addMovie(@RequestParam title:String, @RequestParam year:Int, @RequestParam fullPlot:String){`` collection.insertOne(Document("title", title).append("year", year).append("fullPlot", fullPlot))`` }`\
1 curl --location --request POST 'http://localhost:8080/movies/add?title=KotlinDriver&year=2024&fullPlot=ThisIsAPlot'
Como alternativa, podemos criar um formulário para receber nossas entradas. Vamos fazer o último. Crie um arquivo HTML para adicionar um filme ao seu banco de dados de dados e mapeie a ação do formulário para /movies/add usando um método "post ":
1 <form action="/movies/add" method="post"> 2 3 4 <!--Take in a title--> 5 <label for="title">Title</label> 6 <input type="text" id="title" name="title">
Neste artigo, abordamos a conexão ao MongoDB usando um MongoClient, a leitura e a gravação no MongoDB usando alguns dos métodos presentes no driver Kotlin e o uso de Spring Boot e Spring Data para nos ajudar a começar rapidamente (e mapear nossos métodos para o endpoints certos). Criamos até uma interface de usuário simples baseada em formulário para capturar e registrar entradas!
Para se Go mais em Kotlin e MongoDB, confira nosso tutorial sobre Ktor e Vector Search no Kotlin. Ele se baseia em alguns dos trabalhos fundamentais abordados em nosso artigo anterior do Ktor e é um ótimo ponto de ponto para criar aplicativos Kotlin com o MongoDB.
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.