• 10 heures
  • Difficile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 20/12/2021

Ajoutez vos données en BDD (CREATE)

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Maintenant que vous avez récupéré des données avec Spring Data MongoDB, attaquons-nous à l’opération CREATE du CRUD, de manière à ajouter de nouvelles données en BDD. Mais qu’est-ce qui nous motive à implémenter une insertion de données ?

Encore une fois, c’est le besoin fonctionnel ! Notre plateforme de blogging doit pouvoir vivre ! Autrement dit, nous devons pouvoir y ajouter de nouveaux articles de blogs, de nouveaux tutoriels. La réponse technique à cette nécessité fonctionnelle est donc de pouvoir ajouter une nouvelle donnée en BDD. Alors c’est parti ! Voyons ensemble comment faire.

Ajoutez des données simples

Pour insérer une nouvelle donnée en BDD, nous allons encore une fois nous reposer sur les opérations déjà implémentées de Spring Data MongoDB.

Retournez faire un tour dans la documentation de cette interface. Consultez la liste des méthodes et identifiez celle qui correspondrait à une insertion de données. Vous avez trouvé ? Super !

Deux méthodes attirent notre attention :

  • insert(S entity) ;

  • insert(Iterable<S> entities).

Les deux méthodes ont le même but : ajouter des informations en BDD. Cependant, l’une se concentre sur l’ajout d’un élément unitaire, et l’autre sur l’ajout d’un ensemble d'éléments.

Utilisez insert(S entity) pour ajouter un élément unitaire

Observez le code ci-dessous :

@Override
public void run(String... args) throws Exception {
Post newP = new Post();
newP.setName("My new blog post");
newP.setDate(new Date());
newP.setContent("A new blog post, amazing!");
postRepository.insert(newP);
}

Nous nous retrouvons encore une fois dans la méthode run de la classe BlogDataLayerApplication.

J’ai créé un nouvel objet de type Post nommé newP. Grâce aux méthodes pour modifier les attributs (setter), j’ai défini les valeurs de ce post (son nom, sa date et son contenu).

Puis, j’ai appelé la méthode insert() de la classe PostRepository, en fournissant l’objet préalablement créé en paramètre.

Et c’est tout ! Le nouvel article a été ajouté à notre base de données. Vérifiez que c’est bien le cas en récupérant la liste des articles.

De nouveau, Spring Data MongoDB se révèle performant, nous n’avons pas eu à implémenter la méthode insert.

Utilisez insert(Iterable<S> entities) pour insérer plusieurs éléments

Pour insérer plusieurs éléments simultanément, observez le code ci-dessous :

@Override
public void run(String... args) throws Exception {
Post newP1 = new Post();
newP1.setName("Welcome on board!");
newP1.setDate(new Date());
newP1.setContent("My blog is really useful !");
Post newP2 = new Post();
newP2.setName("See you soon");
newP2.setDate(new Date());
newP2.setContent("I will be back soon - going on holidays!");
postRepository.insert(List.of(newP1, newP2));

Dans ce code, j’ai créé 2 nouveaux articles. Grâce à la méthode List.of(), j’ai ajouté ces articles dans une List que j’ai passée en paramètre de la méthode insert().

À vous de jouer

Exercez-vous en ajoutant un nouveau tutoriel, puis plusieurs tutoriels simultanément.

Retrouvez le corrigé de cet exercice dans le repository GitHub indiqué à la fin du chapitre.

Ajoutez des données complexes

Réfléchissons à un nouveau besoin fonctionnel. Lorsque nous créons un nouvel article ou un nouveau tutoriel, nous souhaitons lui associer une (et une seule) étiquette (ou tag, en anglais). Cette étiquette pourra être utilisée comme critère de recherche lorsqu’un lecteur recherche un article ou un tutoriel.

Seulement voilà, l’étiquette n’est pas une simple chaîne de caractères. Nous souhaitons lui donner les caractéristiques suivantes :

  • un nom ;

  • un slug (c’est un label court unique pour chaque étiquette) ;

  • une description.

Par exemple :

  • Nom : Spring Data MongoDB.

  • Slug : spring-data-mongodb.

  • Description : Module Spring Data MongoDB du framework Spring pour l'interaction avec une base MongoDB.

Ou bien encore :

  • Nom : Hibernate.

  • Slug : hibernate.

  • Description : Framework ORM pour l'interaction avec des bases de données en Java.

Comment implémenter ce Tag et l’associer à notre document Post ou Tutorial ?

MongoDB nous encourage à penser en “objet”. Ça tombe bien, en tant que développeurs Java, c’est notre spécialité ! Comment feriez-vous pour intégrer le Tag à l’objet Post ou à l’objet Tutorial ?

Moi, je commencerais par créer une nouvelle classe nommée Tag.
Puis, tant dans la classe Post que Tutorial, j’ajouterais un nouvel attribut de classe nommé tag de type Tag.

Houlà houlà, d’accord mais comment MongoDB va gérer ça ? Pour l’instant, nous avons vu uniquement des documents qui ont des attributs de types existants, comme la chaîne de caractères ou une date.

Vous avez raison, nous n’avons pas encore manipulé ce type de structure d’objet. Nous sommes en train d’imbriquer un objet dans un autre.
Mais rassurez-vous, MongoDB sait très bien le gérer, grâce aux documents imbriqués

En fait, MongoDB considère l’objet Tag comme un document. Et ce document est tout simplement à l’intérieur d’un autre document.

Allez, rejoignez-moi dans la démonstration ci-dessous, je vous montre comment implémenter l’ajout d’une donnée plus complexe : un document imbriqué.

Reprenons le code ensemble. Tout d’abord la classe Tag :

package com.openclassrooms.blogdatalayer.model;
public class Tag {
private String name;
private String slug;
private String description;
// getters and setters
}

Le seul point à noter est que je n’ai pas eu à ajouter l’annotation @Document. Ce n’est pas nécessaire pour les documents imbriqués.

Maintenant la classe Post :

package com.openclassrooms.blogdatalayer.model;
import java.util.Date;
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;
// Getters and setters
// toString
}

J’ai ici ajouté l’attribut de classe “private Tag tag;”, le getter et le setter. Et j’ai généré la méthode toString.

Terminons par les opérations au sein de la méthode run() de la classe BlogDataLayerApplication :

@Override
public void run(String... args) throws Exception {
Tag springTag = new Tag();
springTag.setName("Spring Framework");
springTag.setSlug("spring-framework");
springTag.setDescription("Spring is the most popular Java Framework in the world.");
Post newPost = new Post();
newPost.setName("Spring Framework Presentation");
newPost.setDate(new Date());
newPost.setContent("Let me introduce you to the awesome Spring Framework!");
newPost.setTag(springTag);
postRepository.insert(newPost);
List<Post> posts = postRepository.findAll();
posts.stream().forEach((post) -> logger.info(post.toString()));
}

Ce code peut être analysé en 4 étapes :

  1. Création de l’objet Tag.

  2. Création de l’objet Post. Le tag précédemment créé est inséré dans ce post grâce à la méthode setTag().

  3. Insertion du post dans la base de données.

  4. Récupération de tous les posts de la base de données.

Je souhaite mettre en avant qu’ici j’utilise la méthode insert exactement de la même façon que dans la section précédente de ce chapitre. La leçon est la suivante : ce n’est pas parce qu’on complexifie la structure de nos documents que la manipulation des documents en question se complexifie. Et ça, c’est une excellente nouvelle !

Observez la structure du JSON généré pour ce document :

{
"_id":{"$oid":"618273e087deb21060318688"},
"name":"Spring Framework Presentation",
"content":"Let me introduce you to the awesome Spring Framework !"
,"date":{"$date":"2021-11-03T11:34:56.564Z"},
"tag":
{"name":"Spring Framework",
"slug":"spring-framework",
"description":"Spring is the most popular Java framework in the world."},
"_class":"com.openclassrooms.blogdatalayer.model.Post"
}

Nous observons clairement que les 3 informations du document Tag sont imbriquées dans le document Post.

À vous de jouer

À vous d'ajouter un tag aux tutoriels. Vous pouvez suivre la même méthodologie que celle que j’ai présentée dans cette section.

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

En résumé

  • Spring Data MongoDB implémente déjà l’opération CREATE grâce à la méthode insert().

  • La méthode insert() est capable d’ajouter tant une donnée unitaire qu’un ensemble de données.

  • Les opérations permettant d’implémenter une donnée complexe (document imbriqué) sont les mêmes que pour une donnée simple.

Envie de savoir comment modifier et supprimer vos données existantes ? Retrouvez-moi dans le chapitre qui suit !

Exemple de certificat de réussite
Exemple de certificat de réussite