Explore Developer Center's New Chatbot! MongoDB AI Chatbot can be accessed at the top of your navigation to answer all your MongoDB questions.

Join us at AWS re:Invent 2024! Learn how to use MongoDB for AI use cases.
MongoDB Developer
MongoDB
plus
Sign in to follow topics
MongoDB Developer Centerchevron-right
Developer Topicschevron-right
Productschevron-right
MongoDBchevron-right

Getting Started With Server-side Kotlin and MongoDB

AM
Ashni Mehta6 min read • Published Oct 08, 2024 • Updated Oct 08, 2024
KotlinMongoDB
Facebook Icontwitter iconlinkedin icon
Rate this tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Are you a Java developer looking to get started with Kotlin? Maybe you’re a Kotlin developer hoping to use MongoDB. If this is the case, look no further! In this tutorial, we’ll cover how to build a sample REST API using Spring Boot, MongoDB, and the server-side Kotlin driver. 
At MongoDB, we’re excited about Kotlin. We released a server-side Kotlin driver in 2022, in response to the growing Kotlin community, many of whom (maybe you!) are former Java developers turning to Kotlin for its interoperability with Java, and its conciseness compared to earlier JVM languages. 
This tutorial will cover how to build an application using the Kotlin sync driver. If you’d rather use Kotlin with coroutines to do asynchronous programming, read our tutorial on creating an API with Ktor and MongoDB Atlas If you’d rather use Spring with Java, we have plenty of resources for that too.

Prerequisites

To follow along with this tutorial, you’ll need:
  • A MongoDB Atlas account (sign up free).
  • Java 17+.
  • An IDE (I’m using IntelliJ).
  • Maven or Gradle (you choose—I’m using Gradle!).

Getting started with Spring Boot

Spring Boot allows you to create standalone, production-grade, Spring-based applications easily. Let’s use Spring Initializr to create our project using the following options:
  1. Project: Gradle - Kotlin
  2. Language: Kotlin
  3. Spring Boot: Feel free to leave this on the default selection
We’ll also add in a dependency on Spring Web:
  • Spring Web
While we could add an additional dependency on Spring Data MongoDB, we’ll forgo that for now. This is because we want to use the new Kotlin driver, and Spring Data MongoDB, though it does support Kotlin, uses the Java driver underneath. However, do note that Spring Data MongoDB is a fine choice and makes it very easy to get started with MongoDB, especially if you’ve used other Spring Data projects before.
A screenshot of Spring Initializr. The project is set to "Gradle - Kotlin", the Language to "Kotlin", the Spring Boot version to the default, and there is a dependency on Spring Web. Additionally, Java 21 is selected.
Unzip the project in your IDE of choice (I’m using IntelliJ), and we’re ready to dive in!

Adding the Kotlin sync driver

To be able to interact with MongoDB from your Kotlin application, we’ll need to add a dependency on the Kotlin sync driver. You can do this by going to your build.gradle.kts file.
1dependencies {
2 implementation("org.mongodb:mongodb-driver-kotlin-sync:5.1.4")
3}
Feel free to change the dependency version to a more recent version of the Kotlin driver. I’m using what’s been most recently released as of the time of writing this article. Refresh Gradle, and we can proceed!

Adding in your connection string

Next, navigate to the application.properties file of your Spring Boot auto-generated application (you can find this in src > main > resources). You’ll want to add in a few things, namely the cluster URI and your database name. If you don’t know what your cluster URI is, have no fear! You can find it easily via the MongoDB Atlas UI.
If you don’t already have a cluster deployed in Atlas, I’d recommend pausing this tutorial and following this guide to set up a free-forever cluster and load in sample data. We’ll need both a cluster and the sample data loaded in to be able to continue following this tutorial.
You can sign into MongoDB Atlas and obtain your connection string by going to your Clusters view, and then pressing “Connect” on the cluster you want to connect to. Once you choose “Drivers,” “Kotlin,” and the appropriate version in the drop-down list, you can copy the connection string that’s shown in the modal.
As an example, here’s what mine looks like:
1spring.application.name=spring-kotlin-sync
2spring.data.mongodb.uri = mongodb+srv://username:password@host.ejzguta.mongodb.net/?retryWrites=true&w=majority&appName=kotlin-tutorial
3spring.data.mongodb.database=sample_mflix

Interacting with documents

For this tutorial, we’ll be using the movies collection in sample_mflix (part of the sample dataset), so each document in our collection will represent a movie. You can see some of the fields in the document by going to the Atlas UI and clicking on the movies collection. You should see something like this:
A screenshot of a selected Document in the movies collection of sample_mflix, from the Atlas UI.
We could create a Movie class with the following fields—an id, title, the fullPlot, and the year the movie was released—as a minimal representation of an individual movie in the collection. The Movie class would then resemble the following:
1data class Movie(
2 @Id
3 val id: ObjectId = ObjectId(),
4 val title: String = "",
5 val fullPlot: String = "",
6 val year: Int = 0
7)
However, we can also interact with the individual documents directly. In this tutorial, we’ll forego the Movie class and will instead use the documents as they appear in the collection.

Finding a movie by release year

In the Spring world, HTTP requests are handled by a controller (and annotated as such through the @RestController annotation). Create a MovieController class and annotate it with @RestController.
For demonstration purposes,  I’m creating my MongoClient directly within my MovieController, but note that MongoClient should typically live outside of the Controller and can be injected into the Controller with Spring (the MongoDB Developer Center has an example of this configuration). I can use my URI as the parameter for creating a new MongoClient, then find the database through the getDatabase() method, and the collection through the getCollection() method on that database.
If we want to find a movie made in a particular release year, we’ll need to use a GET request, as we’ll be requesting data from a resource. We can use the Spring annotation, @GetMapping, to ensure that our HTTP GET request is mapped to the appropriate method.
Let’s map /year to a getMovieByYear() method that will take in a year and return the first matching movie in our database. Note that @RequestParam is how we are able to use the query string parameter “year” in our method. In terms of the actual method, we’re using the collection.find() method and limiting our result set to the first matching document using .first().
1import org.bson.Document
2
3
4@RestController
5@RequestMapping("/movies")
6class 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}

Putting it all together

So, now that we have the right methods in place, it’s time to run our application! From your IDE, run your application. Once your application has started successfully, navigate to your browser and try to find a movie that matches a particular year. 
By navigating to http://localhost:8080/movies/year?year=1999, you’ll get a JSON result that represents the matching Movie in your collection.

Finding a movie by title

We can take the same concepts of finding a movie by year and apply them to filtering by title. In your MovieController, you can create another method, perhaps called findMovieByTitle, that will take in a title and return the first matching movie in your collection. Make sure you annotate this method with another @GetMapping, but this time with /title. To test out your changes, try looking through your collection in Atlas to find a matching title, then search for that same title using your method. 
If we click through to http://localhost:8080/movies/title?title=Toy Story, the result should be the movie that represents “Toy Story” in your collection.
1@GetMapping("/title")
2 fun findMovieByTitle(@RequestParam title:String):Document?{
3 return collection.find(eq("title", title)).first()
4 }

Writing to MongoDB

Now that we’ve mastered reading from MongoDB, let’s learn how to write to MongoDB using the Kotlin sync driver. Maybe you want to add a movie that you’ve just watched or load in some newer movies that were created after the dataset was created.
We’ll create another method, this time to add a movie, and annotate it with @PostMapping. Similar to @GetMapping earlier, this annotation maps our POST requests to the right method. I’ve created a fairly minimal Movie representation as compared to the full Document in my collection, but because MongoDB is inherently flexible in the data it can hold, this is completely fine!
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))``   }`\
Because this will be a POST request, we can use cURL as follows:
1curl --location --request POST 'http://localhost:8080/movies/add?title=KotlinDriver&year=2024&fullPlot=ThisIsAPlot'
Alternatively, we can create a form to take in our input. Let’s do the latter. Create an HTML file to add a movie to your database, and map the form’s action to /movies/add using a “post” method:
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">

Conclusion

In this article, we covered connecting to MongoDB using a MongoClient, reading and writing to MongoDB using some of the methods present in the Kotlin driver, and using Spring Boot and Spring Data to help us get started quickly (and to map our methods to the right endpoints). We even created a simple form-based UI to capture and record input!
To go deeper with Kotlin and MongoDB, check out our tutorial on Ktor and Vector Search in Kotlin. It builds on some of the foundational work covered in our earlier Ktor article and is a great starting point for building Kotlin applications with MongoDB.
Top Comments in Forums
There are no comments on this article yet.
Start the Conversation

Facebook Icontwitter iconlinkedin icon
Rate this tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Related
Article

Using MongoDB Change Streams in Java


Aug 28, 2024 | 6 min read
Tutorial

How to Use Custom Aggregation Expressions in MongoDB 4.4


Sep 23, 2022 | 11 min read
Tutorial

Schema Performance Evaluation in MongoDB Using PerformanceBench


Apr 02, 2024 | 20 min read
News & Announcements

Improved Error Messages for Schema Validation in MongoDB 5.0


Jun 14, 2023 | 10 min read
Table of Contents