Ashni Mehta

Product Manager, Developer Experience

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](https://mongodb.prakticum-team.ru/docs/languages/kotlin/kotlin-sync-driver/current/). If you’d rather use Kotlin with coroutines to do asynchronous programming, read our tutorial on [creating an API with Ktor and MongoDB Atlas](https://mongodb.prakticum-team.ru/developer/languages/kotlin/mastering-kotlin-creating-api-ktor-mongodb-atlas/) If you’d rather use Spring with Java, we have [plenty of resources for that too](https://mongodb.prakticum-team.ru/developer/languages/java/).

## Prerequisites

To follow along with this tutorial, you’ll need:

- A MongoDB Atlas account [(sign up free)](https://mongodb.prakticum-team.ru/cloud/atlas/register).
- 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](https://start.spring.io/) 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.][1]

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.

```
dependencies {
 implementation("org.mongodb:mongodb-driver-kotlin-sync:5.1.4")
}
```
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](https://mongodb.prakticum-team.ru/docs/guides/atlas/connection-string/).

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:

```
spring.application.name=spring-kotlin-sync
spring.data.mongodb.uri = mongodb+srv://username:password@host.ejzguta.mongodb.net/?retryWrites=true&w=majority&appName=kotlin-tutorial
spring.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](https://mongodb.prakticum-team.ru/docs/atlas/sample-data/sample-mflix/)), 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.][2]

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:

```
data class Movie(
   @Id
   val id: ObjectId = ObjectId(),
   val title: String = "",
   val fullPlot: String = "",
   val year: Int = 0
)
```

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](https://mongodb.prakticum-team.ru/developer/code-examples/java/rest-apis-java-spring-boot/#spring-and-mongodb-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().

```
import org.bson.Document


@RestController
@RequestMapping("/movies")
class MovieController {


   val mongoClient = MongoClients.create(MONGODB_URI)
   val database = mongoClient.getDatabase("sample_mflix")
   val collection = database.getCollection("movies")


   @GetMapping("/year")
   fun findMovieByYear(@RequestParam year:Int):Document?{
       return collection.find(eq("year", year)).first()
   }
}
```

## 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](http://localhost:8080/movies/title?title=Toy), the result should be the movie that represents “Toy Story” in your collection.

```
@GetMapping("/title")
   fun findMovieByTitle(@RequestParam title:String):Document?{
       return collection.find(eq("title", title)).first()
   }
```

## 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!

```
@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](https://curl.se/) as follows:

```
curl --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:

```
<form action="/movies/add" method="post">



   <label for="title">Title</label>
   <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](https://mongodb.prakticum-team.ru/developer/products/atlas/beyond-basics-enhancing-kotlin-ktor-api-vector-search/). It builds on some of the foundational work covered in our [earlier Ktor article](https://mongodb.prakticum-team.ru/developer/languages/kotlin/mastering-kotlin-creating-api-ktor-mongodb-atlas/) and is a great starting point for building Kotlin applications with MongoDB.





  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltd35232e7e9a4a59e/67054f822273f2519ab4bf56/spring-initializr.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4373b7a29b38d8a6/6705504b443829e49d9a8ad6/document-movies-collection.png

Are you a Java developer looking to get started with Kotlin? In this tutorial, learn how to build a sample REST API using Spring Boot, MongoDB, and the server-side Kotlin driver. 

Getting Started With Server-side Kotlin and MongoDB

Companies of all sizes are continuing to embrace the power of data. With that power, however, comes great responsibility — namely, the responsibility to protect that data and customers, comply with data privacy regulations, and to control and limit access to confidential and regulated data.

Though existing encryption solutions, both in-transit and [at-rest](https://en.wikipedia.org/wiki/Data_at_rest), do cover many of the use cases above, none of them protect sensitive data while it’s in use. However, in-use encryption is often a requirement for high-sensitivity workloads, particularly for customers in financial services, healthcare, and critical infrastructure organizations.

[Queryable Encryption](https://mongodb.prakticum-team.ru/docs/manual/core/queryable-encryption/), a new feature from MongoDB currently in **preview**, offers customers a way to encrypt sensitive data and keep it encrypted throughout its entire lifecycle, whether it’s in memory, logs, in-transit, at-rest, or in backups.

You can now encrypt sensitive data on the client side, store it as fully randomized encrypted data on the server side, and run expressive queries on that encrypted data. Data is never in cleartext in the database, but MongoDB can still process queries and execute operations on the server side.

Find more details on [Queryable Encryption](https://mongodb.prakticum-team.ru/products/queryable-encryption).

## Setting up Queryable Encryption with Java

There are two ways to set up Queryable Encryption. You can either go the automatic encryption route, which allows you to perform encrypted reads and writes without needing to write code specifying how the fields should be encrypted, or you could go the manual route, which means you’ll need to specify the logic for encryption.

To use Queryable Encryption with Java, you’ll need 4.7.0-beta0 (or later) of the [Java driver</u>](https://mongodb.prakticum-team.ru/docs/drivers/java/sync/current/), and version 1.5.0-rc2 (or later) of MongoCrypt. You’ll also need either MongoDB Atlas or MongoDB Enterprise if you want to use automatic encryption. If you don’t have Atlas or Enterprise, no worries! You can get a [free forever cluster](https://mongodb.prakticum-team.ru/developer/products/atlas/free-atlas-cluster/) on Atlas by [registering](https://mongodb.prakticum-team.ru/cloud/atlas/register).

Once you’ve completed those prerequisites, you can set up Queryable Encryption and specify which fields you’d like to encrypt. Check out [the quick start](https://mongodb.prakticum-team.ru/docs/manual/core/queryable-encryption/quick-start/#std-label-qe-quick-start) to learn more.

## Okay, but what does this have to do with James Bond?

Let’s explore the following use case. Assume, for a moment, that you work for a top-secret company and you’re tasked with keeping the identities of your employees shrouded in secrecy.

The below code snippet represents a new employee, James Bond, who works at your company:
```
Document employee = new Document()

       .append("firstName", "James")

       .append("lastName", "Bond")

       .append("employeeId", 1006)

       .append("address", "30 Wellington Sq");
```

The document containing James Bond’s information is added to an “employees” collection that has two encrypted fields, **employeeId** and **address**. Learn more about [encrypted fields](https://mongodb.prakticum-team.ru/docs/manual/core/queryable-encryption/quick-start/#create-your-data-encryption-keys-and-encrypted-collection).

Assuming someone, maybe Auric Goldfinger, wanted to find James Bond’s address but didn’t have access to an encrypted client, they’d only be able to see the following:
```
“firstName” : “James”,

“lastName” : “Bond”,

"employeeId": {"$binary": {"base64": "B5XwlQMzFkOmmW0VTcE1QhoQ/ZYHhyMqItvaD+J9AfsAFf1koD/TaYpJG/sCOugnDlE7b4K+mciP63k+RdxMw4OVhYUhsCkFPrhvMtk0l8bekyYWhd8Leky+mcNTy547dJF7c3WdaIumcKIwGKJ7vN0Zs78pcA+86SKOA3LCnojK4Zdewv4BCwQwsqxgEAWyDaT9oHbXiUJDae7s+EWj+ZnfZWHyYJNR/oZtaShrooj2CnlRPK0RRInV3fGFzKXtiOJfxXznYXJ//D0zO4Bobc7/ur4UpA==", "subType": "06"}},

"address": {"$binary": {"base64": "Biue77PFDUA9mrfVh6jmw6ACi4xP/AO3xvBcQRCp7LPjh0V1zFPU1GntlyWqTFeHfBARaEOuXHRs5iRtD6Ha5v5EjRWZ9nufHgg6JeMczNXmYo7sOaDJ", "subType": "06"}}
```
Of the four fields in my document, the last two remained encrypted (**employeeId** and **address**). Because Auric’s client was unencrypted, he wasn’t able to access James Bond’s address.

However, if Auric were using an encrypted client, he’d be able to see the following:

```
"firstName": "James", 

"lastName": "Bond", 

"employeeId": 1006, 

"address": "30 Wellington Sq"
```

…and be able to track down James Bond.

### Summary

Of course, my example with James Bond is fictional, but I hope that it illustrates one of the many ways that Queryable Encryption can be helpful. For more details, check out our [docs](https://mongodb.prakticum-team.ru/docs/manual/core/queryable-encryption/) or the following helpful links:

* [Supported Operations for Queryable Encryption](https://mongodb.prakticum-team.ru/docs/manual/core/queryable-encryption/reference/supported-operations/)
* [Driver Compatibility Table](https://mongodb.prakticum-team.ru/docs/manual/core/queryable-encryption/reference/compatibility/)
* [Automatic Encryption Shared Library](https://mongodb.prakticum-team.ru/docs/manual/core/queryable-encryption/reference/shared-library/)

If you run into any issues using Queryable Encryption, please let us know in [Community Forums](https://mongodb.prakticum-team.ru/community/forums/) or by filing [tickets](https://jira.mongodb.org/) on the JAVA project. Happy encrypting!

Learn more about Queryable Encryption and how it could keep one of literature's legendary heroes safe.

Ashni Mehta

Content by Ashni Mehta

Getting Started With Server-side Kotlin and MongoDB

How Queryable Encryption Can Keep James Bond Safe