Integrate MongoDB with Spring Boot

MongoDB database is a popular NoSQL database known for its scalability and flexibility. In contrast, Spring Boot is a powerful framework that simplifies the development of Java applications. Our goal in this article is to demonstrate how to integrate MongoDB with Spring Boot application, including setting up dependencies, configuring the connection, and performing basic CRUD operations (Create, Read, Update, Delete).

Create a Spring Boot Project

Create a new Spring Boot project. This can be done using Spring Initializr (https://start.spring.io/) or your favorite IDE.

Add MongoDB Dependencies

In your pom.xml file (for Maven), add the MongoDB dependencies:

<dependencies>
    <!-- Spring Boot Starter Data MongoDB -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
</dependencies>

Configure MongoDB Connection

Spring Boot provides auto-configuration for MongoDB based on the properties in the application.properties file. Add your MongoDB connection properties to this file:

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=mydatabase

Create a Model Class

Create a simple model class representing a MongoDB document. For example, let's create a User class:

package com.mongodb.application.entity;

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

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

@Document(collection = "users")
public class User {

    @Id
    private String id;
    private String firstName;
    private String lastName;
    private int age;

    // Constructors
    public User() {
    }

    public User(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // Getters and Setters
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // toString() method
    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", age=" + age +
                '}';
    }
}

Create Repository

Create a repository interface that extends MongoRepository to perform CRUD operations on the User collection.

package com.mongodb.application.repository;

import org.springframework.data.mongodb.repository.MongoRepository;
import com.mongodb.application.entity.User;

public interface UserRepository extends MongoRepository<User, String> {

}

Perform CRUD Operations

Now, you can use the UserRepository to perform CRUD operations in your service or controller classes.

package com.mongodb.application.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
import com.mongodb.application.entity.User;
import com.mongodb.application.repository.UserRepository;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User getUserById(String id) {
        Optional<User> optionalUser = userRepository.findById(id);
        return optionalUser.orElse(null);
    }

    public User updateUser(User updatedUser) {
        return userRepository.save(updatedUser);
    }

    public void deleteUser(String id) {
        userRepository.deleteById(id);
    }
}

Create CommandLineRunner Bean to Test

This bean will call the methods in your UserService to test the controller endpoints.

package com.mongodb.application.testRunner;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import com.mongodb.application.entity.User;
import com.mongodb.application.service.UserService;

@Component
public class TestRunner implements CommandLineRunner {

    @Autowired
    private UserService userService;

    @Override
    public void run(String... args) throws Exception {
        // Your test code here
        testUserEndpoints();
    }

    private void testUserEndpoints() {
        // Test creating a user
        User newUser = new User();
        newUser.setFirstName("John");
        newUser.setLastName("Doe");
        newUser.setAge(30);

        System.out.println("Creating User:");
        User createdUser = userService.createUser(newUser);
        System.out.println("Created User: " + createdUser);

        // Test reading users
        System.out.println("Reading All Users:");
        userService.getAllUsers().forEach(System.out::println);

        // Test updating a user
        System.out.println("Updating User:");
        createdUser.setAge(31);
        User updatedUser = userService.updateUser(createdUser);
        System.out.println("Updated User: " + updatedUser);

        // Test reading a specific user
        System.out.println("Reading User by ID:");
        User fetchedUser = userService.getUserById(updatedUser.getId());
        System.out.println("Fetched User: " + fetchedUser);

        // Test deleting a user
        System.out.println("Deleting User:");
        userService.deleteUser(fetchedUser.getId());
        System.out.println("User deleted.");

        // Test reading all users after deletion
        System.out.println("Reading All Users after Deletion:");
        userService.getAllUsers().forEach(System.out::println);
    }
}

Run the Application

When you run your Spring Boot application, the CommandLineRunner will automatically execute the testUserEndpoints() method. A user can be created, read, updated, and deleted using this CommandLineRunner. You can check the data getting added to the database by commenting out the deletion check

Make sure to have MongoDB running and properly configured with Spring Boot for this to work. Each operation's output will be displayed in the console.

This setup allows you to test your controller's endpoints without needing an external tool like Postman.

Conclusion

In this article, we've explored how to connect MongoDB with a Spring Boot application. By adding the necessary dependencies, configuring the MongoDB connection properties, creating a model class, and using a MongoRepository, we can easily perform CRUD operations on MongoDB documents. Spring Boot's auto-configuration simplifies the process of setting up the MongoDB connection, allowing developers to focus on building the application's logic rather than handling the database setup. With this setup, Spring Boot applications can be built with ease using MongoDB