Spring Data MongoDB Annotations

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Spring Data MongoDB is a powerful module that provides seamless integration between MongoDB—a popular NoSQL database—and the Spring Framework. It simplifies storing and querying data in MongoDB through its repository abstraction, converting Java objects into documents stored in MongoDB collections. This process is greatly facilitated by a suite of annotations, making the implementation of data access layers more efficient and less prone to errors. Let's dive into some core Spring Data MongoDB annotations and understand their roles and benefits.

1. @Document

This annotation marks a class as a domain object that will be persisted in the database. You can specify the name of the collection where the documents will be stored. If not specified, the collection name will be derived from the class name.

@Document(collection = "users")
public class User {
    // Class fields and methods
}

2. @Id 

This annotation is applied to a field that should be used as the primary key of the document. MongoDB stores the primary key as _id. When using @Id, Spring Data automatically translates the field into _id during persistence.

public class User {
    @Id
    private String id;
    // Other class fields
}

3. @Field 

Use the @Field annotation to specify a custom name for the document field. This is particularly useful when the field name in the document should be different from the Java class field name.

public class User {
    @Field(name = "email_address")
    private String emailAddress;
    // Other fields
}

4. @DBRef 

This annotation is used to define a reference to another document. It leverages MongoDB's DBRef feature, allowing you to easily create relationships between documents.

public class Order {
    @DBRef
    private User user;
    // Other fields
}

5. @Query 

The @Query annotation lets you define a MongoDB JSON query to be used for the annotated method. This provides a powerful way to execute custom queries directly on the repository interface.

public interface UserRepository extends MongoRepository<User, String> {
    @Query("{ 'emailAddress' : ?0 }")
    List<User> findByEmailAddress(String emailAddress);
}

6. @EnableMongoRepositories 

While not directly related to data mapping, @EnableMongoRepositories is crucial for configuring the repositories at the application level. It enables Spring to scan for MongoDB repository interfaces, allowing them to be autowired and used in the application.

@Configuration
@EnableMongoRepositories(basePackages = "com.example.repository")
public class MongoConfig {
    // Configuration details
}

Complete Example - Simple Book Library System

Let's create a comprehensive example that combines all the discussed Spring Data MongoDB annotations (@Document, @Id, @Field, @DBRef, @Query, and @EnableMongoRepositories) into a single, coherent application. This example will simulate a simple book library system, where we have Book and Author entities, and we aim to showcase how these annotations work together in a Spring Boot application context. 

Step 1: Define the Domain Models 

First, we define our Author and Book domain models using the @Document, @Id, and @Field annotations.

@Document(collection = "authors")
public class Author {
    @Id
    private String id;
    @Field(name = "name")
    private String name;
    // Constructors, Getters, and Setters
}

@Document(collection = "books")
public class Book {
    @Id
    private String id;
    @Field(name = "title")
    private String title;
    @DBRef
    private Author author;
    // Constructors, Getters, and Setters
}

Step 2: Create Repository Interfaces 

Next, we define a repository interface for each entity. We'll also include a custom query in the BookRepository using the @Query annotation.

public interface AuthorRepository extends MongoRepository<Author, String> {
}

public interface BookRepository extends MongoRepository<Book, String> {
    @Query("{ 'title' : ?0 }")
    List<Book> findByTitle(String title);
}

Step 3: Configure MongoDB Repositories 

We use @EnableMongoRepositories to enable the scanning of MongoDB repositories. This is typically placed in a configuration class.

@Configuration
@EnableMongoRepositories(basePackages = "com.example.repository")
public class MongoConfig {
    // MongoDB configuration details
}

Step 4: Spring Boot Application Setup 

Lastly, we'll set up a simple Spring Boot application to tie everything together. We'll also create a command-line runner to populate our database with an author and a book for demonstration.

@SpringBootApplication
public class LibraryApplication {

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

    @Bean
    CommandLineRunner runner(AuthorRepository authorRepository, BookRepository bookRepository) {
        return args -> {
            Author author = new Author();
            author.setName("Ramesh");
            author = authorRepository.save(author);

            Book book = new Book();
            book.setTitle("Spring Boot for Beginners");
            book.setAuthor(author);
            bookRepository.save(book);

            System.out.println("Sample data loaded");
        };
    }
}

This complete example illustrates how to use Spring Data MongoDB annotations to define domain models (@Document, @Id, @Field), manage document references (@DBRef), execute custom queries (@Query), and configure MongoDB repositories (@EnableMongoRepositories) in a Spring Boot application. With this setup, you can start building sophisticated, data-driven applications leveraging MongoDB with minimal boilerplate code and maximum efficiency.