Spring Data MongoDB : configuration et utilisation

Intégrer MongoDB dans l'écosystème Spring Boot

MongoDB est l'une des bases de données NoSQL orientées documents les plus populaires, appréciée pour sa flexibilité de schéma, sa scalabilité et ses capacités de requêtage riches. Pour faciliter son intégration dans les applications Spring, l'écosystème Spring Data propose le module Spring Data MongoDB. Conformément à la philosophie Spring Data, ce module vise à fournir une abstraction familière (notamment via l'interface Repository) tout en permettant d'exploiter les fonctionnalités spécifiques de MongoDB.

Grâce à Spring Boot et son auto-configuration, la mise en place d'une connexion à MongoDB et l'utilisation des fonctionnalités de base de Spring Data MongoDB deviennent remarquablement simples. Ce chapitre vous guidera à travers les étapes essentielles de configuration et vous montrera comment effectuer des opérations CRUD de base à l'aide des repositories.

Configuration du projet et de la connexion

La première étape consiste à ajouter la dépendance starter appropriée à votre projet. Cela inclura Spring Data MongoDB ainsi que le driver Java officiel de MongoDB.

Maven (pom.xml) :

    org.springframework.boot
    spring-boot-starter-data-mongodb

Gradle (build.gradle) :

implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'

Ensuite, vous devez configurer les informations de connexion à votre instance MongoDB dans votre fichier application.properties ou application.yml. Spring Boot offre plusieurs propriétés pour cela. L'approche la plus courante et flexible est d'utiliser l'URI de connexion MongoDB :

application.properties :

# Utilisation de l'URI de connexion (recommandé)
# Format: mongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[database][?options]]
spring.data.mongodb.uri=mongodb://localhost:27017/ma_base_de_donnees

# Exemple avec authentification et réplica set:
# spring.data.mongodb.uri=mongodb://user:secret@host1:27017,host2:27017/ma_base_de_donnees?replicaSet=myReplicaSet

application.yml :

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/ma_base_de_donnees
      # uri: mongodb://user:secret@host1:27017,host2:27017/ma_base_de_donnees?replicaSet=myReplicaSet

Alternativement, vous pouvez spécifier les paramètres individuellement (moins flexible pour les configurations complexes comme les réplica sets) :

application.properties :

# Configuration détaillée (moins courante)
# spring.data.mongodb.host=localhost
# spring.data.mongodb.port=27017
# spring.data.mongodb.database=ma_base_de_donnees
# spring.data.mongodb.username=user
# spring.data.mongodb.password=secret
# spring.data.mongodb.authentication-database=admin

Grâce à l'auto-configuration de Spring Boot, la présence du starter et de ces propriétés suffit pour que Spring configure automatiquement les beans nécessaires, notamment :

• Un MongoClient (le client driver Java).
• Un MongoDatabaseFactory.
• Un MongoTemplate : Un bean central de Spring Data MongoDB offrant un accès plus direct et plus fin à l'API MongoDB pour des opérations complexes.

Utilisation via les Repositories Spring Data

L'approche la plus courante et la plus simple pour les opérations CRUD de base consiste à utiliser l'abstraction Repository de Spring Data. Comme pour JPA ou JDBC, vous définissez une interface qui étend une interface Spring Data spécifique à MongoDB, typiquement MongoRepository.

Vous devez d'abord définir votre classe Java qui sera mappée à un document MongoDB. Le mapping détaillé sera abordé dans la section suivante, mais pour l'instant, supposons une classe simple Product avec un champ id de type String (MongoDB utilise souvent des ObjectIds représentés comme des chaînes hexadécimales).

// Supposons une classe Product (le mapping sera détaillé ensuite)
package com.certiquizz.mongo.domain;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "products") // Lie à la collection 'products'
public class Product {
    @Id
    private String id; // L'ID MongoDB est souvent une String
    private String name;
    private Double price;
    // Constructeurs, Getters, Setters...
}

Ensuite, créez l'interface Repository :

package com.certiquizz.mongo.repository;

import com.certiquizz.mongo.domain.Product;
import org.springframework.data.mongodb.repository.MongoRepository;
import java.util.List;

public interface ProductRepository extends MongoRepository { // Id de type String

    // Méthode dérivée : trouver des produits par nom
    List findByName(String name);

    // Méthode dérivée : trouver des produits dont le prix est inférieur à une valeur
    List findByPriceLessThan(Double maxPrice);

}

Vous pouvez maintenant injecter ce ProductRepository dans vos services ou contrôleurs et utiliser les méthodes héritées de MongoRepository ainsi que vos méthodes dérivées :

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 Product createProduct(Product product) {
        return productRepository.save(product); // Crée ou met à jour
    }

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

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

    public List findProductsByName(String name) {
        return productRepository.findByName(name);
    }

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

Spring Data MongoDB, grâce à l'implémentation de repository fournie, se charge de traduire ces appels de méthode en opérations MongoDB appropriées (insertOne, updateOne, find, deleteOne, etc.).

Alternative : Utilisation du `MongoTemplate`

Pour des scénarios plus complexes qui ne sont pas facilement couverts par les méthodes de repository (requêtes avec critères complexes, projections spécifiques, opérations d'agrégation, mises à jour atomiques avancées, opérations en masse), Spring Data MongoDB fournit le MongoTemplate.

Le MongoTemplate offre une API plus riche et plus proche du driver MongoDB natif, tout en gérant la connexion, la conversion d'objets et la gestion des exceptions. Vous pouvez l'injecter directement dans vos services :

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;

@Component
public class AdvancedProductQueries {

    @Autowired
    private MongoTemplate mongoTemplate;

    public List findProductsWithPriceRange(double minPrice, double maxPrice) {
        Query query = new Query();
        query.addCriteria(Criteria.where("price").gte(minPrice).lte(maxPrice));
        return mongoTemplate.find(query, Product.class);
    }

    // D'autres opérations (updateFirst, updateMulti, aggregate, etc.) sont disponibles
}

Bien que plus verbeux pour les opérations simples, MongoTemplate est indispensable pour exploiter toute la puissance de MongoDB au sein de votre application Spring Boot lorsque les repositories atteignent leurs limites.

Conclusion : Simplicité et puissance pour MongoDB

Spring Data MongoDB, combiné à l'auto-configuration de Spring Boot, rend l'intégration de MongoDB dans vos applications Java remarquablement aisée. La configuration de la connexion est simple via les propriétés d'application. L'utilisation des interfaces MongoRepository permet de bénéficier d'implémentations automatiques pour les opérations CRUD et les requêtes dérivées, réduisant considérablement le code boilerplate. Pour les cas plus avancés, le MongoTemplate offre une porte d'accès flexible et puissante à l'ensemble des fonctionnalités de MongoDB. Cette combinaison permet aux développeurs de choisir le niveau d'abstraction approprié pour interagir efficacement avec leur base de données orientée documents.