How to Implement Auto-Increment Fields in MongoDB with Spring Boot

MongoDB, being a NoSQL database, does not have built-in support for auto-incrementing fields like traditional relational databases (e.g., MySQL) do with sequences or identity columns. However, you can still implement auto-increment functionality in MongoDB using a custom approach. In this blog post, we’ll walk through the process of creating an auto-incrementing sequence in MongoDB using Spring Boot.

Why Auto-Increment?

Auto-increment fields are often used as unique identifiers for records in databases. While MongoDB typically uses ObjectId for unique identifiers, there might be cases where you need a sequential, human-readable ID (e.g., order numbers, invoice IDs). This is where custom auto-increment fields come in handy.

Prerequisites

To follow along, you should have a basic understanding of:

Spring Boot
MongoDB
Java

Step 1: Set Up the MongoDB Connection in Java

First, you’ll need to connect to your MongoDB instance from your Java application. You can use the MongoDB Java Driver to handle the connection.

Add the following dependency to your pom.xml file:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
</dependencies>

Step 1: Set Up the counters Collection

MongoDB doesn’t have a built-in mechanism for auto-incrementing fields, but you can use a counters collection to achieve this. First, let’s define a counters document model:

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import lombok.Data;

@Data
@Document(collection = "database_counters")
public class DatabaseCounter {
    @Id
    private String id;
    private long counter
}

Here, we’re using a DatabaseCounter collection to store our counters. The id field will represent the counter name, and the counterfield will store the current counter number.

Step 2: Create a Counter Generator Service

Next, create a service that will handle the incrementing logic:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
import org.springframework.data.mongodb.core.FindAndModifyOptions;

@Service
public class CounterGeneratorService {

    @Autowired
    private MongoOperations mongoOperations;

    public long generateCounter(String counterName) {
        DatabaseCounter counter = mongoOperations.findAndModify(
                Query.query(Criteria.where("_id").is(counterName)),
                new Update().inc("counter", 1),
                FindAndModifyOptions.options().returnNew(true).upsert(true),
                DatabaseCounter.class);
        return counter != null ? counter.getCounter() : 1;
    }
}

This service defines a generateCounter method that takes the counter name as an argument, increments the counter value, and returns the new value. The findAndModify method is used to atomically update the counter in a thread-safe way.

Step 3: Integrate the Auto-Increment in Your Model

With the counter generator in place, you can now integrate it into your data models. Suppose you have an Employee model where you want to add an auto-incrementing id field:

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.annotation.Transient;
import lombok.Data;

@Data
@Document(collection = "employees")
public class Employee {
    @Transient
    public static final String COUNTER_NAME = "employee_counter";

    @Id
    private long id;
    private String name;
 
}

Step 4: Test the Implementation

To ensure that your auto-incrementing field works as expected, create a simple controller to add new employees:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/employees")
public class EmployeeController {

    @Autowired
    private EmployeeRepository employeeRepository;

    @Autowired
    private CounterGeneratorService counterGeneratorService;

    @PostMapping
    public Employee createEmployee(@RequestBody Employee employee) {  
        employee.setId(counterGeneratorService.
                generateCounter(Employee.COUNTER_NAME));
        return employeeRepository.save(employee);
    }

    @GetMapping("/{id}")
    public Employee getEmployeeById(@PathVariable long id) {
        return employeeRepository.findById(id).orElse(null);
    }
}

Now, whenever you create a new employee, the id field will be auto-incremented.

Conclusion

While MongoDB doesn’t provide built-in support for auto-incrementing fields like relational databases, it’s relatively straightforward to implement this feature using a counters collection and a counter generator service in Spring Boot. This approach gives you the flexibility to create unique identifiers across your collections, even in a distributed environment.

By following the steps outlined in this post, you can efficiently manage auto-incrementing fields in your MongoDB and Spring Boot applications. Happy coding!