Spring Boot - MongoRepository with Example

The MongoRepository interface in Spring Boot is a part of Spring Data MongoDB. It provides a way to perform CRUD operations and queries on MongoDB documents using Spring's familiar repository abstraction. Below is an example of how to use MongoRepository with Spring Boot:

1. Dependencies:

Firstly, add the necessary dependencies to your pom.xml:

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

2. Application Properties:

Configure MongoDB in the application.properties or application.yml:

spring.data.mongodb.uri=mongodb://localhost:27017/mydb

Replace mydb with your database name.

3. Create a Document:

For MongoDB with Spring, we use the @Document annotation for entities:

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

@Document
public class User {

    @Id
    private String id;
    private String name;
    private String email;

    // ... getters, setters, constructors, etc.
}

Here, @Id indicates the id property of the MongoDB document.

4. Create Repository:

Now, create a repository interface for the User document:

import org.springframework.data.mongodb.repository.MongoRepository;

public interface UserRepository extends MongoRepository<User, String> {
    User findByName(String name);
}

By extending MongoRepository, you get basic CRUD operations for free. Additionally, Spring Data allows you to define query methods in the repository, like findByName.

5. Use the Repository:

With the repository in place, you can now use it in a service or controller:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

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

    public User getUserByName(String name) {
        return userRepository.findByName(name);
    }

    // ... other methods
}

6. Run Your Application:

Now, if you run your Spring Boot application and have a MongoDB instance running at the specified location (in our case, localhost:27017), you can use the UserService to interact with the MongoDB instance and perform CRUD operations on the User documents.

Conclusion:

This was a basic introduction to MongoRepository in Spring Boot. The power of Spring Data MongoDB lies in its ability to generate queries from method names, provide custom query methods using the @Query annotation, support for paging and sorting, and many other advanced features.

Introduction to MongoRepository in Spring Boot:
- Description: MongoRepository is part of Spring Data MongoDB and provides a set of abstractions and methods for interacting with MongoDB data stores.
- Code:
```
// Example MongoRepository interface
public interface UserRepository extends MongoRepository<User, String> {
}
```

CRUD operations with MongoRepository in Spring Boot:

Description: MongoRepository supports standard CRUD operations like save, findById, findAll, delete, etc., out of the box.

Code:

// Example CRUD operations with MongoRepository
userRepository.save(new User("John Doe", 25));
Optional<User> user = userRepository.findById("userId");
List<User> allUsers = userRepository.findAll();
userRepository.delete(user.get());

Custom queries with MongoRepository in Spring Boot:

Description: MongoRepository allows the creation of custom queries using method names or @Query annotations.

Code:

// Custom query with method name
List<User> findByAgeGreaterThan(int age);

// Custom query with @Query annotation
@Query("{ 'name' : ?0, 'age' : { $gte: ?1 } }")
List<User> findUsersWithNameAndAge(String name, int age);

Pagination and sorting with MongoRepository in Spring Boot:
- Description: MongoRepository supports pagination and sorting for handling large datasets.
- Code:
```
// Pagination and sorting with MongoRepository
Page<User> usersPage = userRepository.findAll(PageRequest.of(0, 10, Sort.by("name")));
```
Handling embedded documents with MongoRepository in Spring Boot:
- Description: MongoRepository seamlessly handles embedded documents and relationships between entities.
- Code:
```
// Example entity with embedded document
public class User {
    private String name;
    private Address address;
    // getters and setters
}
```
Indexing and optimization with MongoRepository in Spring Boot:
- Description: MongoRepository can leverage MongoDB indexing for optimizing query performance.
- Code:
```
// Indexing with MongoRepository
@Document
@CompoundIndex(def = "{'name': 1, 'age': -1}")
public class User {
    // entity fields
}
```

Using QueryDSL with MongoRepository in Spring Boot:

Description: QueryDSL can be integrated with MongoRepository for more complex queries and dynamic query building.

Code:

// QueryDSL with MongoRepository
public interface UserRepository extends QuerydslMongoPredicateExecutor<User>, MongoRepository<User, String> {
    // custom queries with QueryDSL
}

Transaction management with MongoRepository in Spring Boot:

Description: MongoRepository supports transactions, allowing multiple operations to be executed within a single transaction.

Code:

// Transactional method with MongoRepository
@Transactional
public void performTransactionalOperation() {
    userRepository.save(new User("Alice", 30));
    userRepository.save(new User("Bob", 35));
}