Enfin ! Nous voilà arrivés au moment où l’on va commencer à coder, il faut reconnaître que ça commençait à nous démanger.
Mais pas si vite, avant d’agir il faut réfléchir ! Que devons-nous réaliser ?
Reprenons notre projet : réaliser une partie du backend de notre plateforme de blogging !
Nous souhaitons publier :
des articles au format court. Ils sont définis par un nom (le titre), un contenu et une date ;
des tutoriels : ce sont des articles dans un format plus long. Ils sont définis par un nom (le titre), un contenu, une courte description et une catégorie.
Nous souhaitons également :
que ces 2 types d’articles puissent être commentés par tout le monde en fournissant un pseudo avec le message ;
que chaque article/tutoriel possède une étiquette. Ainsi une recherche par mot clé permettra de retrouver un article ou tutoriel.
En termes de fonctionnalité, nous souhaitons évidemment consulter les articles, tutoriels et commentaires. Nous souhaitons également ajouter, modifier et supprimer un article ou un tutoriel. Quant aux commentaires, on se limitera pour l’instant à l’ajout uniquement.
Maintenant que le périmètre fonctionnel est défini, par quoi devons-nous commencer, techniquement ? Pour répondre à cette question, rappelons-nous ce que nous avons appris concernant MongoDB. Cette base de données utilise des documents pour représenter les données. Et ces derniers ne sont rien d’autres que des objets Java.
Notre première tâche technique est donc d’implémenter ces documents, c'est-à-dire coder les classes Java qui les représentent.
Implémentez les documents
Quelles classes devons-nous créer ?
Avec Spring Data MongoDB, il faut une classe par document. Donc, si nous gérons 2 documents : les articles et les tutoriels, il nous faudra 2 classes.
Je vous montre comment faire dans la démonstration ci-dessous :
Plutôt abordable, n’est-ce pas ? Reprenons le code ensemble :
package com.openclassrooms.blogdatalayer.model;
import java.util.Date;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
@Document(collection = "posts")
public class Post {
@Id
private String id;
private String name;
private String content;
private Date date;
// getters and setters
}Dans la démonstration, j’ai d’abord créé un sous-package nommé model, puis j’ai créé une classe nommée Post (qui signifie article de blog, en anglais). Cette classe doit être annotée @Document. Cette annotation mise à disposition par Spring Data MongoDB permet d’indiquer que la classe représente un document.
Nous pouvons indiquer le nom de la collection via l’attribut d’annotation de nom collection. Si on ne spécifie pas cet attribut, le nom de la classe sera utilisé comme nom de collection.
Chaque attribut de la classe représente une des caractéristiques du document. À noter que l’attribut de classe id est annoté @Id, indiquant ainsi qu’il représente l’identifiant unique du document.
MongoDB se sert de cet identifiant pour rendre chaque document unique. Petite particularité, le type est String. Nous pouvons aussi utiliser les types ObjectId et BigInteger pour gérer cet identifiant.
Le nom des caractéristiques du document est calqué sur le nom de l’attribut de la classe Java. Si vous souhaitez définir un nom différent pour la caractéristique du document, vous pouvez utiliser l’annotation @Field(“nom”), où nom peut être remplacé par la valeur de votre choix.
Pour exclure l’un des attributs de la classe afin qu’il ne soit pas interprété comme faisant partie de la structure du document, vous pouvez utiliser l’annotation @Transient.
À vous de jouer
Maintenant que vous savez comment implémenter un document, à vous de jouer ! Je vous laisse écrire la classe Tutorial.
Pour cela, sachez qu’un document Tutorial est composé des informations suivantes : id, name, shortDescription, content, category.
Vous avez fini ?
N’hésitez pas à vérifier votre travail en consultant le repository GitHub du cours à la branche p2c1. Il contient tous les documents implémentés.
Passons à la suite !
Implémentez l’interface Repository
Ce n’est pas tout d’avoir des classes qui représentent nos documents. Maintenant, nous devons être capables de les manipuler !
Et c’est à ce moment précis que Spring Data MongoDB va nous rendre plus efficaces !
C'est-à-dire ?
Certaines opérations pour manipuler nos documents ont déjà été implémentées et nous sont accessibles ! Pour tirer profit de ce code existant, il nous suffit d’utiliser une interface nommée MongoRepository. Laissez-moi vous montrer comment dans la démonstration ci-dessous :
On ne peut pas dire qu’on a écrit beaucoup de code, n’est-ce pas ?
Prenons tout de même le temps de l’analyser !
Voici l’interface PostRepository que nous avons créée dans un sous-package nommé repository :
package com.openclassrooms.blogdatalayer.repository;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;
import com.openclassrooms.blogdatalayer.model.Post;
@Repository
public interface PostRepository extends MongoRepository<Post, String> {
}Retenons 2 points :
Premièrement, l’interface est annotée @Repository. Cette annotation indique que la classe a pour rôle de communiquer avec une source de données (en l'occurrence, la base de données).
Deuxièmement, l’interface étend une autre interface nommée MongoRepository. Grâce à la généricité, on peut indiquer à cette dernière quel document on veut manipuler via l’interface, et également quel est le type de l’id du document.
Pourquoi faire ça ?
Lorsque l’application sera exécutée, Spring va fournir une implémentation de notre interface PostRepository, qui contiendra également l’implémentation des méthodes de l’interface mère MongoRepository. De ce fait, on accède à une liste de méthodes prêtes à l’emploi sans rien avoir à implémenter !
À vous de jouer
Écrivez l’interface pour Tutorial !
N’hésitez pas à vérifier votre travail en consultant le repository GitHub du cours à la branche p2c1. Il contient le code correspondant.
En résumé
Les documents sont modélisés via des classes Java.
Une classe Java qui représente un document est annoté @Document.
Spring Data MongoDB fournit une interface nommée MongoRepository et des opérations déjà implémentées.
Pour tirer profit de MongoRepository, il faut créer une interface qui étend cette dernière, et spécifier le document qui sera manipulé.
Maintenant que vous avez implémenté vos documents et l’interface repository, suivez-moi dans le chapitre suivant pour implémenter une lecture de données.
