Eclipse JNoSQL: Una API para diversas bases de datos NoSQL

Por Otavio Santana Java Champion Oracle Developer Champion
Publicado en Julio 2018

Revisado por Alexis Lopez



Conozca sobre Eclipse JNoSQL, herramienta que pretende ser un nuevo estándar para las bases de datos no relacionales.

Las bases de datos no relacionales están presentes en las más diversas áreas en el mundo corporativo, pero hay un problema, cada base de datos tiene su propia API, lo cual resulta en un alto riesgo de bloqueo por software propietario, no poder reutilizar el código y curva de aprendizaje al cambiar de base de datos. Conozca Eclipse JnoSQL, una herramienta que busca facilitar la integración de Java con NoSQL.


Eclipse JNoSQL es un framework que realiza la integración entre las aplicaciones Java con bases de datos NoSQL. Define un grupo de APIs cuyo objetivo es estandarizar la comunicación entre Java y la mayoría de las bases de datos NoSQL con sus operaciones comunes. Esto ayuda a disminuir el acoplamiento con este tipo de tecnologías utilizadas en las aplicaciones modernas.

El proyecto tiene dos frentes:

  1. Comunicación: Grupo de APIs que definen la comunicación con las bases de datos no relacionadas. Comparado con las base de datos tradicionales, son semejantes a las APIs JDBC. Contiene cuatro módulos, uno para cada tipo de base de datos NoSQL: llave-valor, familia de columna, documento y grafos. Siendo que la API de grafos no es nueva, se utilizará Apache TinkerPop.

  2. Mapeo: API que ayuda en la integración con las bases de datos no relacionales. Orientada a anotaciones y utilizando tecnologías como inyección de dependencias y Bean Validation, bastante sencilla para que los desarrolladores la utilicen. Comparando con las bases de datos tradicionales, es semejante a JPA u otros frameworks de mapeo como Hibernate.





Una API para múltiples bases de datos


Eclipse NoSQL tiene una API para cada tipo de base de datos no relacional, sin embargo, utiliza las mimas anotaciones Java para cada una de ellas. Por lo tanto, con apenas esas anotaciones, que además son semejantes a las de JPA, soporta mas de 20 base de datos.

@Entity
public class God {
    @Id
    private String id;
    @Column
    private String name;
    @Column
    private String power;
 //... 
}

El anterior código muestra que la misma entidad con sus anotaciones puede ser utilizada en diferentes bases de datos no relacionales: Redis, Cassandra, Couchbase y Neo4J. Al utilizar la API, el desarrollador puede sustituir Redis por Hazelcast, ya que ambas implementan llave-valor, evitando así, quedar preso en una única implementación de base de datos.

Vendor lock-in (Dependencia de un provedor) es una de las cosas que los proyectos Java consideran evitar cuando se trabaja con bases no relacionales. Si hubiera la necesidad de cambiar a otra base de datos no relacional, es necesario considerar puntos como: el tiempo para el cambio, la curva de aprendizaje para la nueva API, el código que será perdido pues no se podrá reutilizar, etc. Eclipse NoSQL evita algunos de esos problemas por medio de la API de comunicación. Posee clases plantilla que funcionan semejantes al patrón de diseño “Method Template”, pero aplicado a operaciones en la base de datos. También existe la interface Repository que permite que el desarrollador cree una nueva interface que extiende de ésta y los métodos serán implementados por el propio framework. Otra funcionalidad es que soporta “method by query”, que crea consultas a partir del nombre del método.

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<God> idResult = repository.findById("diana");
Optional<God> nameResult = repository.findByName("Diana");



Además de JPA


JPA es una buena API para mapeo de objetos en el mundo relacional y ya está definido como un estándar en el mundo Java. Sería realmente sensacional utilizar la misma API para el mundo relacional y el no relacional, sin embargo existen comportamientos que el NoSQL posee pero que el relacional no, por ejemplo, operaciones asincrónicas.

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




API FLUIDA


Eclipse JNoSQL posee una API fluida que facilita la creación de consultas tanto para insertar como para remover registros, por ejemplo, para el tipo NoSQL por documentos:

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



No reinventaremos la rueda: Grafos

El frente de comunicación define tres nuevas APIs: llave-valor, documentos y familia de columnas. Sin embargo, no existe una nueva API para los grafos, debido a que ya existe  Apache TinkerPop, el cual es un framework para grafos que Eclipse JNoSQL usará por medio de una fina integración.



Comportamientos específicos importan en las bases de datos no relacionales

Comportamientos específicos importan, aunque las bases de datos no relacionales sean del mismo tipo, cada base de datos posee recursos únicos que son altamente importantes en la elección de una sobre otra. Esas características facilitan el desarrollo, adicionan mas escalabilidad, definen el nivel de consistencia o el motor de búsqueda. Dentro de  esos comportamientos podemos citar Cassandra Query Language que es el nivel de consistencia para  Cassandra,  OrientDB con “live queries”,  ArangoDB también posee Arango Query Language,  Couchbase con N1QL, etc. Cada recurso realmente importa y es por eso que Eclipse JNoSQL es extensible para capturar cada uno de esos elementos:

public interface PersonRepository extends CouchbaseRepository<Person, String> {
        @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 estándar fácil de utilizar y una API extensible


Eclipse JNoSQL tiene una API bastante simple y amigable, sus interfaces hacen fácil la implementación de una nueva base de datos. Como mencionado anteriormente, cada base no relacional tiende a poseer un comportamiento específico y ellos importan, y es por eso que la API trabaja para cubrir ese punto.

Traducción del tweet: Sigo completamente satisfecho de cuan limpio es el @jnosql para la implementación de @darwinodb. Adicioné consultas JSQL con sorprendentemente poco código.



Conclusión


Eclipse JNoSQL es una herramienta importante cuando los desarrolladores Java EE quieren integrar con las bases NoSQL. Especialmente porque ya soporta mas de 20 bases de datos no relacionales como: Cassandra, Redis, Neo4J, Couchbase, ArangoDB, Riak e MongoDB. JNoSQL posee una API única para cada tipo y código fluido para ese tipo de tecnología con soporte sincrónico y asincrónico por medio de clases tipo plantilla e interfaces Repository, administrado por CDI y posibilidad de extención para recursos específicos de cada base de datos NoSQL. Esa es la fórmula que hace de Eclipse JNoSQL una buena herramienta para persistencia políglota.

Mas información:




Otávio is a passionate software engineer focused on Java technology. He has experience mainly in persistence polyglot and high-performance applications in finances, social media, and e-commerce. Otavio is a member of both Expert Groups and Expert Leader in several JSRs and JCP executive committee. He is working on several Apache and Eclipse Foundation projects such as Apache Tamaya, Eclipse JNoSQL, Eclipse MicroProfile, JakartaEE. A JUG leader and global speaker at JavaOne and Devoxx conferences. Otavio has received recognition for his OSS contributions such as the JCP Outstanding Award, Member of the year and innovative JSR, Duke's Choice Award, and Java Champion Award, to name a few. twitter: @otaviojava

Este artículo ha sido revisado por el equipo de productos Oracle y se encuentra en cumplimiento de las normas y prácticas para el uso de los productos Oracle.