Alles wat u moet weten over MongoDB Client

Als je al een tijdje een relationeel databasebeheersysteem gebruikt, ben je waarschijnlijk de naam MongoDB tegengekomen. MongoDb werd voor het eerst geïntroduceerd in het jaar 2009 en is tegenwoordig een van de meest populaire relationele databasebeheersystemen in de branche. De belangrijkste reden achter zijn waanzinnige populariteit, ondanks de aanwezigheid van oudere relationele databasesoftwaremanagers zoals MySql die op de markt aanwezig zijn, is het grote aantal cijfers en de grote veelzijdigheid die het met zich meebrengt. Het gebruik van MongoDB elimineert veel behoeften, waaronder de noodzaak om een ​​database aan te maken en het gegevenstype te definiëren telkens wanneer een nieuw project wordt gestart. Agenda van het MongoDB-klantartikel:

• Vereisten voor MongoDB Client
• Het project op Maven maken
• Uw allereerste JSON-rustservice toevoegen
• De MongoDB-database configureren
• De geconfigureerde MongoDB-database uitvoeren
• De voorkant maken
• De MongoDB-client vereenvoudigen met BSON-codec
• Definitieve code

Maar om de maximale functionaliteit uit MongoDB te halen, moet men bekend zijn met de MongoDB-client en in dit artikel zullen we precies dat bespreken.

Vereisten voor MongoDB Client

Om dit artikel volledig te kunnen gebruiken, moet je eerst aan de volgende vereisten voldoen.

Heb al een IDE in uw systeem.
Java Development Kit of JDK versie 1.8 en hoger geïnstalleerd met JAVA_HOME correct geconfigureerd.
Docker of MongoDB geïnstalleerd.
Apache Maven versie 3.5.3 en hoger.

De architectuur die we in deze handleiding hebben gemaakt en gebruikt, is een van de eenvoudigste. Na uitvoering kan de gebruiker eenvoudig gegevens en elementen toevoegen aan een lijst, waarna deze automatisch wordt bijgewerkt in de database.

Daarnaast hebben we ervoor gezorgd dat alle communicatie tussen de gegevens en de server in JSON is en dat alle gegevens in MongoDB worden opgeslagen.

Aan de slag

Volg de onderstaande stappen om aan de slag te gaan met dit project.

Stap #1:het project op Maven maken

De eerste stap is altijd om een ​​nieuw project aan te maken en gebruik hiervoor de volgende 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"

Wanneer u de bovenstaande opdracht uitvoert, importeert de IDE zowel de JSON-B-, MongoDb- als RESTEasy/JAX-RS-clients op uw systeem.

Verder gaan met stap 2.

Stap #2:Uw allereerste JSON-rustservice toevoegen

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

Met het bovenstaande voorbeeld hebben we eerst de Fruit gemaakt die later in het programma zal worden gebruikt.

Vervolgens moeten we het org.acme.rest.json.FruitService-bestand maken dat de gebruikerslaag van onze applicatie zal zijn. Gebruik hiervoor de onderstaande 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();
}
}

Verder gaan met stap 3.

Stap #3:De mongoDb-database configureren

De syntaxis en standaardcode voor het configureren van de mongoDb-database worden hieronder weergegeven.

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

In ons geval zullen we de volgende code gebruiken om de database te configureren.

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

Verder gaan met stap 4.

Stap #4:De geconfigureerde MongoDB-database uitvoeren

De volgende stap is het uitvoeren van de MongoDB-database die we zojuist hebben gemaakt. Gebruik hiervoor de onderstaande code.

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

Verder gaan met stap 5.

Stap #5:de voorkant maken

Nu al het werk aan de achterkant van de applicatie is gedaan, laten we eens kijken naar de code die is gebruikt om de voorkant van onze applicatie te coderen.

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

In het bovenstaande voorbeeld maken we gebruik van een reactieve mongoDb-client om de vorming van de front-end te vergemakkelijken.

Verdergaan met stap 6.

Stap #6:de mongoDb-client vereenvoudigen met BSON-codec

Gebruik hiervoor de onderstaande 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;
}
}

Nu gaan we een CodecProvider gebruiken om dit te koppelen aan de reeds aanwezige Fruit-klasse.

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

}

Verder gaan met stap 7.

Stap #7:definitieve code

De uiteindelijke code voor deze applicatie ziet er ongeveer zo uit.

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

Conclusie

Nu weet je hoe je de MongoDB-client in je systeem moet configureren en gebruiken. Ga je gang en probeer deze codes in je systeem en laat ons je ervaringen weten.

Artikeloverzicht

Leer alles over de MongoDB-client en hoe u deze in uw systeem kunt configureren voor verschillende toepassingen. Lees verder om meer te weten.

Hiermee komen we aan het einde van de “ MongoDB-client” artikel.