Tutto ciò che devi sapere sul client MongoDB

Se sei stato un sistema di gestione di database relazionali per un po' di tempo, probabilmente ti sei imbattuto nel nome di MongoDB. Introdotto per la prima volta nell'anno 2009, oggi mongoDb è uno dei sistemi di gestione di database relazionali più popolari nel settore. Il motivo principale alla base della sua folle popolarità nonostante la presenza di vecchi gestori di software di database relazionali come MySql presenti sul mercato è l'ampiezza dei numeri e la grande versatilità che porta in tavola. L'uso di MongoDB elimina molte esigenze, una tra queste è la necessità di creare un database e definire il tipo di dati ogni volta che viene avviato un nuovo progetto. Agenda dell'articolo del client MongoDB:

• Prerequisiti per il client MongoDB
• Creazione del progetto su Maven
• Aggiunta del tuo primo servizio di riposo JSON
• Configurazione del database MongoDB
• Esecuzione del database MongoDB configurato
• Realizzare il front-end
• Semplificazione del client MongoDB utilizzando il codec BSON
• Codice finale

Ma per ottenere la massima funzionalità da MongoDB, è necessario avere familiarità con il client MongoDB e in questo articolo parleremo proprio di questo.

Prerequisiti per il client MongoDB

Affinché questo articolo sia completamente, dovrai prima soddisfare i seguenti prerequisiti.

Ha un IDE già presente nel tuo sistema.
Java Development Kit o JDK versione 1.8 e successive installati con JAVA_HOME configurato correttamente.
Docker o MongoDB installati.
Apache Maven versione 3.5.3 e successive.

L'architettura che abbiamo creato e utilizzato in questa guida è una delle più semplici. Una volta eseguito, l'utente può facilmente aggiungere dati ed elementi in un elenco, dopodiché verrà aggiornato automaticamente nel database.

Insieme a questo, ci siamo assicurati che tutta la comunicazione tra i dati e il server sia in JSON e tutti i dati siano archiviati in MongoDB.

Per iniziare

Per iniziare con questo progetto, segui i passaggi descritti di seguito.

Passaggio n. 1:creazione del progetto su Maven

Il primo passo è sempre creare un nuovo progetto e per fare ciò utilizzare il codice seguente.

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"

Quando esegui il comando precedente, l'IDE importerà i client JSON-B, MongoDb e RESTEasy/JAX-RS sul tuo sistema.

Andare avanti con il passaggio 2.

Passaggio n. 2:aggiunta del tuo primo servizio di riposo JSON

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

Con l'esempio sopra, abbiamo prima creato il Fruit che sarà poi utilizzato nel programma.

Successivamente dobbiamo creare il file org.acme.rest.json.FruitService che sarà il livello utente della nostra applicazione. Per fare ciò, usa il codice qui sotto.

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

Andando avanti con il passaggio 3.

Passaggio n. 3:configurazione del database mongoDb

La sintassi e il codice standard per la configurazione del database mongoDb sono i seguenti.

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

Nel nostro caso, utilizzeremo il codice seguente per configurare il database.

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

Andando avanti con il passaggio 4.

Passaggio n. 4:esecuzione del database MongoDB configurato

Il prossimo passo è eseguire il database MongoDB che abbiamo appena creato. Per fare ciò, utilizza il codice qui sotto.

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

Andando avanti con il passaggio 5.

Passaggio n. 5:realizzazione del front-end

Ora che tutto il lavoro sul back-end dell'applicazione è terminato, diamo un'occhiata al codice utilizzato per codificare il front-end della nostra applicazione.

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

Nell'esempio sopra, utilizziamo un client mongoDb reattivo per facilitare la formazione del front-end.

Andando avanti con il passaggio 6.

Passaggio n. 6:semplificazione del client mongoDb utilizzando il codec BSON

Per fare ciò, utilizza il codice qui sotto.

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

Ora utilizzeremo un CodecProvider per collegarlo alla classe Fruit già presente.

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

}

Andando avanti con il passaggio 7.

Passaggio n. 7:codice finale

Il codice finale per questa applicazione sarà simile a questo.

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

Conclusione

Ora sai come configurare e utilizzare il client MongoDB nel tuo sistema. Vai avanti e prova questi codici nel tuo sistema e facci sapere la tua esperienza.

Riepilogo articolo

Scopri tutto sul client MongoDB e su come puoi configurarlo nel tuo sistema per vari usi. Continua a leggere per saperne di più.

Con questo arriviamo alla fine del “ Cliente MongoDB” articolo.