Geekly articles weekly

Einführung in Spring Data MongoDB

Guten Tag an alle!

Der brandneue Stream "Developer on the Spring Framework" wurde "plötzlich " gestartet. Dieser Kurs erwies sich sowohl bei neuen Studenten als auch bei denen, die bereits von uns in "normalem" Java und Enterprise verlernt haben, als sehr beliebt. Wenn es also interessant ist, kommen Sie zu uns, um offenen Unterricht zu erhalten , und teilen Sie natürlich interessante Materialien zu diesem Thema.

Spring Data MongoDB Tutorial Übersetzung
Gepostet von Anand Kumar

Lass uns gehen!

In der heutigen Welt ist es sehr wichtig, die Anwendung so schnell wie möglich zu erstellen und auszuführen. Außerdem sollte die Anwendung leicht zu entwickeln und zu warten sein.

Spring ist ein solches Framework, das eine einfache Integration in viele andere Frameworks ermöglicht und die Anwendungsentwicklung mit Spring vereinfacht. Eine solche Integration ist die Integration von Spring in MongoDB.



1. Einleitung

In dieser Lektion werden wir eine Kombination aus dem bekanntesten Spring Java Framework und dem bekanntesten NoSQL Database Management System (DBMS) MongoDB diskutieren. MongoDB ist ein dokumentorientiertes NoSQL-DBMS, das Daten in einem JSON-ähnlichen Format speichert.
Die Integration von Spring Data und MongoDB wird von Spring bereitgestellt, um die Interaktion zwischen beiden und den Komfort für Entwickler zu erleichtern, sodass nicht mehr viele Abfragen zum Einfügen, Aktualisieren und Löschen geschrieben werden müssen.

Im Folgenden sind einige der Funktionen aufgeführt, die vom Spring Data MongoDB-Projekt bereitgestellt werden:

  1. Mit Spring Data können Sie sowohl die @ Configuration-Klasse als auch die XML-Konfiguration verwenden.
  2. Die Data Access Spring-Ausnahmehierarchie wird zum Übersetzen der Ausnahme verwendet.
  3. Integrierte Zuordnung zwischen Java POJOs und einem MongoDB-Dokument.
  4. Die MongoTemplate-Klasse, die die Verwendung gängiger MongoDB-Operationen vereinfacht.
  5. Zusätzlich zu MongoTemplate können Sie die Klassen MongoReader und MongoWriter für das Rendern auf niedriger Ebene verwenden.

Der beste Weg, eine Technologie zu verstehen, besteht darin, sie in der Praxis einzusetzen, und genau das werden wir jetzt tun.

Lassen Sie uns ein einfaches Programm erstellen, um mehr über Spring Data MongoDB zu erfahren.

2. Technologien und Werkzeuge

Schauen wir uns die Technologien und Tools an, mit denen wir das Programm erstellen.

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

3. Projektstruktur

Die Struktur unseres Projekts sieht wie folgt aus.


Projektstruktur für Spring Data MongoDB

Das Gradle-Projekt hat die oben gezeigte Struktur. Im Fall von pom.xml unterscheidet sich die Struktur des Projekts geringfügig.

4. Das Programm

Im Rahmen dieses Programms werden wir versuchen, die folgenden Aufgaben auszuführen.

  1. Speichern eines Objekts in MongoDB
  2. Aktualisieren eines Objekts in MongoDB
  3. Entfernen eines Objekts aus MongoDB
  4. Alle Objekte aus MongoDB abrufen

Lassen Sie uns nun alle Komponenten des Programms analysieren. Zunächst beginnen wir mit den Abhängigkeiten und JAR-Dateien, die für das Programm benötigt werden.

4,1 Gradle

Wir verwenden Gradle, um als Teil des Programms zu erstellen. Die Datei build.gradle sieht wie folgt aus.

 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' }

In der build.gradle Datei build.gradle gibt das apply plugin: 'java' zum build.gradle der Zeile an apply plugin: 'java' , welches Plug-in installiert werden soll. In unserem Fall ist dies ein Java-Plugin.

Das Tag repositories{} das Repository an, aus dem Abhängigkeiten abgerufen werden sollen. Wir haben mavenCentral , um abhängige JAR-Dateien mavenCentral . Wir können auch jcenter verwenden, um die entsprechenden abhängigen JAR-Dateien aufzurufen.

Das Tag dependencies {} wird verwendet, um die erforderlichen Daten zu JAR-Dateien bereitzustellen, die für das Projekt abgerufen werden müssen.

4.2 Konfiguration für MongoDB

Um die MongoDB-Konfiguration zu verwenden, müssen wir die AbstractMongoConfiguration Klasse implementieren. Die Klasse MongoConfig.java sieht wie folgt aus. Hier verwenden wir Anmerkungen anstelle von XML. XML kann aber auch zum Konfigurieren der Konfiguration verwendet werden.

Implementierung der MongoConfig.java-Klasse

 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 verwendet, um die Klasse MongoConfig.java als Konfigurationsklasse zu definieren. @Bean definiert die MongoClient .

4.3 Modellklasse

Betrachten Sie nun die Klasse des Modells. Wir verwenden student.java als Modellklasse, die Attribute für Student wie Name und Alter enthält. Die Student.java Modellklasse Student.java verwendet, um POJOs der MongoDB-Auflistung zuzuordnen.

Student Model Class

 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 definiert ein Dokument. Die collection bestimmt die Sammlung, die zur Übereinstimmung mit der Sammlung verwendet wird. Auf alle Attribute, die als Teil der Sammlung bezeichnet werden, muss in der POJO-Klasse zugegriffen werden können. @Id definiert die Sammlungskennung.

4.4 CRUD-Operationen

Um CRUD-Operationen (kurz für Erstellen, Lesen, Aktualisieren, Löschen) auszuführen, z. B. das Speichern, Aktualisieren, Löschen und Abrufen von Daten aus MongoDB, verwenden wir MongoOperations .

Schauen wir uns nun die Klasse MongoDBPOperations.java an. Diese Klasse enthält die Implementierung aller Methoden von CRUD-Operationen.

Die MongoDBPOperations-Klasse, die zum Ausführen von CRUD-Operationen verwendet wird

 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!! "); } }

Die wichtigste Klasse eines Java-Programms ist die Klasse, die die main enthält.

4.5 Anwendungsklasse

Die Hauptklasse, die die Hauptmethode enthält, ist die Application.java Klasse. Wir werden diese Klasse verwenden, um Methoden aus der MongoDBPOperations Klasse MongoDBPOperations .

Anwendungsklasse zum Aufrufen von Methoden der MongoDBPOperations-Klasse

 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); } }

Schauen wir uns Schritt für Schritt die Vorgänge an, die in der Application.java Klasse ausgeführt werden:

  1. Wir erstellen einen ApplicationContext . Dies liegt an der Notwendigkeit, die Konfiguration herunterzuladen.
  2. Außerdem wurde ein MongoOperations Objekt MongoOperations , um die MongoTemplate Komponente zu laden.
  3. Das MongoDBOperations Objekt bietet Zugriff auf Methoden zum Ausführen verschiedener MongoOperation Operationen.
  4. Außerdem wurde ein Schülerobjekt mit dem Namen John und Alter 15 erstellt.
  5. Wir rufen die saveMethod Methode der saveMethod Klasse auf und übergeben die erforderlichen Parameter, um das Objekt in der Datenbank zu speichern.
  6. Auf die gleiche Weise rufen wir die verschiedenen MongoDBOperations Methoden nacheinander auf.

4.6 Programm starten

Lassen Sie uns das Programm nun als Java-Anwendung ausführen. Klicken Sie mit der rechten Maustaste auf Application.java -> Ausführen als -> Java-Anwendung.

Das folgende Ergebnis wird in der Konsole angezeigt.


Konsolenausgabe nach dem Starten des Programms

Lassen Sie uns nun den Befehl zum Löschen des Objekts auskommentieren. MongoDB speichert erfolgreich Daten.

Lassen Sie uns auch die Zeile auskommentieren, um das Objekt zu löschen, wie unten gezeigt.

Klassenanwendung nach Kommentierung der Entfernungsmethoden

 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); } }

Nachdem Sie Änderungen am Programm vorgenommen haben, starten Sie es neu. Folgendes wird in der Konsole angezeigt.


Konsole, wenn der Löschvorgang auskommentiert ist

Als Ergebnis des Kommentierens des Löschbefehls speichert MongoDB die Daten und sieht daher wie unten gezeigt aus.


MongoDB-Ausgabe nach dem Befehl zum Speichern und Aktualisieren

5. Laden Sie das Eclipse-Projekt herunter

Sie können den gesamten Quellcode für dieses Beispiel hier herunterladen .

DAS ENDE

Wie immer warten wir hier auf Fragen und Kommentare oder gehen zu Yuri für eine offene Lektion, in der Sie nicht nur zuhören, sondern auch herumfragen können.

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

More articles:


All Articles