Rachelle Palmer

According to the 2022 Stack Overflow Developer Survey, Java is the sixth most popular programming, scripting, or markup language. 17K of the whopping 53K+ respondents indicated that they use Java - that’s a huge footprint!

Today we have more than 132,000 clusters running on Atlas using Java. 

We’re running our first-ever developer survey specifically for Java developers. We’ll use your survey responses to make changes that matter to you. The survey will take approximately 5-10 minutes to complete. As a way of saying thank you, we’ll be raffling off gift cards (five randomly chosen winners will receive $150).

You can access the survey [here](https://mongodb.co1.qualtrics.com/jfe/form/SV_9QtABFBuqDjQO4S).

MongoDB is conducted a survey for Java developers

The 2022 MongoDB Java Developer Survey

## Introduction
The Spring Data  Framework is used extensively in applications as it makes it easier  to access different kinds of persistence stores.  This article will show how to use  [Spring Data MongoDB](https://spring.io/projects/spring-data-mongodb) to implement bulk insertions.

BulkOperations is an interface that contains a list of write operations to be applied to the database. They can be any combination of
`InsertOne`,
`updateOne`
`updateMany`
`replaceOne`
`deleteOne`
`deleteMany`

A bulkOperation can be ordered or unordered. Ordered operations will be applied sequentially and if an error is detected, will return with an error code.  Unordered operations will be applied in parallel and are thus potentially faster, but it is the responsibility of the application to check if there were errors during the operations. For more information please refer to the bulk write operations section of the MongoDB documentation.

## Getting started
A POM file will specify the version of Spring Data that the application will use. Care must be taken to use a version of Spring Data that utilizes a compatible version of the MongoDB Java Driver. You can verify this compatibility in the [MongoDB Java API documentation](https://www.mongodb.com/docs/drivers/java/sync/current/compatibility/).
```
<dependencies>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-mongodb</artifactId>
       <version>2.7.2</version>
   </dependency>
```


## Application class
The top level class is a SpringBootApplication that implements a CommandLineRunner , like so: 
```
@SpringBootApplication
public class SpringDataBulkInsertApplication implements CommandLineRunner {

   @Value("${documentCount}")
   private int count;
   private static final Logger LOG = LoggerFactory
           .getLogger(SpringDataBulkInsertApplication.class);

   @Autowired
   private CustomProductsRepository repository;

   public static void main(String[] args) {
       SpringApplication.run(SpringDataBulkInsertApplication.class, args);
   }


   @Override
   public void run(String... args) {

       repository.bulkInsertProducts(count);
       LOG.info("End run");
   }
}

```

Now we need to write a few classes to implement our bulk insertion application.

## Configuration class
We will implement a class that holds the configuration to the MongoClient object that the Spring Data framework will utilize.

The `@Configuration` annotation will allow us to retrieve values to configure access to the MongoDB Environment. For a good explanation of Java-based configuration see [JavaConfig in the Spring reference documentation](https://docs.spring.io/spring-framework/docs/5.3.22/reference/html/core.html#beans-java) for more details.

```
@Configuration
public class MongoConfig   {
   @Value("${mongodb.uri}")
   private String uri;

   @Value("${mongodb.database}")
   private String databaseName;

   @Value("${truststore.path}")
   private String trustStorePath;
   @Value("${truststore.pwd}")
   private String trustStorePwd;

   @Value("${mongodb.atlas}")
   private boolean atlas;

   @Bean
   public MongoClient mongo() {
       ConnectionString connectionString = new ConnectionString(uri);
           MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
                   .applyConnectionString(connectionString)
                   .applyToSslSettings(builder -> {
                       if (!atlas) {
                           // Use SSLContext if a trustStore has been provided
                           if (!trustStorePath.isEmpty()) {
                               SSLFactory sslFactory = SSLFactory.builder()
                                       .withTrustMaterial(Paths.get(trustStorePath), trustStorePwd.toCharArray())
                                       .build();
                               SSLContext sslContext = sslFactory.getSslContext();
                               builder.context(sslContext);
                               builder.invalidHostNameAllowed(true);
                           }
                       }
                       builder.enabled(true);
                   })
                   .build();
       return MongoClients.create(mongoClientSettings);
   }

   @Bean
   public MongoTemplate mongoTemplate() throws Exception {
       return new MongoTemplate(mongo(), databaseName);
   }
}
```

In this implementation we are using a flag, mongodb.atlas,  to indicate that this application will  connect to Atlas. If the flag is false, an SSL Context may be created using a trustStore, This presents a certificate for the root certificate authority in the form of a truststore file pointed to by truststore.path, protected by a password (`truststore.pwd`) at the moment of creation.  If needed the client can also offer a keystore file, but this is not implemented.

The parameter mongodb.uri should contain a valid MongoDB URI.  The URI contains the hosts to which the client connects, the user credentials, etcetera. 

## The document class
The relationship between MongoDB collection and the documents that it contains is implemented via a class that is decorated by the @Document annotation.  This class defines the fields of the documents and the annotation defines the name of the collection.

```
@Document("products")
public class Products {

   private static final Logger LOG = LoggerFactory
           .getLogger(Products.class);
   @Id
   private String id;
   private String name;
   private int qty;
   private double price;
   private Date available;
   private Date  unavailable;
   private String skuId;
```

Setters and getters need to be defined for each field.  The @Id annotation indicates our default index. If this field is not specified, MongoDB will assign an ObjectId value which will be unique.

## Repository classes
The repository is implemented with two classes, one  an interface and the other the implementation of the interface. The repository classes flesh out  the interactions of the application with the database. A method in the repository is responsible for the bulk insertion:

```
@Component
public class CustomProductsRepositoryImpl implements CustomProductsRepository {

   private static final Logger LOG = LoggerFactory
           .getLogger(CustomProductsRepository.class);

   @Autowired
   MongoTemplate mongoTemplate;

   public int bulkInsertProducts(int count) {

       LOG.info("Dropping collection...");
       mongoTemplate.dropCollection(Products.class);
       LOG.info("Dropped!");

       Instant start = Instant.now();
       mongoTemplate.setWriteConcern(WriteConcern.W1.withJournal(true));

       Products [] productList = Products.RandomProducts(count);
       BulkOperations bulkInsertion = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, Products.class);

       for (int i=0; i<productList.length; ++i)
           bulkInsertion.insert(productList[i]);

       BulkWriteResult bulkWriteResult = bulkInsertion.execute();

       LOG.info("Bulk insert of "+bulkWriteResult.getInsertedCount()+" documents completed in "+ Duration.between(start, Instant.now()).toMillis() + " milliseconds");
       return bulkWriteResult.getInsertedCount();
   }
}
```

## Conclusion
In this example we are creating a random list of Products, which then are bulk-inserted unordered.  We have specified a write concern of 1, which means that the server will acknowledge the operation once the Primary has written the operation in the journal.

This write concern results in faster insertions, but there is a chance of losing data if the Primary crashes or an election takes place and data has not yet been replicated.  To avoid this danger, use write concern `Majority`.


Learn how to use Spring Data MongoDB to implement bulk insertions for your application

Implementing Bulk Writes using Spring Boot for MongoDB

## Introduction
Build your first application with Java and Spring! This simple application demonstrates basic CRUD operations via a book app - you can add a book, edit a book, delete a book. Stores the data in MongoDB database. 


## Technology

* Java
* Spring Boot
* MongoDB




Build an application to track the books you've read with Spring Boot, Java, and MongoDB

Build a MongoDB Spring Boot Java Book Tracker for Beginners

Graeme Robinson

In the second part of the series, we will provide examples of how the single-collection pattern can be utilized in Java applications using Spring Data MongoDB.

Single-Collection Designs in MongoDB with Spring Data (Part 2)

Mohit Sharma


> This is an introduction article on how to build a RESTful application in Kotlin using [Spring Boot 3](https://spring.io/) and [MongoDB Atlas](https://www.mongodb.com/atlas/database).

## Introduction

Today, we are going to build a basic RESTful application that does a little more than a CRUD operation, and for that, we will use:

* `Spring Boot 3`, which is one of the popular frameworks based on Spring, allowing developers to build production grades quickly.
* `MongoDB`, which is a document oriented database, allowing developers to focus on building apps rather than on [database schema](https://en.wikipedia.org/wiki/Database_schema).

## Prerequisites

This is a getting-started article, so nothing much is needed as a prerequisite. But familiarity with [Kotlin](https://kotlinlang.org/) as a programming language, plus a basic understanding of [Rest API](https://en.wikipedia.org/wiki/Representational_state_transfer) and [HTTP methods](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol), would be helpful.

To help with development activities, we will be using [Jetbrains IntelliJ IDEA (Community Edition)](https://www.jetbrains.com/idea/download/).

## HelloWorld app!

Building a HelloWorld app in any programming language/technology, I believe, is the quickest and easiest way to get familiar with it. This helps you cover the basic concepts, like how to build, run, debug, deploy, etc.

Since we are using the community version of IDEA, we cannot create the `HelloWorld` project directly from IDE itself using the New Project. But we can use the [Spring initializer app](https://start.spring.io/) instead, which allows us to create a Spring
project out of the box.

Once you are on the website, you can update the default selected parameters for the project, like the name of the project, language, version of `Spring Boot`, etc., to something similar as shown below.

![Spring initializer](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Spring_initializr_dbbfd7e79a.png)

And since we want to create REST API with MongoDB as a database, let's add the dependency using the Add Dependency button on the right.

![Spring dependency](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Spring_Depdendency_bb8866de1c.png)

After all the updates, our project settings will look like this.

![Spring project](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Spring_With_Dependency_4137b2515f.png)

Now we can download the project folder using the generate button and open it using the IDE. If we scan the project folder, we will only find one class — i.e., `HelloBackendWorldApplication.kt`, which has the `main` function, as well.

![Sample Project](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Default_App_c843cf2216.png)

The next step is to print HelloWorld on the screen. Since we are building a restful
application, we will create a `GET` request API. So, let's add a function to act as a `GET` API call.

```kotlin
@GetMapping("/hello")
fun hello(@RequestParam(value = "name", defaultValue = "World") name: String?): String {
    return String.format("Hello %s!", name)
}
```

We also need to add an annotation of `@RestController` to our `class` to make it a `Restful` client.

```kotlin
@SpringBootApplication
@RestController
class HelloBackendWorldApplication {
    @GetMapping("/hello")
    fun hello(): String {
        return "Hello World!"
    }
}

fun main(args: Array<String>) {
    runApplication<HelloBackendWorldApplication>(*args)
}
```

Now, let's run our project using the run icon from the toolbar.

![Run icon image](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Run_icon_image_bdb6c52ca8.png)

Now load https://localhost:8080/hello on the browser once the build is complete, and that will print Hello World on your screen.

![Hello World Output](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Hello_World_output_279aed0e43.png)

And on cross-validating this from [Postman](https://www.postman.com), we can clearly understand that our `Get` API is working perfectly.  
![Hello World Output](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Postman_output_216cb86538.png)

It's time to understand the basics of `Spring Boot` that made it so easy to create our first API call.

## What is Spring Boot ?

> [As per official docs](https://spring.io/projects/spring-boot#overview), Spring Boot makes it easy to create stand-alone, production-grade, Spring-based applications that you can "just run."

This implies that it's a tool built on top of the Spring framework, allowing us to build web applications quickly.

`Spring Boot` uses annotations, which do the heavy lifting in the background. A few of them, we have used already, like:

1. `@SpringBootApplication`: This annotation is marked at class level, and declares to the code reader (developer) and Spring that it's a Spring Boot project. It allows an enabling feature, which can also be done using `@EnableAutoConfiguration`,`@ComponentScan`, and `@Configuration`.

2. `@RequestMapping` and `@RestController`: This annotation provides the routing information. Routing is nothing but a mapping of a `HTTP` request path (text after `host/`) to classes that have the implementation of these across various `HTTP` methods.

These annotations are sufficient for building a basic application. Using Spring Boot, we will create a RESTful web service with all business logic, but we don't have a data container that can store or provide data to run these operations.

## Introduction to MongoDB

For our app, we will be using MongoDB as the database. MongoDB is an open-source, cross-platform, and distributed document database, which allows building apps with flexible schema. This is great as we can focus on building the app rather than defining the schema.

We can get started with MongoDB really quickly using [MongoDB Atlas](https://www.mongodb.com/atlas/database), which is a database as a service in the cloud and has a free forever tier.

I recommend that you explore the [MongoDB Jumpstart series](https://www.youtube.com/watch?v=RGfFpQF0NpE&list=PL4RCxklHWZ9v2lcat4oEVGQhZg6r4IQGV) to get familiar with MongoDB and its various services in under 10 minutes.

## Connecting with the Spring Boot app and MongoDB

With the basics of MongoDB covered, now let's connect our Spring Boot project to it. Connecting with MongoDB is really simple, thanks to the Spring Data MongoDB plugin.

To connect with MongoDB Atlas, we just need a [database URL](https://www.mongodb.com/docs/guides/atlas/connection-string/) that can be added
as a `spring.data.mongodb.uri` property in `application.properties` file. The connection string can be found as shown below.

![DB URL](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/find_Connect_Stream_URL_e7a6c2257a.gif)

The format for the connection string is:

```shell
spring.data.mongodb.uri = mongodb + srv ://<username>:<pwd>@<cluster>.mongodb.net/<dbname>
```

![Connection URL](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Connect_Mongo_DB_Atlas_19305672d4.png)

## Creating a CRUD RESTful app

With all the basics covered, now let's build a more complex application than HelloWorld! In this app, we will be covering all CRUD operations and tweaking them along the way to make it a more realistic app. So, let's create a new project similar to the HelloWorld app we created earlier. And for this app, we will use one of the sample datasets provided by MongoDB — one of my favourite features that enables quick learning.

You can load a [sample dataset](https://www.mongodb.com/developer/products/atlas/atlas-sample-datasets/) on Atlas as shown below:

![sample_db](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/load_sample_dataset_95ce8126e0.png)

We will be using the `sample_restaurants` collection for our CRUD application. Before we start with the actual CRUD operation, let's create the restaurant model class equivalent to it in the collection.

![model](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/model_from_compass_20b916a09a.png)

```kotlin

@Document("restaurants")
data class Restaurant(
    @Id
    val id: ObjectId = ObjectId(),
    val address: Address = Address(),
    val borough: String = "",
    val cuisine: String = "",
    val grades: List<Grade> = emptyList(),
    val name: String = "",
    @Field("restaurant_id")
    val restaurantId: String = ""
)

data class Address(
    val building: String = "",
    val street: String = "",
    val zipcode: String = "",
    @Field("coord")
    val coordinate: List<Double> = emptyList()
)

data class Grade(
    val date: Date = Date(),
    @Field("grade")
    val rating: String = "",
    val score: Int = 0
)
```

You will notice there is nothing fancy about this class except for the annotation. These annotations help us to connect or co-relate classes with databases like:

* `@Document`: This declares that this data class represents a document in Atlas.
* `@Field`: This is used to define an alias name for a property in the document, like `coord` for coordinate in `Address` model.

Now let's create a repository class where we can define all methods through which we can access data. `Spring Boot` has interface `MongoRepository`, which helps us with this.

```kotlin
interface Repo : MongoRepository<Restaurant, String> {

    fun findByRestaurantId(id: String): Restaurant?
}
```

After that, we create a controller through which we can call these queries. Since this is a bigger project, unlike the HelloWorld app, we will create a separate controller where the `MongoRepository` instance is passed using `@Autowired`, which provides annotations-driven dependency injection. 

```kotlin
@RestController
@RequestMapping("/restaurants")
class Controller(@Autowired val repo: Repo) {

}
``` 

### Read operation

Now our project is ready to do some action, so let's count the number of restaurants in the collection using `GetMapping`.

```kotlin
@RestController
@RequestMapping("/restaurants")
class Controller(@Autowired val repo: Repo) {

    @GetMapping
    fun getCount(): Int {
        return repo.findAll().count()
    }
}
```

![model](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Read_72aa6d89de.png)

Taking a step further to read the restaurant-based `restaurantId`. We will have to add a method in our repo as `restaurantId` is not marked `@Id` in the restaurant class.

```kotlin
interface Repo : MongoRepository<Restaurant, String> {
    fun findByRestaurantId(restaurantId: String): Restaurant?
}
``` 

```kotlin
@GetMapping("/{id}")
fun getRestaurantById(@PathVariable("id") id: String): Restaurant? {
    return repo.findByRestaurantId(id)
}
```

And again, we will be using [Postman](https://www.postman.com/) to validate the output against a random `restaurantId` from the sample dataset.

![ready-id](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Read_By_Id_d1752a108b.png)

Let's also validate this against a non-existing `restaurantId`.  

![ready-null](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Read_Null_637f97f167.png)

As expected, we haven't gotten any results, but the API response code is still 200, which is incorrect! So, let's fix this.

In order to have the correct response code, we will have to check the result before sending it back with the correct response code.

```kotlin
    @GetMapping("/{id}")
fun getRestaurantById(@PathVariable("id") id: String): ResponseEntity<Restaurant> {
    val restaurant = repo.findByRestaurantId(id)
    return if (restaurant != null) ResponseEntity.ok(restaurant) else ResponseEntity
        .notFound().build()
}
```

![ready-404](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Notfound_404_522b7f60ac.png)

### Write operation

To add a new object to the collection, we can add a `write` function in the `repo` we created earlier, or we can use the inbuilt method `insert` provided by `MongoRepository`. Since we will be adding a new object to the collection, we'll be using `@PostMapping` for this.

```kotlin
    @PostMapping
fun postRestaurant(): Restaurant {
    val restaurant = Restaurant().copy(name = "sample", restaurantId = "33332")
    return repo.insert(restaurant)
}
```

### Update operation

Spring doesn't have any specific in-built update similar to other CRUD operations, so we will be using the read and write operation in combination to perform the update function.

```kotlin
    @PatchMapping("/{id}")
fun updateRestaurant(@PathVariable("id") id: String): Restaurant? {
    return repo.findByRestaurantId(restaurantId = id)?.let {
        repo.save(it.copy(name = "Update"))
    }
}
```

This is not an ideal way of updating items in the collection as it requires two operations and can be improved further if we use the [MongoDB native driver](https://www.mongodb.com/docs/drivers/), which allows us to perform complicated operations with the minimum number of steps.

### Delete operation

Deleting a restaurant is also similar. We can use the `MongoRepository` delete function of the item from the collection, which takes the item as input.

```kotlin
    @DeleteMapping("/{id}")
fun deleteRestaurant(@PathVariable("id") id: String) {
    repo.findByRestaurantId(id)?.let {
        repo.delete(it)
    }
}
```

## Summary

Thank you for reading and hopefully you find this article informative! The complete source code of the app can be found on [GitHub](https://github.com/mongodb-developer/mongodb-springboot3-kotlin).

If you have any queries or comments, you can share them on the [MongoDB forum](https://www.mongodb.com/community/forums/) or tweet me [@codeWithMohit](https://twitter.com/codeWithMohit).

This is an introductory article on how to build a RESTful application in Kotlin using Spring Boot 3 and MongoDB Atlas.

Spring

All Spring Content

Getting Started with Backend Development in Kotlin Using Spring Boot 3 & MongoDB

Single-Collection Designs in MongoDB with Spring Data (Part 2)

Build a MongoDB Spring Boot Java Book Tracker for Beginners

Implementing Bulk Writes using Spring Boot for MongoDB

The 2022 MongoDB Java Developer Survey

Related Topics