Spring Boot and MongoDB

Connecting Spring Boot to MongoDB Atlas

After you get the connection from MongoDB Atlas UI, paste the string into the application.properties files. There is no need to write connection-related code in any other file. Spring Boot takes care of the database connection for us.

xxxxxxxxxx

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

spring.data.mongodb.database=mygrocerylist

​

In addition, we also need to put the database here. If it doesn't exist, MongoDB will create one.

Building the SpringBoot model class

Creating the GroceryItem model

To build the Spring Boot project, we start with the model class. The class of the MVC architecture is where we map the Plain Old Java Objects or POJOs. This class works with the data stored in the MongoDB collection and is also used to transfer data between the view and controller of the Spring MVC application.

In our project, we will be creating a GroceryItem.java class where the objects have been mapped to be used inside the application. 

xxxxxxxxxx

@Document("GroceryItem")

public class GroceryItem {

​

        @Id

        private String id;

​

        private String name;

        private int quantity;

        private String category;

        public GroceryItem(String id, String name, int quantity, String category) {

            super();

            this.id = id;

            this.name = name;

            this.quantity = quantity;

            this.category = category;

        }

​

If you look at the above code, it has an @Document annotation to specify the collection name that will be used by the model. If the collection doesn't exist, MongoDB will create it.

Following that, it mentions all the field values with their datatypes. You'll also note that in the above sample, the primary key in our MongoDB document is specified using the @Id annotation. If we don't do this, MongoDB will automatically generate an _id when creating the document. 

This class also has all the getters and setter methods used in the application defined, along with the constructor methods, if any.

Repository layer: Implementing MongoDB CRUD operations

1.Creating the ItemRepository interface

To implement the APIs and perform the desired functionality, the code for implementing the business logic goes inside the repository code. It acts as a link between the model and the database and has all the methods for CRUD operations.

To implement that, we first create an ItemRepository public interface that extends the MongoRepository interface.

xxxxxxxxxx

public interface ItemRepository extends MongoRepository<GroceryItem, String> {

    @Query("{name:'?0'}")

    GroceryItem findItemByName(String name);

    @Query(value="{category:'?0'}", fields="{'name' : 1, 'quantity' : 1}")

    List<GroceryItem> findAll(String category);

    public long count();

}

​

The first method, findItemByName, requires a parameter for the query, i.e., the field by which to filter the query. We specify this with the annotation @Query. The second method uses the category field to get a particular category's items. We only want to project the field's name and quantity in the query response, so we set those fields to 1. We reuse the method count() as it is.

2.Using MongoRepository methods for CRUD

The next step is to make the connection to the MongoDB Atlas database. To make the connection, we need to get the connection string for a cluster, which can be found in the Atlas UI. 

We will configure credentials inside the application properties to connect to the databases. Spring Data MongoDB provides keys to configure the database connection.

After you get the connection from MongoDB Atlas UI, paste the string into the application.properties files. There is no need to write connection-related code in any other file. Spring Boot takes care of the database connection for us.

xxxxxxxxxx

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

spring.data.mongodb.database=mygrocerylist

​

In addition, we also need to put the database here. If it doesn't exist, MongoDB will create one.

In this Spring Boot MongoDB example, we are not using the controller and the view. We will use a CommandLineRunner to view the output on the console.

The next step is from where we start the main class. The application starts from the MdbSpringBootApplication.java class.

xxxxxxxxxx

@SpringBootApplication

@EnableMongoRepositories

public class MdbSpringBootApplication implements CommandLineRunner{

    @Autowired

    ItemRepository groceryItemRepo;

    @Autowired

    CustomItemRepository customRepo;

    List<GroceryItem> itemList = new ArrayList<GroceryItem>();

​

    public static void main(String[] args) {

        SpringApplication.run(MdbSpringBootApplication.class, args);

    }

​

This class MdbSpringBootApplication implements the CommandLineRunner interface to run the Spring application. ItemRepository is autowired, allowing Spring to find it automatically.

Spring initializes the application context using the @SpringBootApplication annotation. We also activate the Mongo repositories using @EnableMongoRepositories. Our project structure should be similar to the below structure now:

Let's now add the repository methods to the main class for CRUD operations.

Performing create operations with MongoDB

To perform the CRUD operations, start with creating a new document and saving it into the MongoDB collection. To do so, it makes use of the save method. The save method is available to us through the SimpleMongoRepository class, which implements the MongoRepository interface. 

The save method takes the GroceryItem object as a parameter.

xxxxxxxxxx

void createGroceryItems() {

        System.out.println("Data creation started...");

​

        groceryItemRepo.save(new GroceryItem("Whole Wheat Biscuit", "Whole Wheat Biscuit", 5, "snacks"));

        groceryItemRepo.save(new GroceryItem("Kodo Millet", "XYZ Kodo Millet healthy", 2, "millets"));

        groceryItemRepo.save(new GroceryItem("Dried Red Chilli", "Dried Whole Red Chilli", 2, "spices"));

        groceryItemRepo.save(new GroceryItem("Pearl Millet", "Healthy Pearl Millet", 1, "millets"));

        groceryItemRepo.save(new GroceryItem("Cheese Crackers", "Bonny Cheese Crackers Plain", 6, "snacks"));

        System.out.println("Data creation complete...");

    }

​

The code above creates five different sample documents and saves them in the MongoDB database. 

Read operations in MongoDB with Spring Boot

After the data is present inside the database, you need to read the data from the collection. The read code present in the main class covers four different cases:

• Fetching all the documents using findAll()

• Getting a single document by name

• Getting a list of items by category

• Getting the count of items

1.Fetching all documents with findAll()

xxxxxxxxxx

public void showAllGroceryItems() {

         itemList = groceryItemRepo.findAll();

         itemList.forEach(item -> System.out.println(getItemDetails(item)));

     }

​

This read method would show all the documents present inside the MongoDB collection. 

2.Fetching specific documents by name

The next read method would extract a specific document based on a specific item name.

xxxxxxxxxx

public void getGroceryItemByName(String name) {

         System.out.println("Getting item by name: " + name);

         GroceryItem item = groceryItemRepo.findItemByName(name);

         System.out.println(getItemDetails(item));

     }

​

The next read method includes operating to get items of a specific category. 

3.Fetching items by category

Java

Code Snippetpublic void getItemsByCategory(String category) { System.out.println("Getting items for the category " + category); List<GroceryItem> list = groceryItemRepo.findAll(category); list.forEach(item -> System.out.println("Name: " + item.getName() + ", Quantity: " + item.getItemQuantity())); }

xxxxxxxxxx

7

 

1

public void getItemsByCategory(String category) {

2

         System.out.println("Getting items for the category " + category);

3

         List<GroceryItem> list = groceryItemRepo.findAll(category);

4

5

         list.forEach(item -> System.out.println("Name: " + item.getName() + ", Quantity: " + item.getItemQuantity()));

6

     }

7

​

And lastly, if you wish to count the number of documents being returned… 

4.Counting documents in the collection

Java

Code Snippet public void findCountOfGroceryItems() { long count = groceryItemRepo.count(); System.out.println("Number of documents in the collection = " + count); }

xxxxxxxxxx

5

 

1

 public void findCountOfGroceryItems() {

2

         long count = groceryItemRepo.count();

3

         System.out.println("Number of documents in the collection = " + count);

4

     }

5

​

Update operations in MongoDB

1.Updating documents with saveAll()

This explains the MongoDB method to make an update to the document saved inside the database. 

For example, to change the category from "snacks" to "munchies," we first need to find all documents with the category "snacks," set their categories to "munchies," and then save all the modified documents.

xxxxxxxxxx

public void updateCategoryName(String category) {

         String newCategory = "munchies";

         List<GroceryItem> list = groceryItemRepo.findAll(category);

         list.forEach(item -> {

             item.setCategory(newCategory);

         });

         List<GroceryItem> itemsUpdated = groceryItemRepo.saveAll(list);

         if(itemsUpdated != null)

             System.out.println("Successfully updated " + itemsUpdated.size() + " items.");      

     }

​

Delete operations with MongoDB

Finally, the last step of the CRUD is to delete a specific document from the collection. 

xxxxxxxxxx

public void deleteGroceryItem(String id) {

         groceryItemRepo.deleteById(id);

         System.out.println("Item with id " + id + " deleted...");

     }

     public String getItemDetails(GroceryItem item) {

​

         System.out.println(

         "Item Name: " + item.getName() + 

         ", \nItem Quantity: " + item.getItemQuantity() + 

         ", \nItem Category: " + item.getCategory()

         );

             return "";

     }

​

​

To delete all the items, we can use the groceryItemRepo.deleteAll() method.

Running the Spring Boot application

In this step, we will implement the CommandLineRunner.run() method to call the above methods:

Java

Code Snippetpublic void run(String... args) { groceryItemRepo.deleteAll(); System.out.println("-------------CREATE GROCERY ITEMS-------------------------------\n"); createGroceryItems(); System.out.println("\n----------------SHOW ALL GROCERY ITEMS---------------------------\n"); showAllGroceryItems(); System.out.println("\n--------------GET ITEM BY NAME-----------------------------------\n"); getGroceryItemByName("Whole Wheat Biscuit"); System.out.println("\n-----------GET ITEMS BY CATEGORY---------------------------------\n"); getItemsByCategory("millets"); System.out.println("\n-----------UPDATE CATEGORY NAME OF ALL GROCERY ITEMS----------------\n"); updateCategoryName("snacks"); System.out.println("\n----------DELETE A GROCERY ITEM----------------------------------\n"); deleteGroceryItem("Kodo Millet"); System.out.println("\n------------FINAL COUNT OF GROCERY ITEMS-------------------------\n"); findCountOfGroceryItems(); System.out.println("\n-------------------THANK YOU---------------------------"); }

xxxxxxxxxx

36

 

1

public void run(String... args) {

2

3

        groceryItemRepo.deleteAll(); 

4

5

        System.out.println("-------------CREATE GROCERY ITEMS-------------------------------\n");

6

7

        createGroceryItems();

8

9

        System.out.println("\n----------------SHOW ALL GROCERY ITEMS---------------------------\n");

10

11

        showAllGroceryItems();

12

13

        System.out.println("\n--------------GET ITEM BY NAME-----------------------------------\n");

14

15

        getGroceryItemByName("Whole Wheat Biscuit");

16

17

        System.out.println("\n-----------GET ITEMS BY CATEGORY---------------------------------\n");

18

19

        getItemsByCategory("millets");

20

21

        System.out.println("\n-----------UPDATE CATEGORY NAME OF ALL GROCERY ITEMS----------------\n");

22

23

        updateCategoryName("snacks");

24

25

        System.out.println("\n----------DELETE A GROCERY ITEM----------------------------------\n");

26

27

        deleteGroceryItem("Kodo Millet");

28

29

        System.out.println("\n------------FINAL COUNT OF GROCERY ITEMS-------------------------\n");

30

31

        findCountOfGroceryItems();

32

33

        System.out.println("\n-------------------THANK YOU---------------------------");

34

35

    }

36

​

This code snippet helps you identify the response for each of the CRUD operations and gives you the response as:

And:

Update using MongoTemplate

The update operation that we saw in the earlier code example was performed using MongoRepository code. However, there is more than one method to perform the update. This is using the MongoTemplate class. 

The nice thing about MongoTemplate is that the update can be done in a single database interaction.

To use MongoTemplate, we create a custom repository where we build the update query.

Let's write a method to update the quantity of a grocery item. For this, we create a new Java class as CustomItemRepository.java.

xxxxxxxxxx

public interface CustomItemRepository { 

    void updateItemQuantity(String itemName, float newQuantity);

}

​

And then add the implementation for this interface into the CustomItemRepositoryImpl.java class file as:

xxxxxxxxxx

public class CustomItemRepositoryImpl implements CustomItemRepository {

​

    @Autowired

    MongoTemplate mongoTemplate;

    public void updateItemQuantity(String name, float newQuantity) {

        Query query = new Query(Criteria.where("name").is(name));

        Update update = new Update();

        update.set("quantity", newQuantity);

        UpdateResult result = mongoTemplate.updateFirst(query, update, GroceryItem.class);      

        if(result == null)

            System.out.println("No documents updated");

        else

            System.out.println(result.getModifiedCount() + " document(s) updated..");

​

    }

}

​

Now, to run this method, add it to the main class as:

Java

Code SnippetSystem.out.println("\n-----------UPDATE QUANTITY OF A GROCERY ITEM------------------------\n"); updateItemQuantity("Bonny Cheese Crackers Plain", 10);

xxxxxxxxxx

3

 

1

System.out.println("\n-----------UPDATE QUANTITY OF A GROCERY ITEM------------------------\n"); 

2

        updateItemQuantity("Bonny Cheese Crackers Plain", 10);

3

​

Which gives the results as:

The difference between updates of the two methods is how the operations happen. For example, in the MongoRepository method, we had to do three operations (find, set, save), while in the latter method, we update in a single database transaction!

Conclusion: Why Spring Boot and MongoDB are ideal for modern applications

We’ve covered the fundamental concepts of integrating Spring Boot with MongoDB, along with building a complete Spring Boot application. For further exploration beyond the Spring Boot starter or to dive deeper into the core capabilities of Spring Data, you can refer to our handy guide.