# REST APIs with Java, Spring Boot, and MongoDB

## GitHub repository

If you want to write REST APIs in Java at the speed of light, I have what you need. I wrote this template to get you started. I have tried to solve as many problems as possible in it.

So if you want to start writing REST APIs in Java, clone this project, and you will be up to speed in no time.

```shell
git clone https://github.com/mongodb-developer/java-spring-boot-mongodb-starter
```

That’s all folks! All you need is in this repository. Below I will explain a few of the features and details about this template, but feel free to skip what is not necessary for your understanding.

## README

All the extra information and commands you need to get this project going are in the `README.md` file which you can read in GitHub.

## Spring and MongoDB configuration
## Spring and MongoDB configuration

The configuration can be found in the MongoDBConfiguration.java class.

```java
package com.mongodb.starter;

import ...]

import static org.bson.codecs.configuration.CodecRegistries.fromProviders;
import static org.bson.codecs.configuration.CodecRegistries.fromRegistries;

@Configuration
public class MongoDBConfiguration {

    @Value("${spring.data.mongodb.uri}")
    private String connectionString;

    @Bean
    public MongoClient mongoClient() {
        CodecRegistry pojoCodecRegistry = fromProviders(PojoCodecProvider.builder().automatic(true).build());
        CodecRegistry codecRegistry = fromRegistries(MongoClientSettings.getDefaultCodecRegistry(), pojoCodecRegistry);
        return MongoClients.create(MongoClientSettings.builder()
                                                      .applyConnectionString(new ConnectionString(connectionString))
                                                      .codecRegistry(codecRegistry)
                                                      .build());
    }

}
```
}
```

The important section here is the MongoDB configuration, of course. Firstly, you will notice the connection string is automatically retrieved from the `application.properties` file, and secondly, you will notice the configuration of the `MongoClient` bean.

A `Codec` is the interface that abstracts the processes of decoding a BSON value into a Java object and encoding a Java object into a BSON value.

A `CodecRegistry` contains a set of `Codec` instances that are accessed according to the Java classes that they encode from and decode to.

The MongoDB driver is capable of encoding and decoding BSON for us, so we do not have to take care of this anymore. All the configuration we need for this project to run is here and nowhere else.

You can read [the driver documentation if you want to know more about this topic.

## Multi-document ACID transactions
You can read [the driver documentation if you want to know more about this topic.

## Multi-document ACID transactions

Just for the sake of it, I also used multi-document ACID transactions in a few methods where it could potentially make sense to use ACID transactions. You can check all the code in the `MongoDBPersonRepository` class.

Here is an example:

```java
private static final TransactionOptions txnOptions = TransactionOptions.builder()
    .readPreference(ReadPreference.primary())
    .readConcern(ReadConcern.MAJORITY)
    .writeConcern(WriteConcern.MAJORITY)
    .build();

@Override
public List saveAll(List personEntities) {
    try (ClientSession clientSession = client.startSession()) {
        return clientSession.withTransaction(() -> {
            personEntities.forEach(p -> p.setId(new ObjectId()));
            personCollection.insertMany(clientSession, personEntities);
            return personEntities;
        }, txnOptions);
    }
}
```
As you can see, I’m using an auto-closeable try-with-resources which will automatically close the client session at the end. This helps me to keep the code clean and simple.

Some of you may argue that it is actually too simple because transactions (and write operations, in general) can throw exceptions, and I’m not handling any of them here… You are absolutely right and this is an excellent transition to the next part of this article.

## Exception management

Transactions in MongoDB can raise exceptions for various reasons, and I don’t want to go into the details too much here, but since MongoDB 3.6, any write operation that fails can be automatically retried once. And the transactions are no different. See the documentation for retryWrites.

If retryable writes are disabled or if a write operation fails twice, then MongoDB will send a MongoException (extends RuntimeException) which should be handled properly.
Luckily, Spring provides the annotation `ExceptionHandler` to help us do that. See the code in my controller `PersonController`. Of course, you will need to adapt and enhance this in your real project, but you have the main idea here.

```java
@ExceptionHandler(RuntimeException.class)
public final ResponseEntity handleAllExceptions(RuntimeException e) {
    logger.error("Internal server error.", e);
    return new ResponseEntity<>(e, HttpStatus.INTERNAL_SERVER_ERROR);
}
```

## Aggregation pipeline

MongoDB's aggregation pipeline is a very powerful and efficient way to run your complex queries as close as possible to your data for maximum efficiency. Using it can ease the computational load on your application.

Just to give you a small example, I implemented the `/api/persons/averageAge` route to show you how I can retrieve the average age of the persons in my collection.
```java
@Override
public double getAverageAge() {
    List pipeline = List.of(group(new BsonNull(), avg("averageAge", "$age")), project(excludeId()));
    return personCollection.aggregate(pipeline, AverageAgeDTO.class).first().averageAge();
}
```

Also, you can note here that I’m using the `personCollection` which was initially instantiated like this:

```java
private MongoCollection personCollection;

@PostConstruct
void init() {
    personCollection = client.getDatabase("test").getCollection("persons", PersonEntity.class);
}
```

Normally, my personCollection should encode and decode `PersonEntity` object only, but you can overwrite the type of object your collection is manipulating to return something different — in my case, `AverageAgeDTO.class` as I’m not expecting a `PersonEntity` class here but a POJO that contains only the average age of my "persons".

## Swagger
## Swagger

Swagger is the tool you need to document your REST APIs. You have nothing to do — the configuration is completely automated. Just run the server and navigate to http://localhost:8080/swagger-ui.html. the interface will be waiting for you.

 for more information.

## Nyan Cat

Yes, there is a Nyan Cat section in this post. Nyan Cat is love, and you need some Nyan Cat in your projects. :-)

Did you know that you can replace the Spring Boot logo in the logs with pretty much anything you want?

 and the "Epic" font for each project name. It's easier to identify which log file I am currently reading.

## Conclusion

I hope you like my template, and I hope I will help you be more productive with MongoDB and the Java stack.
## Conclusion

I hope you like my template, and I hope I will help you be more productive with MongoDB and the Java stack.

If you see something which can be improved, please feel free to open a GitHub issue or directly submit a pull request. They are very welcome. :-)

If you are new to MongoDB Atlas, give our Quick Start post a try to get up to speed with MongoDB Atlas in no time.

  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt876f3404c57aa244/65388189377588ba166497b0/swaggerui.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltf2f06ba5af19464d/65388188d31953242b0dbc6f/nyancat.png