Spring Boot with MongoDB: A Step-by-Step Tutorial

In modern web applications, MongoDB is often used due to its flexibility, scalability, and ease of use. Integrating MongoDB with Spring Boot enables developers to build robust and scalable applications quickly. In this tutorial, we will cover how to set up and use MongoDB with Spring Boot, focusing on CRUD (Create, Read, Update, Delete) operations.

Prerequisites

• JDK 17 or later
• Maven or Gradle
• MongoDB installed on your machine (or running via Docker)
• Spring Boot (version 3.2+ recommended)
• IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a Spring Boot Project

Use Spring Initializr to create a new project with the following configuration:

• Project: Maven Project
• Language: Java
• Spring Boot: 3.2.x
• Dependencies: Spring Web, Spring Data MongoDB

Download and unzip the project, then open it in your IDE.

Example Spring Boot Application

We will create a simple Spring Boot application that interacts with MongoDB to perform CRUD operations on a Product entity.

1.1 Application Class

package com.example.mongodb;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MongodbApplication {

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

Step 2: Running MongoDB

Using Docker

If you have Docker installed, you can run MongoDB using the following command:

docker run --name mongodb -d -p 27017:27017 mongo

Installing MongoDB Locally

Alternatively, you can install MongoDB on your local machine by following the installation instructions for your operating system from the MongoDB website.

Step 3: Configure MongoDB in Spring Boot

3.1 Add MongoDB Configuration

Add the following configuration to your src/main/resources/application.properties file:

# src/main/resources/application.properties

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

3.2 Create a MongoDB Configuration Class

(Optional) If you need custom configurations, create a configuration class named MongoConfig in the com.example.mongodb.config package. For most basic setups, the default configuration provided by Spring Boot should suffice.

Step 4: Create a Product Entity

Create a model class named Product in the com.example.mongodb.model package.

package com.example.mongodb.model;

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

@Document(collection = "products")
public class Product {

    @Id
    private String id;
    private String name;
    private String description;
    private double price;

    public Product() {
    }

    public Product(String name, String description, double price) {
        this.name = name;
        this.description = description;
        this.price = price;
    }

    // Getters and setters

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

Step 5: Create a Product Repository

Create a repository interface named ProductRepository in the com.example.mongodb.repository package. This interface will define methods for interacting with MongoDB.

package com.example.mongodb.repository;

import com.example.mongodb.model.Product;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface ProductRepository extends MongoRepository<Product, String> {
}

Step 6: Create a Product Service

Create a service class named ProductService in the com.example.mongodb.service package.

package com.example.mongodb.service;

import com.example.mongodb.model.Product;
import com.example.mongodb.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class ProductService {

    @Autowired
    private ProductRepository productRepository;

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    public Optional<Product> getProductById(String id) {
        return productRepository.findById(id);
    }

    public Product createProduct(Product product) {
        return productRepository.save(product);
    }

    public Optional<Product> updateProduct(String id, Product product) {
        return productRepository.findById(id).map(existingProduct -> {
            existingProduct.setName(product.getName());
            existingProduct.setDescription(product.getDescription());
            existingProduct.setPrice(product.getPrice());
            return productRepository.save(existingProduct);
        });
    }

    public void deleteProduct(String id) {
        productRepository.deleteById(id);
    }
}

Step 7: Create a REST Controller

Create a controller class named ProductController in the com.example.mongodb.controller package.

package com.example.mongodb.controller;

import com.example.mongodb.model.Product;
import com.example.mongodb.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/products")
public class ProductController {

    @Autowired
    private ProductService productService;

    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @GetMapping("/{id}")
    public Optional<Product> getProductById(@PathVariable String id) {
        return productService.getProductById(id);
    }

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return productService.createProduct(product);
    }

    @PutMapping("/{id}")
    public Optional<Product> updateProduct(@PathVariable String id, @RequestBody Product product) {
        return productService.updateProduct(id, product);
    }

    @DeleteMapping("/{id}")
    public void deleteProduct(@PathVariable String id) {
        productService.deleteProduct(id);
    }
}

Step 8: Test the Application

8.1 Run the Application

Run the Spring Boot application using your IDE or the command line:

./mvnw spring-boot:run

8.2 Verify CRUD Operations

Use a tool like Postman or curl to test the endpoints.

1. Create a Product:

   • URL: http://localhost:8080/products
   • Method: POST
   • Body:

     {
       "name": "Product 1",
       "description": "Description for product 1",
       "price": 100.0
     }
     

2. Get All Products:

   • URL: http://localhost:8080/products
   • Method: GET

3. Get a Product by ID:

   • URL: http://localhost:8080/products/{id}
   • Method: GET

4. Update a Product:

   • URL: http://localhost:8080/products/{id}
   • Method: PUT
   • Body:

     {
       "name": "Updated Product",
       "description": "Updated description",
       "price": 150.0
     }
     

5. Delete a Product:

   • URL: http://localhost:8080/products/{id}
   • Method: DELETE

You should see the correct responses and verify that the data is stored, retrieved, updated, and deleted from MongoDB.

Conclusion

In this tutorial, you have learned how to integrate MongoDB with Spring Boot to perform CRUD operations. We covered:

• Setting up a Spring Boot project with MongoDB dependencies.
• Running MongoDB locally using Docker or installing it on your machine.
• Configuring MongoDB in Spring Boot.
• Creating a Product entity, repository, service, and REST controller.
• Testing the CRUD operations using Postman or curl.

By following these steps, you can leverage MongoDB to build robust and scalable Spring Boot applications.