JNoSQL Logo
JNoSQL

Eclipse JNoSQL è un framework Java che semplifica l’integrazione delle applicazioni con i database NoSQL. Definisce un insieme di API e fornisce un’implementazione standard per la maggior parte dei database con l’obiettivo di  ottenere un accoppiamento molto basso con le tecnologie NoSQL utilizzate nelle applicazioni.

Il progetto ha due livelli:

  • Comunicazione: un insieme di API che definisce la comunicazione con i database NoSQL. Rispetto al tradizionale mondo RDBMS, sono equivalenti a JDBC. Contiene quattro moduli, uno per ogni tipo di database NoSQL: Key Value, Column Family, Document e Graph.
  • Mapping: questo livello aiuta gli sviluppatori a integrare la loro applicazione Java con il database NoSQL. Questo strato fa uso di  annotazioni e si appoggia su tecnologie come CDI e Bean Validation, che lo rendono semplice da utilizzare. Nel mondo RDBMS tradizionale, questo livello può essere paragonato a Java Persistence API o a Hibernate.

Un mapping API, più database

Eclipse JNoSQL ha una API per ogni tipo di database NoSQL. Tuttavia, utilizza le stesse annotazioni per mappare oggetti Java. In totale è disponibile il supporto per più di venti database NoSQL.

@Entity
public class God {

    @Id
    private String id;
    @Column
    private String name;
    @Column
    private String power;
 //...
}

Un altro esempio è presentato in questo articolo che dimostra che la stessa entità annotata può essere utilizzata su diversi NoSQL: Redis, Cassandra, Couchbase e Neo4J. L’approccio è “attenersi all’API”: lo sviluppatore può sostituire Redis con Hazelcast, in quanto entrambi implementano il valore chiave API (Key Value API), evitando così di legarsi ad uno specifico database.

Il vendor lock-in è una delle cose che qualsiasi progetto Java deve prendere in considerazione quando si scelgono i database NoSQL. Se in futuro c’è la possibilità di cambiare database vanno fatte ulteriori considerazioni: il tempo speso per la modifica, la curva di apprendimento di una nuova API, il codice che andrà riscritto, il livello di persistenza che deve essere sostituito, ecc. Eclipse JNoSQL evita la maggior parte di questi problemi tramite le API di comunicazione.

JNoSQL include anche delle classi template per le operazioni sui database. L’interfaccia del repository consente agli sviluppatori di creare ed estendere interfacce, con l’implementazione automatica fornita da Eclipse JNoSQL: le query del metodo di supporto create dagli sviluppatori verranno automaticamente implementate dalla libreria.

public interface GodRepository extends Repository<God, String> {
    Optional<God> findByName(String name);
}

GodRepository repository = ...;
God diana = God.builder().withId("diana").withName("Diana").withPower("hunt").builder();
repository.save(diana);
Optional idResult = repository.findById("diana");
Optional nameResult = repository.findByName("Diana");

Oltre JPA

JPA è una buona API per il mapping relazionale tra oggetti (ORM) ed è già uno standard nel mondo Java definito in JSR. Sarebbe bello usare la stessa API sia per SQL che per NoSQL, ma ci sono comportamenti in NoSQL che SQL non copre, come il time to live e le operazioni asincrone. JPA semplicemente non è stato creato per gestire queste funzionalità.

ColumnTemplateAsync templateAsync = …;
ColumnTemplate template = …;
God diana =God.builder().withId("diana").withName("Diana").withPower("hunt").builder();
Consumer<God> callback = g -> System.out.println("Insert completed to: " + g);
templateAsync.insert(diana, callback);
Duration ttl = Duration.ofSeconds(1);
template.insert(diana, Duration.ofSeconds(1));

Un’API fluente

Eclipse JNoSQL implementa un’API fluente che rende semplice creare query che richiamano o eliminano informazioni in un tipo di documento, come nell’esempio qui sotto.

DocumentTemplate template = //;//a template to document nosql operations
God diana =God.builder().withId("diana").withName("Diana").withPower("hunt").builder();
template.insert(diana);//insert an entity
DocumentQuery query=select().from(God.class).where("name").eq("Diana").build();//select god where name equals “Diana”
List<God> gods = template.select(query);//execute query
DocumentDeleteQuery delete = delete().from("god").where("name").eq("Diana").build();//delete query
template.delete(delete);

Non reinventiamo la ruota: i grafi

Il livello di comunicazione definisce tre tipi di interazione: Key Value, Document  e Column Family. Non definisce una implementazione per grafi , perché ne esiste già una molto valida. Apache TinkerPop è un graph computing framework  usato sia per database a grafo (OLTP) che sistemi analitici a grafo (OLAP).

Il comportamento specifico è importante nei database NoSQL

Il comportamento specifico è importante. Anche all’interno dello stessa tipologia, ogni database NoSQL ha caratteristiche uniche che sono un fattori considerevoli quando si sceglie una soluzionepiuttosto che un’altra. Queste feature potrebbero rendere più facile lo sviluppo, favorire la scalabilità o la consistenza del dato, influire sui criteri di ricerca, ecc. Alcuni esempi sono Cassandra con il suo linguaggio di interrogazione e il livello di consistenza, OrientDB con le live queries, ArangoDB e il suo linguaggio di interrogazione, Couchbase con N1QL e la lista continua. Ogni NoSQL ha un comportamento specifico: JNoSQL è abbastanza estensibile per catturare queste funzionalità sostanzialmente differenti.

public interface PersonRepository extends CouchbaseRepository {

        @N1QL("select * from Person")
        List<Person> findAll();

        @N1QL("select * from Person where name = $name")
        List<Person> findByName(@Param("name") String name);
}

Person person = ...
CassandraTemplate template = ...
ConsistencyLevel level = ConsistencyLevel.THREE;
template.save(person, level);

Un’API di estensione standard e facile da usare

L’API di JNoSQL ha un’interfaccia semplice e intuitiva che semplifica l’aggiunta di un nuovo database. Avere un’interfaccia semplice ed estensibile è fondamentale, come lo è  avere un processo di facile implementazione. Ecco perché JNoSQL offre un kit di compatibilità tecnologica, chiamato TCK:è una suite di test che verifica una particolare implementazione.

Conclusione

Eclipse JNoSQL è uno strumento eccellente da usare quando gli sviluppatori vogliono integrarsi con i database NoSQL. Ciò è particolarmente vero perché supporta già più di venti database NoSQL, come Cassandra, Redis, Neo4J, Couchbase, ArangoDB, Riak e MongoDB.

JNoSQL tramite un’API unificata e fluente supporta queste tecnologie di persistenza, sia con chiamate sincrone che asincrone fornendo funzionalità per un  specifico provider NoSQ. Questa è una formula che rende Eclipse JNoSQL uno strumento utile per la persistenza poliglotta e per l’accesso i big data sul mondo NoSQL.

Scopri maggiori informazioni e lasciati coinvolgere!

1 Posts

Otávio è un appassionato ingegnere del software incentrato sulla tecnologia Java. Ha esperienza principalmente in persistenza poliglotta e applicazioni ad alte prestazioni in finanze, social media ed e-commerce. Otavio è membro di entrambi i gruppi di esperti e leader esperto in diversi JSR e JCP executive committee. Sta lavorando su diversi progetti Apache ed Eclipse Foundation come Apache Tamaya, Eclipse JNoSQL, Eclipse MicroProfile, JakartaEE. Un leader JUG e speaker di livello internazionale alle conferenze JavaOne e Devoxx. Otavio ha ricevuto riconoscimenti per i suoi contributi OSS come il JCP Outstanding Award, Member of the year e innovative JSR, il Duke's Choice Award e il Java Champion Award.