Todo lo que necesita saber sobre el cliente MongoDB

Si ha utilizado algún tipo de sistema de gestión de bases de datos relacionales durante algún tiempo, probablemente se haya topado con el nombre de MongoDB. Presentado por primera vez en el año 2009, hoy mongoDb es uno de los sistemas de administración de bases de datos relacionales más populares en la industria. La razón principal detrás de su increíble popularidad a pesar de la presencia de administradores de software de bases de datos relacionales más antiguos como MySql presentes en el mercado es la gran cantidad de números y la gran versatilidad que aporta. El uso de MongoDB elimina muchas necesidades, una de ellas es la necesidad de crear una base de datos y definir el tipo de datos cada vez que se inicia un nuevo proyecto. Agenda del artículo del cliente MongoDB:

• Requisitos previos para MongoDB Client
• Creando el proyecto en Maven
• Agregando su primer servicio de descanso JSON
• Configuración de la base de datos MongoDB
• Ejecutar la base de datos MongoDB configurada
• Haciendo la parte delantera
• Simplificando el cliente MongoDB utilizando el códec BSON
• Código final

Pero para lograr la máxima funcionalidad de MongoDB, uno debe estar familiarizado con el cliente de MongoDB y en este artículo, discutiremos precisamente eso.

Requisitos previos para MongoDB Client

Para leer este artículo en su totalidad, primero deberá cumplir con los siguientes requisitos previos.

Tenga un IDE ya presente en su sistema.
Java Development Kit o JDK versión 1.8 y superior instalado con JAVA_HOME configurado correctamente.
Docker o MongoDB instalado.
Apache Maven versión 3.5.3 y superior.

La arquitectura que hemos creado y usado en esta guía es una de las más simples. Cuando se ejecuta, el usuario puede agregar fácilmente datos y elementos en una lista, después de lo cual se actualizará automáticamente en la base de datos.

Junto con esto, nos hemos asegurado de que toda la comunicación entre los datos y el servidor sea en JSON y todos los datos se almacenen en MongoDB.

Cómo empezar

Para comenzar con este proyecto, siga los pasos que se describen a continuación.

Paso n.° 1:creación del proyecto en Maven

El primer paso siempre es crear un nuevo proyecto y para ello, utilice el siguiente código.

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"

Cuando ejecute el comando anterior, el IDE importará los clientes JSON-B, MongoDb y RESTEasy/JAX-RS a su sistema.

Continuando con el Paso 2.

Paso n.° 2:agregar su primer servicio de descanso 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 el ejemplo anterior, primero hemos creado la Fruta que luego se usará en el programa.

A continuación, debemos crear el archivo org.acme.rest.json.FruitService, que será la capa de usuario de nuestra aplicación. Para hacer esto, use el siguiente código.

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

Continuando con el Paso 3.

Paso #3:Configuración de la base de datos mongoDb

La sintaxis y el código estándar para configurar la base de datos mongoDb se indican a continuación.

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

En nuestro caso, haremos uso del siguiente código para configurar la base de datos.

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

Continuando con el Paso 4.

Paso #4:Ejecutar la base de datos MongoDB configurada

El siguiente paso es ejecutar la base de datos MongoDB que acabamos de crear. Para hacer esto, utilice el siguiente código.

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

Continuando con el Paso 5.

Paso n.º 5:hacer la parte delantera

Ahora que todo el trabajo en el back-end de la aplicación está hecho, echemos un vistazo al código utilizado para codificar el front-end de nuestra aplicación.

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

En el ejemplo anterior, utilizamos un cliente mongoDb reactivo para facilitar la formación de la interfaz.

Continuando con el Paso 6.

Paso n.º 6:simplificación del cliente mongoDb con el códec BSON

Para hacer esto, utilice el siguiente código.

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

Ahora haremos uso de un CodecProvider para vincular esto a la clase Fruit ya 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;
}

}

Continuando con el Paso 7.

Paso n.° 7:Código final

El código final para esta aplicación se verá así.

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

Conclusión

Ahora ya sabe cómo configurar y utilizar el cliente MongoDB en su sistema. Adelante, prueba estos códigos en tu sistema y cuéntanos tu experiencia.

Resumen del artículo

Aprenda todo sobre el cliente MongoDB y cómo puede configurarlo en su sistema para varios usos. Sigue leyendo para saber más.

Con esto llegamos al final de la “ Cliente MongoDB” artículo.