Accesso ai dati in Quarkus: MongoDB e Panache

Nel precedente articolo è stato introdotto Hibernate Panache come estensione di Hibernate per velocizzare la scrittura di un ORM layer. Quarkus Panache consente di fare di più, possiamo interagire con un database NO-SQL, come Mongo DB, anche senza avere conoscenza delle API client necessarie il cui uso può essere ritenuto ingombrante.

In questo articolo vedremo come convertire in pochi semplici passi il servizio Rest Animal Service in modo che interagisca con un DB Mongo.

Configurazione di MongoDB

Come sempre il primo step è la configurazione del progetto. Riprendiamo quanto realizzato in precedenza e aggiungiamo la dipendenza:

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-mongodb-panache</artifactId>
</dependency>

Eseguiamo da terminale Intellij il comando maven mvn -U idea:idea per poter aggiornare il repository locale con le dipendenze Mongo necessarie. Come fatto per un DB relazionale, anche in questo caso facciamo in modo di avere un'istanza Mongo DB pronta all'uso avvalendoci di Docker in ambiente Linux.

Digitiamo da terminale Linux il comando:

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

e attendiamo che Docker completi il suo lavoro.

Con MongoDB a disposizione apriamo il file application.properties e configuriamo una connessione in modo simile a quanto fatto con Postgres:

quarkus.mongodb.connection-string = mongodb://localhost:27017
quarkus.mongodb.database = animal

Con le righe precedenti abbiamo definito la stringa di connessione al DB e il nome del database che ospiterà la collezione Animal.

Il servizio Rest Animal accede a MongoDB

Riprendiamo la definizione dell'entity Animal e riformuliamola come entity Mongo seguendo il pattern Active Record:

package it.html;
import io.quarkus.mongodb.panache.MongoEntity;
import io.quarkus.mongodb.panache.PanacheMongoEntity;
import org.bson.codecs.pojo.annotations.BsonProperty;
import java.util.List;
@MongoEntity(collection="Animal")
public class Animal extends PanacheMongoEntity {
    @BsonProperty("name")
    public String name;
    @BsonProperty("type")
    public String type;
    public static Animal findByName(String name){
        return find("name", name).firstResult();
    }
    public static List<Animal> findSelvatic(){
        return list("type", "Selvatic");
    }
}

Come si può notare la conversione è abbastanza lineare. Estendiamo la classe PanacheMongoEntity in modo che la classe sia un'entity Mongo e annotiamo i suoi campi con l'annotation @BsonProperty al fine di renderli persistenti.

Altre annotation utili sono @BsonId per personalizzare l'ID identificativo dell'entity, e l'annotation @BsonIgnore per ignorare il campo durante la serializzazione. Può sorprendere ma la conversione del progetto per il funzionamento verso Mongo DB è conclusa.

Il codice del servizio Rest rimane infatti inalterato:

package it.html;
import java.util.List;
import javax.enterprise.context.ApplicationScoped;
import javax.transaction.Transactional;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response;
import org.jboss.resteasy.annotations.jaxrs.PathParam;
import io.quarkus.panache.common.Sort;
@Path("animals")
@ApplicationScoped
@Produces("application/json")
@Consumes("application/json")
public class AnimalService {
    @GET
    @Path("/all")
    public List<Animal> get() {
        return Animal.listAll(Sort.by("type"));
    }
    @GET
    @Path("/selvatic")
    public List<Animal> getSelvatic() {
        return Animal.findSelvatic();
    }
    @GET
    @Path("{name}")
    public Animal getByName(@PathParam String name) {
        return Animal.findByName(name);
    }
    @POST
    @Transactional
    public Response create(Animal animal) {
        if (animal.name == null || animal.type == null) {
            throw new WebApplicationException("Indalid data.", 422);
        }
        animal.persist();
        return Response.ok(animal).status(201).build();
    }
}

Il database creato è chiaramente privo di record, apriamo quindi Postman ed eseguiamo alcuni test. Iniziamo con due operazioni di inserimento.

Avviamo l'applicazione Quarkus eseguendo il comando quarkus:dev da Intellij ed utilizziamo Postman per richiamare il servizio REST al fine di visualizzare ed inserire istanze della classe Animale:

e concludiamo richiamando l'endpoint del servizio per la visualizzazione dei record inseriti: