Utilisez Spring Data MongoDB pour interagir avec des bases de données NoSQL

La couche d’accès aux données de notre plateforme de blogging est de plus en plus opérationnelle. Nous savons récupérer nos données et les insérer.

Nous sommes désormais face à deux nouveaux besoins fonctionnels :

• Mettre à jour un article ou un tutoriel existant (vous savez, à cause de la petite faute d’orthographe qu’on a laissé traîner !).

• Supprimer un article ou un tutoriel existant (au cas où les informations seraient dépassées au vu des dernières évolutions). 

Découvrez avec moi comment réaliser ces opérations !

Utilisez la méthode save() pour mettre à jour vos données

Commençons ensemble par la mise à jour de nos données. Cela implique 3 étapes :

1. Accéder au document qu’on souhaite modifier. Et ça, vous avez déjà appris à le faire.

2. Modifier le document. Ce dernier étant un objet Java, il suffit de modifier la valeur des attributs de ce dernier. Et ça aussi, vous savez le faire.

3. Sauvegarder cette modification en base de données. C’est ça que je vais vous apprendre !

La clé de la sauvegarde est de connaître la bonne méthode pour le faire, et c’est de nouveau Spring qui va nous la fournir, grâce à la méthode save().

Observez le code ci-dessous :

     @Override
     public void run(String... args) throws Exception {

          // Creating a Post object with the name we are looking for
          Post existingPost = new Post();
          existingPost.setName("Welcome !");
          Example<Post> example = Example.of(existingPost);

          // Getting the searched Post
          existingPost = postRepository.findOne(example).get();

          // Building a new name and updating the object Post
          String newName = existingPost.getName() + " [updated]";
          existingPost.setName(newName);

          // Saving this change in database
          postRepository.save(existingPost);
     }

J’ai décomposé ce code en 4 blocs :

Premièrement, je crée un objet Post avec le nom qui correspond à l’article que je souhaite récupérer.

Deuxièmement, je récupère le Post complet via la méthode findOne. Je vous ai expliqué ce fonctionnement dans le chapitre 2 de la partie 2.

Troisièmement, je modifie le nom de mon article en changeant l’attribut name de l’objet.

Quatrièmement, je sauvegarde ce changement en base de données grâce à la méthode save(). Cette méthode prend l’objet à sauvegarder en paramètre.

Vous pouvez ensuite vérifier que la modification a bien eu lieu.

Il est très intéressant de comprendre plus précisément le fonctionnement de la méthode save(). Cette dernière se comporte en réalité comme un upsert. Cela signifie qu’elle gère tant la création que la mise à jour. 

Le comportement est le suivant : si l’objet existe, alors il est mis à jour, sinon il est créé.

En quelque sorte oui ! Mais gardez à l’esprit que l’avantage de la méthode insert est qu’elle retourne une erreur si on essaie d’ajouter un élément qui existe déjà. Elle est donc plus restrictive, et empêchera une mise à jour involontaire d’un élément existant, alors que nous voulions en créer un nouveau.

À vous de jouer

• Implémentez une mise à jour pour un tutoriel de votre choix. 

• Vérifiez que la mise à jour a bien été sauvegardée, en consultant le tutoriel en question.

N’hésitez pas à vérifier votre travail en consultant le repository GitHub du cours à la branche p3c2. Il contient le code correspondant pour tout ce chapitre.

Mettez à jour un document et ses documents imbriqués

Étant donné que nous sommes dans le cadre de la mise à jour d’un document, je vais vous montrer comment répondre à un autre besoin fonctionnel. Notre plateforme de blogging doit permettre d’écrire des commentaires sous les articles et les tutoriels.

Il est intéressant de noter qu’un commentaire pourra être ajouté uniquement si un article existe déjà.

Oui le commentaire est nouveau, mais la structure de nos documents fait qu’il s’agit en réalité d’une modification de l’article.

Eh bien comme nous l’avons vu dans le chapitre précédent avec le tag qui est un document imbriqué, les commentaires sont des documents imbriqués au sein du document Post.

Par voie de conséquence, ajouter un commentaire signifie modifier le document. C’est la raison pour laquelle on doit traiter cela comme une modification et non comme un ajout !

Vous souvenez-vous de la leçon que je vous ai apprise dans le chapitre précédent ? Je cite : “Ce n’est pas parce qu’on complexifie la structure de nos documents que la manipulation des documents en question se complexifie.”

Eh bien, ça sera pareil pour mettre à jour un article avec de nouveaux commentaires. Nous utiliserons la méthode save() comme nous l'avons fait auparavant. Regardez cela dans la démonstration suivante :

Reprenons ensemble le code ! D’abord je crée une classe Comment :

package com.openclassrooms.blogdatalayer.model;

public class Comment {

     private String pseudo;
     private String content;
     // getters et setters
}

Puis je modifie la classe Post :

package com.openclassrooms.blogdatalayer.model;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

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

@Document(collection = "posts")
public class Post {

     @Id
     private String id;
     @Indexed(unique = true)
     private String name;
     private String content;
     private Date date;
     private Tag tag;
     private List<Comment> comments = new ArrayList<>();
     // getters, setters, toString
}

Enfin, terminons par la méthode run() :

     @Override
     public void run(String... args) throws Exception {

          // Creating a comment
          Comment newComment = new Comment();
          newComment.setPseudo("your fan");
          newComment.setContent("This blog is amazing!");

          // Creating a Post object with the name which we are looking for
          Post existingPost = new Post();
          existingPost.setName("Spring Framework Presentation");
          Example<Post> example = Example.of(existingPost);

          // Getting the searched Post
          existingPost = postRepository.findOne(example).get();
          // Adding the new comment
          existingPost.getComments().add(newComment);

          // Saving this change in database
          postRepository.save(existingPost);
     }

J’ai commencé par créer un nouvel objet : Comment. Dans la pratique, les données du commentaire seront issues de la saisie d’un utilisateur.

J’ai ensuite récupéré l’article concerné par le commentaire.

J’ai ajouté le commentaire aux commentaires de l’article avec la ligne : existingPost.getComments().add(newComment); 

Comme les commentaires sont au sein de l’objet Post via une ArrayList, il suffit d’utiliser la méthode add() pour ajouter le commentaire à la liste existante.

J’ai terminé en appelant tout simplement la méthode save() expliquée précédemment dans ce chapitre.

En résumé

• La méthode save() permet de mettre à jour vos documents.

• Cette méthode se comporte comme un upsert : si le document existe, il est mis à jour, sinon il est créé.

Nous avons terminé cette section, attaquons-nous maintenant à la dernière opération : la suppression de données !