Utilisation de `MongoRepository` et `MongoTemplate`

Deux approches pour interagir avec MongoDB

Une fois votre application Spring Boot configurée pour se connecter à MongoDB via le starter spring-boot-starter-data-mongodb, Spring Data MongoDB vous offre principalement deux façons d'interagir avec votre base de données :

1. MongoRepository : Une approche de haut niveau, basée sur l'abstraction Repository de Spring Data. Elle est idéale pour les opérations CRUD standard et les requêtes simples basées sur les propriétés de vos documents.
2. MongoTemplate : Une approche de plus bas niveau, offrant un contrôle plus fin et l'accès à l'ensemble des fonctionnalités du driver MongoDB. Elle est utilisée pour les requêtes complexes, les opérations d'agrégation, les mises à jour spécifiques, etc.

Comprendre quand et comment utiliser chacune de ces approches est essentiel pour développer efficacement des applications utilisant MongoDB avec Spring Boot.

MongoRepository : Simplicité et productivité pour les opérations courantes

MongoRepository est l'outil de prédilection pour démarrer rapidement et gérer les interactions de base avec vos collections MongoDB. C'est une interface que vous définissez dans votre code, héritant de MongoRepository (qui elle-même étend PagingAndSortingRepository et CrudRepository). Spring Data se charge de fournir automatiquement une implémentation concrète au moment de l'exécution.

Avantages :

• Réduction du code boilerplate : Les méthodes CRUD de base (save, findById, findAll, deleteById, count, etc.) sont fournies gratuitement.
• Requêtes dérivées (Query Methods) : Vous pouvez définir des requêtes personnalisées simplement en nommant vos méthodes d'interface selon des conventions spécifiques (ex: findByNameAndCategory, findByPriceBetween). Spring Data MongoDB analysera le nom de la méthode et générera la requête MongoDB correspondante.
• Support de la pagination et du tri : Hérite des fonctionnalités de PagingAndSortingRepository pour gérer facilement les résultats paginés et triés.
• Facilité d'utilisation : Très simple à mettre en place et à utiliser pour les cas courants.

Exemple d'utilisation :

1. Définir l'entité (Document) :

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

@Document(collection = "products")
public class Product {
    @Id
    private String id;
    private String name;
    private String category;
    private Double price;
    private List tags;

    // Constructeurs, Getters, Setters...
}

2. Créer l'interface Repository :

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.repository.MongoRepository;
import java.util.List;

public interface ProductRepository extends MongoRepository {

    // Requête dérivée: Trouver par catégorie
    List findByCategory(String category);

    // Requête dérivée: Trouver par nom contenant (insensible à la casse)
    List findByNameContainingIgnoreCase(String nameFragment);

    // Requête dérivée: Trouver par prix inférieur à et trié par nom ascendant
    List findByPriceLessThanOrderByNameAsc(Double maxPrice);

    // Support de la pagination
    Page findByTags(String tag, Pageable pageable);

}

3. Injecter et utiliser dans un service :

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

@Service
public class ProductService {
    @Autowired
    private ProductRepository repository;

    public Product saveProduct(Product p) {
        return repository.save(p);
    }

    public List getProductsByCategory(String category) {
        return repository.findByCategory(category);
    }
    // ... autres méthodes utilisant le repository ...
}

MongoTemplate : Contrôle fin et fonctionnalités avancées

Lorsque les capacités des repositories (méthodes CRUD et requêtes dérivées) ne suffisent plus, ou lorsque vous avez besoin d'un contrôle plus précis sur les opérations MongoDB, le MongoTemplate entre en jeu. Il s'agit d'une classe centrale de Spring Data MongoDB qui fournit une API synchrone, riche et de plus bas niveau pour interagir avec MongoDB. Spring Boot configure automatiquement un bean MongoTemplate prêt à être injecté.

Avantages :

• Accès complet à l'API MongoDB : Permet d'utiliser des critères de requête complexes (Criteria API), des projections (sélectionner des champs spécifiques), des opérations de mise à jour ciblées (avec des opérateurs comme $set, $inc, $push), des opérations d'agrégation (Aggregation Framework), des requêtes géospatiales, etc.
• Contrôle précis : Vous construisez explicitement les requêtes et les opérations de mise à jour.
• Gestion des conversions : S'occupe de la conversion entre vos objets Java et les BSON Documents de MongoDB.
• Gestion des exceptions : Traduit les exceptions spécifiques au driver MongoDB en exceptions non-cochées de la hiérarchie Spring DataAccessException.

Exemple d'utilisation :

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.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
import com.mongodb.client.result.UpdateResult;
import java.util.List;

@Service
public class AdvancedProductService {

    @Autowired
    private MongoTemplate mongoTemplate;

    // Trouver des produits avec des critères complexes
    public List findProductsComplex(String namePattern, Double minPrice, String requiredTag) {
        Query query = new Query();
        query.addCriteria(
            Criteria.where("name").regex(namePattern, "i") // Regex insensible à la casse
                    .and("price").gte(minPrice)
                    .and("tags").is(requiredTag) // Vérifie si le tag est dans le tableau
        );
        // Spécifier les champs à retourner (projection)
        query.fields().include("name").include("price").exclude("id");

        return mongoTemplate.find(query, Product.class);
    }

    // Mettre à jour le prix d'un produit spécifique
    public boolean updateProductPrice(String productId, Double newPrice) {
        Query query = new Query(Criteria.where("id").is(productId));
        Update update = new Update().set("price", newPrice);
        
        UpdateResult result = mongoTemplate.updateFirst(query, update, Product.class);
        return result.wasAcknowledged() && result.getModifiedCount() > 0;
    }

    // Incrémenter un compteur (exemple hypothétique)
    // public void incrementProductViews(String productId) {
    //    Query query = new Query(Criteria.where("id").is(productId));
    //    Update update = new Update().inc("viewCount", 1);
    //    mongoTemplate.updateFirst(query, update, Product.class);
    // }
}

MongoRepository vs MongoTemplate : Quand utiliser quoi ?

Le choix entre MongoRepository et MongoTemplate dépend du besoin :

• Utilisez MongoRepository pour :
  • Les opérations CRUD standard (Create, Read, Update, Delete).
  • Les requêtes simples basées sur les propriétés des documents (requêtes dérivées).
  • La pagination et le tri simples.
  • Une productivité rapide et moins de code boilerplate pour les cas courants.
• Utilisez MongoTemplate pour :
  • Les requêtes avec des critères complexes ou multiples opérateurs logiques ($or, $and, $not).
  • Les requêtes utilisant des opérateurs MongoDB spécifiques ($regex, $in, $elemMatch, géospatial, etc.).
  • Les projections de champs (ne retourner que certains champs).
  • Les opérations de mise à jour ciblées ($set, $inc, $push, $pull, etc.).
  • Le framework d'agrégation de MongoDB.
  • Les opérations en masse (insertAll, bulkOps).
  • Un contrôle plus fin sur les options de requête (ex: read preference, write concern - bien que souvent configurable globalement).

Il est tout à fait courant et même recommandé d'utiliser les deux dans la même application. Utilisez MongoRepository pour la majorité des opérations simples et injectez MongoTemplate (ou créez des méthodes personnalisées dans un repository implémenté avec MongoTemplate) pour les quelques opérations plus complexes qui le nécessitent.

Conclusion : Deux outils complémentaires pour MongoDB

Spring Data MongoDB fournit avec MongoRepository et MongoTemplate deux outils puissants et complémentaires pour interagir avec MongoDB depuis Spring Boot. MongoRepository offre une abstraction de haut niveau idéale pour la productivité et les opérations courantes, tandis que MongoTemplate donne accès à la pleine puissance et à la flexibilité de MongoDB pour les cas d'utilisation avancés. En comprenant les forces de chacun, les développeurs peuvent choisir l'outil approprié pour chaque tâche, résultant en un code d'accès aux données à la fois efficace et maintenable.