Ashni Mehta

Product Manager, Developer Experience

Ever since Java was introduced in 1995, millions of developers have used it to build applications across a variety of industries and problem spaces. Other languages have emerged, too, building on top of the solid foundation that Java has provided over the past 30 years. Apache Groovy, first released in 2007, is a Java syntax-compatible language for the JVM. Scala, intended to address some of the criticisms of Java, also can run on the JVM and is interoperable with Java. 

Kotlin is the newest popular contender in the world of JVM languages. Released in 2011, it has been gaining steady popularity—first in the Android application development world, and now, in the server-side JVM space. Kotlin is interoperable with Java and mainly targets the JVM. However, it is more concise than Java, with null safety and coroutine support.

In this article, we’ll cover how to use some MongoDB features, and compare and contrast how they look and feel in Kotlin and Java.

## Change streams
Suppose you want to track changes to your data in MongoDB. These can be changes to a collection, database, or deployment. You can monitor real-time changes through change streams, a feature in the MongoDB server. This feature allows applications to watch for changes to data and react to them. 

Change streams have been available for several MongoDB server releases, but in more recent releases, the ability to split a large change stream event (an event that exceeds 16MB) was introduced, with $changeStreamSplitLargeEvent. The ability to contain or omit a pre-image (a document that represents the version of the document before the operation) and a post-image (the same, but for after the operation) was also introduced, with ChangeStreamPreAndPostImagesOptions.

In Java, you can open a change stream on a collection and print events as they occur, as follows:

````java
ChangeStreamIterable<Document> changeStream = collection.watch();
changeStream.forEach(event -> System.out.println("Received a change: " + event));
````
The watch() method is how you can open a change stream on a MongoCollection, MongoDatabase, or MongoClient. Note that depending on the object that you call watch() on, the scope of events that the change stream listens for will change (ex: if you call watch() on a MongoDatabase, all collections in that database are monitored).

The method is similar in Kotlin, but note that in the Kotlin Coroutine driver, you can leverage the power of flows, as the watch() method will return an instance of [ChangeStreamFlow][1], which is a Flow implementation for change streams:

````java
val changeStream = collection.watch()
changeStream.collect {
    println("Received a change: $it")
}
````

## Builders
In MongoDB, queries can be constructed in a few ways. Before I dive into specifics, let’s start with an example. Let us assume that we want to find all patients in a `patients` collection who match the following eligibility criteria for a new healthcare trial:

 * Patients whose gender is “male”
 * Patients who are younger than “30”

We want to return only their addresses so that we can send them a notice in the mail about this new trial.

If we were to use the [MongoDB shell][2], our query would look like this:

````java
collection.find({ "gender": "male", "age" : { "$lt": 30 }}, { "_id": 0, "address": 1 })
````
The results of the above query would be a set of documents containing only the address field (the _id field has been suppressed by being [projected out][3]). If we were to use the Java driver, without builders, our query would resemble the following:

````java
Bson filter = new Document().append("gender", "male").append("age", new Document().append("$lt", 30));
Bson projection = new Document().append("_id", 0).append("address", 1);

collection.find(filter).projection(projection);
````
The above would yield the addresses for patients who match the earlier criteria. However, the driver also provides methods to simplify the process of using CRUD operations and the Aggregation API to build queries more efficiently. These methods are called builders.

If we were to use builders, instead of the above code, our code in Java might resemble the following:

````java
import static com.mongodb.client.model.Filters.*;
import static com.mongodb.client.model.Projections.*;

Bson filter = and(eq("gender", "male"), lt("age", 30));
Bson projection = fields(excludeId(), include("address"));

collection.find(filter).projection(projection);
````
There are several builders that are available in the Java driver today: 



* [Filters](https://mongodb.github.io/mongo-java-driver/5.1/apidocs/mongodb-driver-core/com/mongodb/client/model/Filters.html), for building query filters
* [Projections](https://mongodb.github.io/mongo-java-driver/5.1/apidocs/mongodb-driver-core/com/mongodb/client/model/Projections.html), for building projects
* [Sorts](https://mongodb.github.io/mongo-java-driver/5.1/apidocs/mongodb-driver-core/com/mongodb/client/model/Sorts.html), for building sort criteria
* [Updates](https://mongodb.github.io/mongo-java-driver/5.1/apidocs/mongodb-driver-core/com/mongodb/client/model/Updates.html), for building updates
* [Aggregates](https://mongodb.github.io/mongo-java-driver/5.1/apidocs/mongodb-driver-core/com/mongodb/client/model/Aggregates.html), for building aggregation pipelines
* [Indexes](https://mongodb.github.io/mongo-java-driver/5.1/apidocs/mongodb-driver-core/com/mongodb/client/model/Indexes.html), for creating index keys

In the above example, we use both the filters and projections. Filters are operations MongoDB uses to limit results to what you want to see, and projections allow you to specify which fields to include and exclude in query results. Projections are particularly useful when you want to limit the amount of data MongoDB is sending to applications, to optimize performance or reduce storage costs.

 \
The same builders are available in Kotlin and can be used with slightly different syntax. If we consider the non-builder case in Kotlin, our code might look like the following:

````java
val filter = Document().append("gender", "male").append("age", Document().append("\$lt", 30))
val projection = Document().append("_id", 0).append("address", 1)
val results = collection.find<Results>(filter).projection(projection)
````
Builders simplify this quite a bit, with the resulting code resembling the following:

````java
val filter = Filters.and(Filters.eq(User::gender.name, "male"), Filters.lt(User::age.name, 30))
val projection = Projections.fields(Projections.excludeId(), Projections.include("address"))
val results = collection.find<Results>(filter).projection(projection)
````

## Queryable Encryption

MongoDB supports encryption in several ways: 

(1) In transit through TLS/SSL, to ensure that MongoDB network traffic is only readable by the intended client 

(2) At rest, to help ensure compliance with security and privacy standards like HIPAA, PCI-DSS, and FERPA 

(3) In-use, to encrypt data when transmitted, stored, and processed 

Queryable Encryption is a form of in-use encryption that allows you to encrypt sensitive data from the client-side, store sensitive fields as fully randomized encrypted data on the server-side, and run expressive queries on the encrypted data. It is an industry-first, fast, searchable encryption scheme that allows you to perform expressive queries on encrypted fields without the need for deterministic encryption or hardware enclaves. Although Queryable Encryption was launched last year, with support for equality queries, with MongoDB 8.0 comes the ability to run range queries, as well. Range queries can be used to filter documents with specific value ranges, like dates or numerical intervals.

To use the new range support, you’ll need to first: \




1. Create [a Queryable Encryption-enabled application](https://mongodb.prakticum-team.ru/docs/manual/core/queryable-encryption/qe-create-application/#std-label-qe-create-application). 
2. *Optional*: If you’re using explicit encryption (as opposed to automatic encryption), you will also need to create a Data Encryption Key for your encrypted field(s).

Once you have your application, you’ll need to:

1. Specify which fields you’d like to encrypt by adding them to the encryption schema, with the `queries` property. Similar to specifying a `queryType` of “`equality`” for equality queries, for range queries, you’d want to specify a `queryType` of “`range`”.
2. Instantiate ClientEncryption to access the API for encryption helper methods (you can use ClientEncryptions#create to do so).
3. Create the collection (note that it is recommended to explicitly create the collection so that an index is created on the encrypted fields).
4. Insert at least one document with encrypted fields.

For a more in-depth guide to the above steps, we have [code snippets throughout our documentation.](https://mongodb.prakticum-team.ru/docs/manual/core/queryable-encryption/qe-create-encrypted-collection/#create-an-encrypted-collection-and-insert-documents)

Once a field has been designated as encrypted, and at least one document has been inserted into your collection with one of those encrypted fields, you can query to find matching documents. In Java, a range query to find a patient whose bill amount is between 1000 and 2000 might resemble the following:

````java
Document filter = new Document("patientRecord.billAmount", new Document("$gt", 1000).append("$lt", 2000));
Patient findResult = collection.find(filter).first();
````

Kotlin is not so different, syntax-wise, with the resulting range query resembling the following:

````java
val filter = Document("patientRecord.billAmount", Document("\$gt", 1000).append("\$lt", 2000))
val findResult: Patient? = collection.find(filter).first()
````
To explore Range Queries (and Queryable Encryption) in greater detail, check out our tutorial, [Java Meets Queryable Encryption][4]! It’ll take you step by step through the process of setting up a project, configuring automatic encryption, the encryption classes, and more.

## Summary
In the above article, we touched on key features of MongoDB and how to use them in two different, but complementary, languages. Java and Kotlin are two distinct languages that target the JVM, but with MongoDB support for both, you can rest assured that you can interact with your data in the language of your choice. Plus, because Java and Kotlin are interoperable, you can leverage the power of the long-standing Java ecosystem and the libraries and utilities within it, to build new Kotlin applications.

  [1]: https://mongodb.github.io/mongo-java-driver/5.1/apidocs/mongodb-driver-kotlin-coroutine/mongodb-driver-kotlin-coroutine/com.mongodb.kotlin.client.coroutine/-change-stream-flow/index.html
  [2]: https://mongodb.prakticum-team.ru/docs/mongodb-shell/
  [3]: https://mongodb.prakticum-team.ru/docs/manual/tutorial/project-fields-from-query-results/#suppress-_id-field
  [4]: https://mongodb.prakticum-team.ru/developer/products/atlas/java-queryable-encryption/

In this article, we’ll cover how to use some MongoDB features, and compare and contrast how they look and feel in Kotlin and Java.

Java vs Kotlin: Different Syntax, Same Possibilities

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

Java vs Kotlin: Different Syntax, Same Possibilities

Getting Started With Server-side Kotlin and MongoDB

How Queryable Encryption Can Keep James Bond Safe