Geekly articles weekly

Présentation de Spring Data MongoDB

Bonne journée à tous!

Le tout nouveau volet «Developer on the Spring Framework» a commencé, «soudainement», ce cours s'est avéré très populaire parmi les nouveaux étudiants et ceux qui nous ont déjà désappris en Java et en entreprise «ordinaires». Donc, si c'est intéressant, venez nous voir pour des leçons ouvertes et, bien sûr, partagez du matériel intéressant sur le sujet.

Traduction du tutoriel Spring Data MongoDB
Publié par Anand Kumar

C'est parti!

Dans le monde d'aujourd'hui, il est très important de créer et d'exécuter l'application dès que possible. De plus, l'application doit être facile à développer et à entretenir.

Spring est un tel framework qui facilite l'intégration avec de nombreux autres frameworks différents, ce qui simplifie le développement d'applications à l'aide de Spring. Une telle intégration est l'intégration de Spring avec MongoDB.



1. Introduction

Dans cette leçon, nous discuterons d'une combinaison du framework Java Spring le plus célèbre et du plus célèbre système de gestion de base de données NoSQL (SGBD) MongoDB. MongoDB est un SGBD NoSQL orienté document qui stocke les données dans un format similaire à JSON.
L'intégration de Spring Data et MongoDB est fournie par Spring pour faciliter l'interaction des deux et la commodité des développeurs, éliminant ainsi la nécessité d'écrire de nombreuses requêtes pour l'insertion, la mise à jour et la suppression.

Voici quelques-unes des fonctionnalités fournies par le projet Spring Data MongoDB:

  1. Spring Data vous permet d'utiliser à la fois la classe @Configuration et la configuration XML.
  2. La hiérarchie d'exceptions Data Access Spring est utilisée pour traduire l'exception.
  3. Mappage intégré entre les POJO Java et un document MongoDB.
  4. La classe MongoTemplate, qui simplifie l'utilisation des opérations MongoDB courantes.
  5. En plus de MongoTemplate, vous pouvez utiliser les classes MongoReader et MongoWriter pour un rendu de bas niveau.

La meilleure façon de comprendre n'importe quelle technologie est de l'utiliser dans la pratique, et c'est exactement ce que nous allons faire maintenant.

Créons un programme simple pour en savoir plus sur Spring Data MongoDB.

2. Technologies et outils

Examinons les technologies et les outils que nous utiliserons pour créer le programme.

  1. Eclispe Oxygen.2 Release (4.7.2)
  2. Java - version 9.0.4
  3. Gradle - 4.6
  4. Serveur MongoDB - 3.6
  5. MongoCompass - 3.6
  6. SpringDataMongoDB - 2.0.5-RELEASE

3. Structure du projet

La structure de notre projet ressemblera à celle ci-dessous.


Structure du projet pour Spring Data MongoDB

Le projet Gradle aura la structure indiquée ci-dessus. Dans le cas de pom.xml, la structure du projet sera légèrement différente.

4. Le programme

Dans le cadre de ce programme, nous essaierons d'effectuer les tâches ci-dessous.

  1. Enregistrement d'un objet dans MongoDB
  2. Mise à jour d'un objet dans MongoDB
  3. Supprimer un objet de MongoDB
  4. Récupérer tous les objets de MongoDB

Analysons maintenant tous les composants du programme. Tout d'abord, nous allons commencer par les dépendances et les fichiers jar nécessaires au programme.

4.1 gradle

Nous utilisons Gradle pour construire dans le cadre du programme. Le fichier build.gradle ressemblera à celui illustré ci-dessous.

 apply plugin: 'java' repositories { mavenCentral() } dependencies { compile group: 'org.springframework.data', name: 'spring-data-mongodb', version: '2.0.5.RELEASE' implementation 'com.google.guava:guava:23.0' testImplementation 'junit:junit:4.12' }

Dans le fichier build.gradle - build.gradle , la ligne apply plugin: 'java' indique le plug-in à installer. Dans notre cas, il s'agit d'un plugin Java.

La balise repositories{} indique le référentiel à partir duquel les dépendances doivent être extraites. Nous avons choisi mavenCentral pour extraire les fichiers jar dépendants. Nous pouvons également utiliser jcenter pour afficher les fichiers jar dépendants correspondants.

La balise dependencies {} est utilisée pour fournir les données nécessaires sur les fichiers jar qui doivent être extraits pour le projet.

4.2 Configuration pour MongoDB

Pour utiliser la configuration MongoDB, nous devons implémenter la classe AbstractMongoConfiguration . La classe MongoConfig.java ressemblera à celle illustrée ci-dessous. Ici, nous utilisons des annotations au lieu de xml. Mais XML peut également être utilisé pour configurer la configuration.

Implémentation de la classe MongoConfig.java

 package com.tutorial.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.mongodb.config.AbstractMongoConfiguration; import com.mongodb.MongoClient; @Configuration public class MongoConfig extends AbstractMongoConfiguration { @Override public String getDatabaseName() { return "local"; } @Override @Bean public MongoClient mongoClient() { return new MongoClient("127.0.0.1"); } }

@Configuration utilisé pour définir la classe MongoConfig.java comme classe de configuration. @Bean définit le MongoClient .

4.3 Classe de modèle

Considérons maintenant la classe du modèle. Nous utilisons student.java comme classe modèle qui contient des attributs pour Student, tels que le nom et l'âge. La Student.java modèle Student.java Student.java utilisée pour mapper les POJO à la collection MongoDB.

Classe modèle étudiant

 package com.tutorial.model; import org.springframework.data.annotation.Id; import org.springframework.data.mongodb.core.mapping.Document; @Document(collection = "students") public class Student { public Student(String studentName, int studentAge) { this.studentName = studentName; this.studentAge = studentAge; } @Id private String id; String studentName; int studentAge; public String getStudentName() { return studentName; } public void setStudentName(String studentName) { this.studentName = studentName; } public int getStudentAge() { return studentAge; } public void setStudentAge(int studentAge) { this.studentAge = studentAge; } @Override public String toString() { return String.format( "Student[id=%s, studentName='%s', studentAge="+studentAge+"]", id, studentName); } }

@Document définit un document. La propriété de collection détermine la collection qui sera utilisée pour correspondre à la collection. Tous les attributs référencés comme faisant partie de la collection doivent être accessibles dans la classe POJO. @Id définit l'identifiant de la collection.

4.4 Opérations CRUD

Pour effectuer des opérations CRUD (abréviation de créer, lire, mettre à jour, supprimer), telles que l'enregistrement, la mise à jour, la suppression et la récupération de données de MongoDB, nous utiliserons MongoOperations .

Examinons maintenant la classe MongoDBPOperations.java . Cette classe contient l'implémentation de toutes les méthodes d'opérations CRUD.

La classe MongoDBPOperations qui sera utilisée pour effectuer des opérations CRUD

 package com.tutorial; import java.util.List; import org.springframework.data.mongodb.core.MongoOperations; 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 com.tutorial.model.Student; public class MongoDBPOperations { public void saveStudent(MongoOperations mongoOperation, Student student) { mongoOperation.save(student); System.out.println("Student saved successfully"); // student object got created with id. System.out.println("student : " + student); } public void searchStudent(MongoOperations mongoOperation, String critera,String value) { // query to search student Query searchStudent = new Query(Criteria.where(critera).is(value)); // find student based on the query Student resultStudent = mongoOperation.findOne(searchStudent, Student.class); System.out.println("Student found!!"); System.out.println("Student details: " + resultStudent); } public void updateStudent(MongoOperations mongoOperation, String critera,String value, String updateCriteria, String updateValue) { // query to search student Query searchStudent = new Query(Criteria.where(critera).is(value)); mongoOperation.updateFirst(searchStudent, Update.update(updateCriteria, updateValue), Student.class); System.out.println("Student got updated successfully"); } public void getAllStudent(MongoOperations mongoOperation) { List listStudent = mongoOperation.findAll(Student.class); for(Student student:listStudent) { System.out.println("Student = " + student); } } public void removeStudent(MongoOperations mongoOperation, String critera,String value) { Query searchStudent = new Query(Criteria.where(critera).is(value)); mongoOperation.remove(searchStudent, Student.class); System.out.println("Student removed successfully!! "); } }

La classe la plus importante d'un programme Java est la classe qui contient la méthode main .

4.5 Classe d'application

La classe principale qui contient la méthode principale est la classe Application.java . Nous utiliserons cette classe pour appeler des méthodes de la classe MongoDBPOperations .

Classe d'application pour appeler les méthodes de la classe MongoDBPOperations

 package com.tutorial; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.data.mongodb.core.MongoOperations; import com.tutorial.config.MongoConfig; import com.tutorial.model.Student; public class Application { public static void main (String[] args) { // For Annotation ApplicationContext ctx = new AnnotationConfigApplicationContext(MongoConfig.class); MongoOperations mongoOperation = (MongoOperations) ctx.getBean("mongoTemplate"); MongoDBPOperations ops = new MongoDBPOperations(); Student student = new Student("John", 15); //save student ops.saveStudent(mongoOperation, student); // get student based on search criteria ops.searchStudent(mongoOperation, "studentName", "John"); //update student based on criteria ops.updateStudent(mongoOperation, "StudentName", "John", "studentAge", "18"); // get student based on search criteria ops.searchStudent(mongoOperation, "studentName", "John"); // get all the students ops.getAllStudent(mongoOperation); //remove student based on criteria ops.removeStudent(mongoOperation, "studentName", "John"); // get all the students ops.getAllStudent(mongoOperation); } }

Examinons pas à pas les opérations effectuées dans la classe Application.java :

  1. Nous créons un ApplicationContext . Cela est dû à la nécessité de télécharger la configuration.
  2. De plus, un objet MongoOperations été MongoOperations pour charger le composant MongoTemplate .
  3. L'objet MongoDBOperations permet d'accéder aux méthodes permettant d'effectuer diverses opérations MongoOperation .
  4. De plus, un objet Etudiant a été créé avec le nom John et l'âge de 15 ans.
  5. Nous appelons la méthode saveMethod de la classe saveMethod et passons les paramètres nécessaires pour enregistrer l'objet dans la base de données.
  6. De la même manière, nous appelons les différentes méthodes MongoDBOperations une par une.

4.6 Démarrage du programme

Enfin, exécutons maintenant le programme en tant qu'application Java. Cliquez avec le bouton droit sur Application.java -> Exécuter en tant que -> Application Java.

Le résultat suivant apparaîtra dans la console.


Sortie de la console après le démarrage du programme

Maintenant, commentons la commande pour supprimer l'objet. MongoDB stockera avec succès les données.

Également, commentons la ligne pour supprimer l'objet, comme indiqué ci-dessous.

Application de classe après avoir commenté les méthodes de suppression

 package com.tutorial; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.data.mongodb.core.MongoOperations; import com.tutorial.config.MongoConfig; import com.tutorial.model.Student; public class Application { public static void main (String[] args) { // For Annotation ApplicationContext ctx = new AnnotationConfigApplicationContext(MongoConfig.class); MongoOperations mongoOperation = (MongoOperations) ctx.getBean("mongoTemplate"); MongoDBPOperations ops = new MongoDBPOperations(); Student student = new Student("John", 15); //save student ops.saveStudent(mongoOperation, student); // get student based on search criteria ops.searchStudent(mongoOperation, "studentName", "John"); //update student based on criteria ops.updateStudent(mongoOperation, "StudentName", "John", "studentAge", "18"); // get student based on search criteria ops.searchStudent(mongoOperation, "studentName", "John"); // get all the students ops.getAllStudent(mongoOperation); //remove student based on criteria //ops.removeStudent(mongoOperation, "studentName", "John"); // get all the students //ops.getAllStudent(mongoOperation); } }

Après avoir apporté des modifications au programme, redémarrons-le. Ce qui suit apparaît dans la console.


Console lorsque l'opération de suppression est mise en commentaire

À la suite des commentaires sur la commande de suppression, MongoDB stockera les données et ressemblera donc à celle illustrée ci-dessous.


Sortie MongoDB après la commande save and update

5. Téléchargez le projet Eclipse

Vous pouvez télécharger l'intégralité du code source de cet exemple ici.

LA FIN

Comme toujours, nous attendons des questions et des commentaires ici ou allons à Yuri pour une leçon ouverte où vous pouvez non seulement écouter, mais aussi demander autour.

Source: https://habr.com/ru/post/fr430520/

More articles:


All Articles