Eclipse JNoSQL: Uma API para diversos bancos de dados NoSQL

O Eclipse JNoSQL é um framework que realiza a integração entre as aplicações Java com bancos de dados NoSQL. Ele define um grupo de APIs cujo objetivo é padronizar a comunicação entre a maioria dos bancos de dados e suas operações comuns. Isso ajuda a diminuir o acoplamento com este tipo de tecnologia utilizada nas aplicações atuais.

O projeto tem duas camadas:

1. Camada de comunicação: É um grupo de APIs que define a comunicação com os bancos de dados não relacionais. Comparado com os tradicionais bancos não relacionais, eles são semelhantes as APIs JDBC. Ele contém quatro módulos, um para cada tipo de banco NoSQL: chave-valor, família de coluna, documento e grafos. Sendo que a API grafo não é nova, será utilizada o Apache TinkerPop.
2. Camada de mapeamento: API que ajuda o desenvolvedor na integração com o banco não relacional, sendo orientada a anotações e utiliza tecnologias como injeção de dependências e Bean Validation, deixando simples para os desenvolvedores a utilizarem. Comparando com os clássicos RDBMS, essa camada pode ser comparada com o JPA ou outros frameworks de mapeamentos como o Hibernate.

Uma API para múltiplos banco de dados

O Eclipse NoSQL tem uma API para cada tipo de banco de dados não relacional, porém utiliza as mesmas anotações Java. Portanto, com apenas essas anotações, semelhantes ao JPA, existe suporte a mais de 20 bancos de dados.

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

Outro exemplo pode ser encontrado nesse artigo que demonstra que a mesma entidade anotada pode ser utilizada em diferentes bancos de dados: Redis, Cassandra, Couchbase e Neo4J. A abordagem foi manter a API: o desenvolvedor pode substituir Redis por Hazelcast, uma vez que ambos implementam chave-valor, evitando assim, ficar preso numa única implementação de banco de dados.

Vendor lock-in é uma das coisas que os projetos Java consideram evitar quando se trabalha com bancos não relacionais. Se houver a necessidade de mudar para outro banco, é necessário considerar pontos como: o tempo para a mudança, a curva de aprendizagem para a nova API, o código que será perdido além da camada da aplicação de persistência que será substituído. O Eclipse NoSQL evita alguns desses problemas por meio da camada de comunicação. Ele também possui classes template que funcionam semelhantes ao design pattern "Method Template", porém para operações no banco de dados. Também existe a interface Repository que permite que o desenvolvedor crie uma nova interface estendendo da Repository e os métodos serão implementados pelo próprio framework, ele também suporta "method by query", que cria consultas a partir do nome do método.

public interface GodRepository extends Repository {
    Optional 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");

Indo além do JPA

O JPA é uma boa API para mapeamento de objetos para o mundo relacional e já está definido como padrão no mundo Java a partir das JSRs. Seria realmente sensacional utilizar a mesma API para relacional e não relacional, porém existem comportamentos que o NoSQL possui que o relacional não possui, por exemplo, operações assíncronas, isso acontece simplesmente porque o JPA não foi feito para lidar com essas tecnologias de persistência.

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

A Fluent API

O Eclipse JNoSQL possui uma API fluente que facilita a criação de queries tanto para criar quanto para remover informações, por exemplo, para o 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 gods = template.select(query);//execute query
DocumentDeleteQuery delete = delete().from("god").where("name").eq("Diana").build();//delete query
template.delete(delete);

Não reinventaremos a roda: Grafo

A camada de comunicação define três novas APIs: chave-valor, documentos e família de colunas. Porém, não existe uma nova API para grafos, o motivo é que ele já existe. O Apache TinkerPop é um framework para grafos, o que o Eclipse JNoSQL realiza é uma fina integração com essa solução de Grafos.

Comportamentos específicos importam nos bancos de dados não relacionais

Comportamentos específicos importam, mesmo que os bancos sejam do mesmo tipo, cada banco de dados possui recursos únicos que são altamente importantes na escolha de um banco de dados sobre outro. Essas características facilitam o desenvolvimento, adicionam mais escalabilidade, definem o nível de consistência ou a engine de busca. Dentre esses comportamentos podemos citar o Cassandra Query Language e o nível de consistência para o Cassandra, o OrientDB com live queries, o ArangoDB também possui Arango Query Language, o Couchbase com N1QL, etc. Cada recurso realmente importa e é por isso que o Eclipse JNoSQL é extensível para capturar cada um desses elementos.

public interface PersonRepository extends CouchbaseRepository {
        @N1QL("select * from Person")
        List findAll();

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

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

Um padrão fácil de utilizar e uma API extensível

O Eclipse JNoSQL tem uma API bastante simples e amigável, essas interfaces tornam fácil a implementação de um novo banco de dados. Como mencionado anteriormente, cada banco não relacional tende a possuir um comportamento específico e eles importam, e é por isso que a API trabalha para cobrir esse ponto.

Tradução do tweet: Continuo completamente satisfeito em quão limpo é o @jnosql para implementação do @darwinodb. Adicionei consultas JSQL com surpreendentemente pouco código a mais.

Conclusão

O Eclipse JNoSQL é uma ferramenta importante quando os desenvolvedores Java EE querem integrar com bancos NoSQL. Especialmente porque já suporta mais de 20 bancos de dados não relacionais como: Cassandra, Redis, Neo4J, Couchbase, ArangoDB, Riak e MongoDB. O JNoSQL possui uma API única para cada tipo e código fluente para esse tipo de tecnologia com suporte síncrono e assíncronos por meio de classes template e interfaces Repository, gerenciado pelo CDI além de recursos específicos para cada banco de dados NoSQL. Essa é a fórmula que faz do Eclipse JNoSQL uma boa ferramenta para persistência poliglota.

Mais informações:

• Website: http://www.jnosql.org/
• Twitter: https://twitter.com/jnosql
• GitHub Repo: https://github.com/eclipse?q=Jnosql
• Mailing List: https://accounts.eclipse.org/mailing-list/jnosql-dev