Alles, was Sie über den MongoDB-Client wissen müssen

Wenn Sie seit einiger Zeit ein relationales Datenbankverwaltungssystem sind, ist Ihnen wahrscheinlich der Name MongoDB begegnet. Erstmals im Jahr 2009 eingeführt, ist mongoDb heute eines der beliebtesten Verwaltungssysteme für relationale Datenbanken in der Branche. Der Hauptgrund für seine wahnsinnige Popularität trotz der Präsenz älterer Softwaremanager für relationale Datenbanken wie MySql auf dem Markt ist die große Zahl und die große Vielseitigkeit, die es auf den Tisch bringt. Die Verwendung von MongoDB beseitigt viele Anforderungen, darunter die Notwendigkeit, bei jedem Start eines neuen Projekts eine Datenbank zu erstellen und den Datentyp zu definieren. Agenda des MongoDB-Client-Artikels:

• Voraussetzungen für den MongoDB-Client
• Projekt auf Maven erstellen
• Hinzufügen Ihres allerersten JSON-Rest-Service
• MongoDB-Datenbank konfigurieren
• Ausführen der konfigurierten MongoDB-Datenbank
• Das Frontend erstellen
• Vereinfachung des MongoDB-Clients mit BSON-Codec
• Endgültiger Code

Aber um die maximale Funktionalität von MongoDB zu erreichen, muss man mit dem MongoDB-Client vertraut sein und in diesem Artikel werden wir genau das besprechen.

Voraussetzungen für den MongoDB-Client

Um diesen Artikel vollständig lesen zu können, müssen Sie zuerst die folgenden Voraussetzungen erfüllen.

In Ihrem System ist bereits eine IDE vorhanden.
Java Development Kit oder JDK Version 1.8 und höher installiert mit richtig konfiguriertem JAVA_HOME.
Docker oder MongoDB installiert.
Apache Maven Version 3.5.3 und höher.

Die Architektur, die wir in diesem Handbuch erstellt und verwendet haben, ist eine der einfachsten. Bei der Ausführung kann der Benutzer einfach Daten und Elemente zu einer Liste hinzufügen, wonach diese automatisch in der Datenbank aktualisiert wird.

Dabei haben wir sichergestellt, dass die gesamte Kommunikation zwischen den Daten und dem Server in JSON erfolgt und alle Daten in MongoDB gespeichert werden.

Erste Schritte

Um mit diesem Projekt zu beginnen, folgen Sie den unten beschriebenen Schritten.

Schritt Nr. 1:Erstellen des Projekts auf Maven

Der erste Schritt besteht immer darin, ein neues Projekt zu erstellen, und verwenden Sie dazu den folgenden Code.

mvn io.quarkus:quarkus-maven-plugin:0.22.0:create 
-DprojectGroupId=org.acme 
-DprojectArtifactId=using-mongodb-client 
-DclassName="org.acme.rest.json.FruitResource" 
-Dpath="/fruits" 
-Dextensions="resteasy-jsonb,mongodb-client"

Wenn Sie den obigen Befehl ausführen, importiert die IDE die JSON-B-, MongoDb- sowie RESTEasy/JAX-RS-Clients auf Ihr System.

Fahren Sie mit Schritt 2 fort.

Schritt 2:Hinzufügen Ihres allerersten JSON-Rest-Service

In order to do this, use the code below.

package org.acme.rest.json;

import java.util.Objects;

public class Fruit {

private String name;
private String description;

public Fruit() {
}

public Fruit(String name, String description) {
this.name = name;
this.description = description;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getDescription() {
return description;
}

public void setDescription(String description) {
this.description = description;
}

@Override
public boolean equals(Object obj) {
if (!(obj instanceof Fruit)) {
return false;
}

Fruit other = (Fruit) obj;

return Objects.equals(other.name, this.name);
}

@Override
public int hashCode() {
return Objects.hash(this.name);
}
}

Mit dem obigen Beispiel haben wir zuerst die Frucht erstellt, die später im Programm verwendet wird.

Als nächstes müssen wir die Datei org.acme.rest.json.FruitService erstellen, die die Benutzerebene unserer Anwendung sein wird. Verwenden Sie dazu den folgenden Code.

package org.acme.rest.json;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import org.bson.Document;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;

@ApplicationScoped
public class FruitService {

@Inject MongoClient mongoClient;

public List list(){
List list = new ArrayList<>();
MongoCursor cursor = getCollection().find().iterator();

try {
while (cursor.hasNext()) {
Document document = cursor.next();
Fruit fruit = new Fruit();
fruit.setName(document.getString("name"));
fruit.setDescription(document.getString("description"));
list.add(fruit);
}
} finally {
cursor.close();
}
return list;
}

public void add(Fruit fruit){
Document document = new Document()
.append("name", fruit.getName())
.append("description", fruit.getDescription());
getCollection().insertOne(document);
}

private MongoCollection getCollection(){
return mongoClient.getDatabase("fruit").getCollection("fruit");
}
}

Now we need to edit the org.acme.rest.json.FruitResource class to suit our needs. In order to do this, use the code below.

@Path("/fruits")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class FruitResource {

@Inject FruitService fruitService;

@GET
public List list() {
return fruitService.list();
}

@POST
public List add(Fruit fruit) {
fruitService.add(fruit);
return list();
}
}

Fahren Sie mit Schritt 3 fort.

Schritt Nr. 3:Konfigurieren der mongoDb-Datenbank

Die Syntax sowie der Standardcode zum Konfigurieren der mongoDb-Datenbank sind unten angegeben.

# configure the mongoDB client for a replica set of two nodes
quarkus.mongodb.connection-string = mongodb://mongo1:27017,mongo2:27017

In unserem Fall verwenden wir den folgenden Code, um die Datenbank zu konfigurieren.

# configure the mongoDB client for a replica set of two nodes
quarkus.mongodb.connection-string = mongodb://localhost:27017

Fahren Sie mit Schritt 4 fort.

Schritt Nr. 4:Ausführen der konfigurierten MongoDB-Datenbank

Der nächste Schritt besteht darin, die soeben erstellte MongoDB-Datenbank auszuführen. Verwenden Sie dazu den folgenden Code.

docker run -ti --rm -p 27017:27017 mongo:4.0

Fahren Sie mit Schritt 5 fort.

Schritt Nr. 5:Erstellen des Frontends

Nachdem nun die gesamte Arbeit am Backend der Anwendung erledigt ist, werfen wir einen Blick auf den Code, der zum Codieren des Frontends unserer Anwendung verwendet wird.

package org.acme.rest.json;

import io.quarkus.mongodb.ReactiveMongoClient;
import io.quarkus.mongodb.ReactiveMongoCollection;
import org.bson.Document;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import java.util.List;
import java.util.concurrent.CompletionStage;

@ApplicationScoped
public class ReactiveFruitService {

@Inject
ReactiveMongoClient mongoClient;

public CompletionStage<List> list(){
return getCollection().find().map(doc -> {
Fruit fruit = new Fruit();
fruit.setName(doc.getString("name"));
fruit.setDescription(doc.getString("description"));
return fruit;
}).toList().run();
}

public CompletionStage add(Fruit fruit){
Document document = new Document()
.append("name", fruit.getName())
.append("description", fruit.getDescription());
return getCollection().insertOne(document);
}

private ReactiveMongoCollection getCollection(){
return mongoClient.getDatabase("fruit").getCollection("fruit");
}
}

package org.acme.rest.json;

import javax.inject.Inject;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import java.util.List;
import java.util.concurrent.CompletionStage;

@Path("/reactive_fruits")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class ReactiveFruitResource {

@Inject ReactiveFruitService fruitService;

@GET
public CompletionStage<List> list() {
return fruitService.list();
}

@POST
public CompletionStage<List> add(Fruit fruit) {
fruitService.add(fruit);
return list();
}
}

Im obigen Beispiel verwenden wir einen reaktiven mongoDb-Client, um die Bildung des Front-Ends zu erleichtern.

Fahren Sie mit Schritt 6 fort.

Schritt Nr. 6:Vereinfachen des mongoDb-Clients mithilfe des BSON-Codecs

Verwenden Sie dazu den folgenden Code.

package org.acme.rest.json.codec;

import com.mongodb.MongoClient;
import org.acme.rest.json.Fruit;
import org.bson.*;
import org.bson.codecs.Codec;
import org.bson.codecs.CollectibleCodec;
import org.bson.codecs.DecoderContext;
import org.bson.codecs.EncoderContext;

import java.util.UUID;

public class FruitCodec implements CollectibleCodec {

private final Codec documentCodec;

public FruitCodec() {
this.documentCodec = MongoClient.getDefaultCodecRegistry().get(Document.class);
}

@Override
public void encode(BsonWriter writer, Fruit fruit, EncoderContext encoderContext) {
Document doc = new Document();
doc.put("name", fruit.getName());
doc.put("description", fruit.getDescription());
documentCodec.encode(writer, doc, encoderContext);
}

@Override
public Class getEncoderClass() {
return Fruit.class;
}

@Override
public Fruit generateIdIfAbsentFromDocument(Fruit document) {
if (!documentHasId(document)) {
document.setId(UUID.randomUUID().toString());
}
return document;
}

@Override
public boolean documentHasId(Fruit document) {
return document.getId() != null;
}

@Override
public BsonValue getDocumentId(Fruit document) {
return new BsonString(document.getId());
}

@Override
public Fruit decode(BsonReader reader, DecoderContext decoderContext) {
Document document = documentCodec.decode(reader, decoderContext);
Fruit fruit = new Fruit();
if (document.getString("id") != null) {
fruit.setId(document.getString("id"));
}
fruit.setName(document.getString("name"));
fruit.setDescription(document.getString("description"));
return fruit;
}
}

Jetzt werden wir einen CodecProvider verwenden, um dies mit der bereits vorhandenen Fruit-Klasse zu verknüpfen.

package org.acme.rest.json.codec;

import org.acme.rest.json.Fruit;
import org.bson.codecs.Codec;
import org.bson.codecs.configuration.CodecProvider;
import org.bson.codecs.configuration.CodecRegistry;

public class FruitCodecProvider implements CodecProvider {
@Override
public Codec get(Class clazz, CodecRegistry registry) {
if (clazz == Fruit.class) {
return (Codec) new FruitCodec();
}
return null;
}

}

Fahren Sie mit Schritt 7 fort.

Schritt Nr. 7:Endgültiger Code

Der endgültige Code für diese Anwendung sieht in etwa so aus.

package org.acme.rest.json;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;

@ApplicationScoped
public class CodecFruitService {

@Inject MongoClient mongoClient;

public List list(){
List list = new ArrayList<>();
MongoCursor cursor = getCollection().find().iterator();

try {
while (cursor.hasNext()) {
list.add(cursor.next());
}
} finally {
cursor.close();
}
return list;
}

public void add(Fruit fruit){
getCollection().insertOne(fruit);
}

private MongoCollection getCollection(){
return mongoClient.getDatabase("fruit").getCollection("fruit", Fruit.class);
}
}

Fazit

Jetzt wissen Sie, wie Sie den MongoDB-Client in Ihrem System konfigurieren und verwenden. Probieren Sie diese Codes in Ihrem System aus und teilen Sie uns Ihre Erfahrungen mit.

Artikelzusammenfassung

Erfahren Sie alles über den MongoDB-Client und wie Sie ihn in Ihrem System für verschiedene Zwecke konfigurieren können. Lesen Sie weiter, um mehr zu erfahren.

Damit kommen wir zum Ende des “ MongoDB-Client“ Artikel.