Semplifica l’integrazione dei database NoSQL in Java con Eclipse JNoSQL 1.1.3

Tutorial

NoSQL

I database NoSQL sono diventati una base dello sviluppo di applicazioni moderne, offrendo scalabilità e flessibilità per gestire diversi tipi di dati. Tuttavia, per molti sviluppatori Java, l’integrazione con i database NoSQL può essere complessa e richiedere molto tempo. Ecco dove entra in gioco Eclipse JNoSQL, fornendo un modo semplice e standardizzato per collegare le tue applicazioni Java a vari database NoSQL.

Questo articolo esplora come Eclipse JNoSQL 1.1.3 semplifica l’integrazione dei database, migliora la produttività degli sviluppatori e offre flessibilità tra diversi database. Ti guideremo anche attraverso un esempio pratico utilizzando Quarkus e ArangoDB per dimostrare le sue funzionalità.

Perché gli sviluppatori Java dovrebbero interessarsi a Eclipse JNoSQL

Per molti sviluppatori, lavorare con i database NoSQL implica imparare API specifiche del database, il che può portare a codice frammentato e non portabile. Eclipse JNoSQL elimina queste sfide offrendo:

Semplicità d’uso: Con annotazioni intuitive come @Entity, @Id e @Column, puoi mappare gli oggetti Java alle collezioni NoSQL in pochi secondi.
Flessibilità: Passa da un database NoSQL all’altro (ad esempio Redis, MongoDB, ArangoDB, Oracle NoSQL) senza modificare il codice dell’applicazione.
Conformità agli standard: Implementa le specifiche Jakarta Data e Jakarta NoSQL, garantendo una soluzione portabile e pronta per il futuro.
Pronto per l’integrazione: Funziona perfettamente con i componenti Jakarta EE e MicroProfile, sfruttando CDI per l’iniezione delle dipendenze e la gestione della configurazione.

Cosa c’è di nuovo in Eclipse JNoSQL 1.1.3

Eclipse JNoSQL ha appena rilasciato la versione 1.1.3, portando nuove funzionalità, correzioni di bug e miglioramenti delle prestazioni al suo ecosistema già robusto. Questo rilascio è un traguardo significativo nel semplificare le interazioni degli sviluppatori Java con i database NoSQL. In questo articolo, esploreremo gli obiettivi di Eclipse JNoSQL e le nuove funzionalità introdotte in questa versione fornendo un esempio pratico su come utilizzarlo con Quarkus e ArangoDB.

Eclipse JNoSQL mira a semplificare l’integrazione delle applicazioni Java con i database NoSQL fornendo un’API e un’architettura unificate. Aderendo alle specifiche di Jakarta EE, JNoSQL permette agli sviluppatori di lavorare senza problemi con vari database NoSQL – che siano database chiave-valore, documentali, a grafo o a famiglia di colonne.

Interoperabilità: Questa astrazione riduce le complessità specifiche del database, facilitando il passaggio tra database come MongoDB, Redis, ArangoDB e Oracle NoSQL.
Guidato dalle specifiche: Implementa le specifiche Jakarta Data e Jakarta NoSQL, offrendo un modo standardizzato per lavorare con i database NoSQL.
Integrazione con l’Ecosistema Java: Sfrutta CDI per l’iniezione delle dipendenze e Eclipse MicroProfile per la configurazione, garantendo la compatibilità con i moderni framework Java come Quarkus e Spring Boot.

Limitazioni e Considerazioni per Eclipse JNoSQL

Mentre Eclipse JNoSQL offre notevoli vantaggi per l’integrazione dei database NoSQL, è essenziale considerare alcuni svantaggi per mantenere una prospettiva equilibrata:

Curva di Apprendimento per Nuovi Standard: Gli sviluppatori non familiarità con Jakarta EE o MicroProfile potrebbero aver bisogno di tempo per comprendere e adattarsi alle specifiche e alle API utilizzate da JNoSQL.
Caratteristiche Specifiche del Database: Anche se JNoSQL astrae le operazioni comuni dei database NoSQL, potrebbe non supportare appieno le funzionalità avanzate specifiche del database senza personalizzazioni aggiuntive.
Comunità ed Ecosistema: Essendo uno strumento relativamente specializzato, il suo ecosistema e il supporto della comunità sono più limitati rispetto ai framework Java più ampi come Hibernate o Spring Data.
OTTimizzazione delle Prestazioni: Le API generalizzate potrebbero introdurre un leggero sovraccarico delle prestazioni rispetto alle librerie native specifiche del database, specialmente per applicazioni ad elevate prestazioni.

Comprendere queste limitazioni aiuta gli sviluppatori a prendere decisioni informate e a valutare dove JNoSQL si adatta meglio ai loro progetti.

Specifiche Jakarta EE Supportate da Eclipse JNoSQL

Eclipse JNoSQL supporta Jakarta Data e Jakarta NoSQL, due specifiche critiche nell’ecosistema di Jakarta EE.

Jakarta Data

Fornisce una standard API per accedere e gestire i repository di dati, consentendo agli sviluppatori di eseguire facilmente operazioni CRUD. Si concentra sulla semplificazione della paginazione, dell’ordinamento e delle query dinamiche.

Jakarta NoSQL

Definisce un’API uniforme per le interazioni con i database NoSQL. Fornisce annotazioni come @Entity, @Id e @Column per mappare le classi Java alle collezioni NoSQL e semplificare le operazioni di database.

Queste specifiche riducono il codice ripetitivo e favoriscono la portabilità tra database, rendendole essenziali per gli sviluppatori Java.

La versione più recente, versione 1.1.3, si concentra sul miglioramento della affidabilità, della sicurezza e delle prestazioni introducendo nuove funzionalità interessanti:

Redis: Migliorato il supporto per Redis Sentinel per una maggiore disponibilità.
ArangoDB: Aggiornamenti sulla sicurezza e la gestione delle chiavi.
Oracle NoSQL: Nuove opzioni di credenziali per una migliore integrazione.
JNoSQL Lite: Aggiunto il supporto per la registrazione, migliorando la tracciabilità.
Aggiornamenti dei driver: Driver migliorati per vari database NoSQL.
CDI Lite: Ora ha il supporto per i record Java

Per mostrare la potenza di Eclipse JNoSQL 1.1.3, creeremo un’applicazione Quarkus che gestisce “Goals” utilizzando ArangoDB. Grazie alle specifiche di Jakarta EE, passare ad altri database NoSQL come MongoDB o Oracle NoSQL può essere fatto con modifiche minime.

Passo dopo passo

Passo 1: Configurazione di Quarkus

Inizia il tuo progetto Quarkus utilizzando il Quarkus Starter UI, selezionando le seguenti estensioni:

REST
JSON
ARC (CDI Lite)
Driver ArangoDB

Il tuo pom.xml dovrebbe includere:

XML

<dependencies>

    <dependency>

        <groupId>io.quarkus</groupId>

        <artifactId>quarkus-rest</artifactId>

    </dependency>

    <dependency>

        <groupId>io.quarkus</groupId>

        <artifactId>quarkus-rest-jsonb</artifactId>

    </dependency>

    <dependency>

        <groupId>io.quarkus</groupId>

        <artifactId>quarkus-arc</artifactId>

    </dependency>

    <dependency>

        <groupId>io.quarkiverse.jnosql</groupId>

        <artifactId>quarkus-jnosql-document-arangodb</artifactId>

        <version>3.3.2</version>

    </dependency>

    <!-- Test dependencies -->

    <dependency>

        <groupId>io.quarkus</groupId>

        <artifactId>quarkus-junit5</artifactId>

        <scope>test</scope>

    </dependency>

    <dependency>

        <groupId>io.rest-assured</groupId>

        <artifactId>rest-assured</artifactId>

        <scope>test</scope>

    </dependency>

</dependencies>

Passo 2: Implementazione della Connessione al Database

Imposta la connessione al tuo database in application.properties:

Properties files

jnosql.arangodb.host=localhost:8529

jnosql.document.database=goals

jnosql.keyvalue.database=goals

Esegui un’istanza di ArangoDB localmente utilizzando Docker:

Shell

docker run -e ARANGO_NO_AUTH=1 -d --name arangodb-instance -p 8529:8529 -d arangodb/arangodb

Crea un database chiamato goals e una collezione Goal nell’interfaccia web di ArangoDB.

Passo 3: Modellare i Tuoi Dati

Utilizza la funzionalità record di Java con CDI Lite:

Java

import jakarta.json.bind.annotation.JsonbProperty;

import jakarta.json.bind.annotation.JsonbPropertyOrder;

import jakarta.nosql.Column;

import jakarta.nosql.Entity;

import jakarta.nosql.Id;

​

import java.util.List;

​

@JsonbPropertyOrder({"id", "title", "description", "priority", "tasks"})

@Entity

public record Goal(

        @Id @JsonbProperty("id") String id,

        @JsonbProperty("title") @Column String title,

        @JsonbProperty("description") @Column String description,

        @JsonbProperty("priority") @Column int priority,

        @JsonbProperty("tasks") @Column List<String> tasks) {}

Passo 4: Impostazione di un Repository

Definisci un repository utilizzando Jakarta Data:

Java

@Repository

public interface NewYearWishes extends BasicRepository<Goal, String> {}

Passo 5: Implementazione di un Livello di Servizio

Crea un livello di servizio per gestire la logica di business:

Java

@ApplicationScoped

public class GoalService {

​

    private final NewYearWishes newYearWishes;

​

    @Inject

    public GoalService(@Database(DatabaseType.DOCUMENT) NewYearWishes newYearWishes) {

        this.newYearWishes = newYearWishes;

    }

​

    public List<Goal> findGoals(int page, int size) {

        PageRequest pageRequest = PageRequest.ofPage(page).size(size);

        return newYearWishes.findAll(pageRequest, Order.by(Sort.asc("priority"))).content();

    }

​

    public Goal save(Goal goal) {

        return newYearWishes.save(goal);

    }

​

    public Optional<Goal> findById(String id) {

        return newYearWishes.findById(id);

    }

}

Passo 6: Creazione di Endpoint REST

Definisci una risorsa REST:

Java

@Path("/goals")

@Consumes(MediaType.APPLICATION_JSON)

@Produces(MediaType.APPLICATION_JSON)

public class GoalResource {

​

    private final GoalService goalService;

​

    @Inject

    public GoalResource(GoalService goalService) {

        this.goalService = goalService;

    }

​

    @GET

    public List<Goal> goals(@QueryParam("page") int page, @QueryParam("size") int size) {

        return goalService.findGoals(page, size);

    }

​

    @POST

    public Goal create(Goal goal) {

        return goalService.save(goal);

    }

​

    @GET

    @Path("{id}")

    public Goal findById(@PathParam("id") String id) {

        return goalService.findById(id).orElseThrow(() -> new WebApplicationException("Goal not found", 404));

    }

}

Passo 7: Testare l’Applicazione

Ecco come testare la tua applicazione utilizzando curl:

Shell

curl -X POST -H "Content-Type: application/json" \

-d '{

      "title": "Learn JNoSQL",

      "description": "Master NoSQL with JNoSQL",

      "priority": 1,

      "tasks": ["Read documentation", "Write sample code"]

    }' \

http://localhost:8080/goals

​

curl -X POST -H "Content-Type: application/json" \

-d '{

      "title": "Get Fit",

      "description": "Adopt a healthier lifestyle",

      "priority": 2,

      "tasks": ["Exercise daily", "Eat balanced meals", "Stay hydrated"]

    }' \

http://localhost:8080/goals

​

curl -X POST -H "Content-Type: application/json" \

-d '{

      "title": "Learn Quarkus",

      "description": "Explore Quarkus framework features",

      "priority": 3,

      "tasks": ["Set up Quarkus", "Create REST endpoints", "Integrate JNoSQL"]

    }' \

http://localhost:8080/goals

Elenca gli Obiettivi:

Shell

curl http://localhost:8080/goals?page=1&size=10

Conclusione

Eclipse JNoSQL 1.1.3 dimostra il suo impegno nel rendere le interazioni con i database NoSQL senza soluzione di continuità per gli sviluppatori Java. Funzionalità migliorate e capacità di integrazione consentono agli sviluppatori di costruire applicazioni flessibili e scalabili. Per ulteriori dettagli, dai un’occhiata al completo esempio su GitHub.

Source:
https://dzone.com/articles/nosql-database-integration-in-java-with-eclipse-jnosql-1-1-3