Simplifique a Integração do Banco de Dados NoSQL em Java com o Eclipse JNoSQL 1.1.3

Bancos de dados NoSQL se tornaram uma pedra fundamental no desenvolvimento de aplicativos modernos, oferecendo escalabilidade e flexibilidade para lidar com diversos tipos de dados. No entanto, para muitos desenvolvedores Java, integrar-se com bancos de dados NoSQL pode ser complexo e demorado. É aí que o Eclipse JNoSQL entra, fornecendo uma maneira contínua e padronizada de conectar suas aplicações Java a diversos bancos de dados NoSQL.

Este artigo explora como o Eclipse JNoSQL 1.1.3 simplifica a integração de banco de dados, aprimora a produtividade do desenvolvedor e oferece flexibilidade entre diferentes bancos de dados. Também iremos guiá-lo por um exemplo prático usando Quarkus e ArangoDB para demonstrar seus recursos.

Por que os Desenvolvedores Java Deveriam se Importar com o Eclipse JNoSQL

Para muitos desenvolvedores, trabalhar com bancos de dados NoSQL envolve aprender APIs específicas do banco de dados, o que pode resultar em código fragmentado e não portável. O Eclipse JNoSQL elimina esses desafios ao oferecer:

• Facilidade de Uso: Com anotações intuitivas como @Entity, @Id e @Column, você pode mapear objetos Java para coleções NoSQL em segundos.
• Flexibilidade: Alternar entre bancos de dados NoSQL (por exemplo, Redis, MongoDB, ArangoDB, Oracle NoSQL) sem precisar alterar o código de sua aplicação.
• Conformidade com Padrões: Implementa as especificações Jakarta Data e Jakarta NoSQL, garantindo uma solução portátil e à prova de futuro.
• Pronto para integração: Funciona perfeitamente com os componentes Jakarta EE e MicroProfile, aproveitando o CDI para injeção de dependência e gerenciamento de configuração.

O que há de novo no Eclipse JNoSQL 1.1.3

O Eclipse JNoSQL acaba de lançar a versão 1.1.3, trazendo novos recursos, correções de bugs e melhorias de desempenho para seu ecossistema já robusto. Este lançamento é um marco significativo na simplificação das interações dos desenvolvedores Java com bancos de dados NoSQL. Neste artigo, vamos explorar os objetivos do Eclipse JNoSQL e os novos recursos introduzidos nesta versão, além de fornecer um exemplo prático de como usá-lo com Quarkus e ArangoDB.

O Eclipse JNoSQL tem como objetivo simplificar a integração de aplicativos Java com bancos de dados NoSQL, fornecendo uma API e arquitetura unificadas. Ao aderir às especificações do Jakarta EE, o JNoSQL capacita os desenvolvedores a trabalharem perfeitamente com vários bancos de dados NoSQL – sejam eles de valor-chave, documento, grafo ou família de colunas.

• Interoperabilidade: Esta abstração simplifica as complexidades específicas do banco de dados, facilitando a troca entre bancos de dados como MongoDB, Redis, ArangoDB e Oracle NoSQL.
• Baseado em especificações: Implementa as especificações Jakarta Data e Jakarta NoSQL, oferecendo uma maneira padronizada de trabalhar com bancos de dados NoSQL.
• Integração com o Ecossistema Java: Utiliza o CDI para injeção de dependência e o Eclipse MicroProfile para configuração, garantindo compatibilidade com frameworks Java modernos como Quarkus e Spring Boot.

Limitações e Considerações para Eclipse JNoSQL

Embora o Eclipse JNoSQL forneça benefícios significativos para a integração de banco de dados NoSQL, é essencial considerar algumas desvantagens para manter uma perspectiva equilibrada:

1. Curva de Aprendizado para Novos Padrões: Desenvolvedores não familiarizados com o Jakarta EE ou MicroProfile podem precisar de tempo para entender e se adaptar às especificações e APIs usadas pelo JNoSQL.
2. Recursos Específicos do Banco de Dados: Embora o JNoSQL abstraia operações comuns de NoSQL, ele pode não oferecer suporte total a recursos avançados específicos do banco de dados sem personalização adicional.
3. Comunidade e Ecossistema: Como uma ferramenta relativamente especializada, seu ecossistema e suporte da comunidade são menores do que estruturas Java mais amplas como o Hibernate ou Spring Data.
4. Otimização de Desempenho: APIs generalizadas podem introduzir uma leve sobrecarga de desempenho em comparação com bibliotecas nativas específicas do banco de dados, especialmente para aplicações de alta performance.

Compreender essas limitações ajuda os desenvolvedores a tomar decisões informadas e considerar onde o JNoSQL se encaixa melhor em seus projetos.

Especificações Jakarta EE Suportadas Pelo Eclipse JNoSQL

O Eclipse JNoSQL suporta Jakarta Data e Jakarta NoSQL, duas especificações críticas no ecossistema Jakarta EE.

Jakarta Data

Fornece uma API padrão para acessar e gerenciar repositórios de dados, permitindo que os desenvolvedores realizem operações CRUD facilmente. Foca em simplificar paginação, ordenação e consultas dinâmicas.

Jakarta NoSQL 

Define uma API uniforme para interações com bancos de dados NoSQL. Fornece anotações como @Entity, @Id e @Column para mapear classes Java a coleções NoSQL e simplificar operações de banco de dados.

Essas especificações reduzem o código repetitivo e promovem portabilidade entre bancos de dados, tornando-se essenciais para desenvolvedores Java.

A versão mais recente, versão 1.1.3, foca em melhorar a confiabilidade, segurança e desempenho, enquanto introduz novos recursos empolgantes:

• Redis: Suporte aprimorado para Redis Sentinel para melhor disponibilidade.
• ArangoDB: Atualizações de segurança e gerenciamento de chaves.
• Oracle NoSQL: Novas opções de credenciais para melhor integração.
• JNoSQL Lite: Suporte adicionado para registro, melhorando a rastreabilidade.
• Atualizações de Driver: Drivers melhorados para vários bancos de dados NoSQL.
• CDI Lite: Agora possui suporte para registros Java

Para mostrar o poder do Eclipse JNoSQL 1.1.3, criaremos uma aplicação Quarkus que gerencia “Metas” usando ArangoDB. Graças às especificações Jakarta EE, a transição para outros bancos de dados NoSQL, como MongoDB ou Oracle NoSQL, pode ser feita com mínimas alterações.

Passo a Passo

Passo 1: Configurando o Quarkus

Inicie seu projeto Quarkus usando a Quarkus Starter UI, selecionando as seguintes extensões:

• REST
• JSON
• ARC (CDI Lite)
• Driver ArangoDB

Seu pom.xml deve incluir:

<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: Implementando Conectividade com o Banco de Dados

Defina sua conexão com o banco de dados em application.properties:

jnosql.arangodb.host=localhost:8529

jnosql.document.database=goals

jnosql.keyvalue.database=goals

Execute uma instância do ArangoDB localmente usando Docker:

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

Crie um banco de dados chamado goals e uma coleção Goal na interface web do ArangoDB.

Passo 3: Modelando Seus Dados

Use o recurso de registro do Java com CDI Lite:

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: Configurando um Repositório

Defina um repositório usando Jakarta Data:

@Repository

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

Passo 5: Implementando uma Camada de Serviço

Crie uma camada de serviço para gerenciar a lógica de negócios:

@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: Criando Endpoints REST

Defina um recurso REST:

@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: Testando a Aplicação

Aqui está como testar sua aplicação usando curl:

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

Listar Metas:

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

Conclusão

O Eclipse JNoSQL 1.1.3 demonstra seu compromisso em tornar as interações com bancos de dados NoSQL mais simples para desenvolvedores Java. Recursos aprimorados e capacidades de integração capacitam os desenvolvedores a construir aplicações flexíveis e escaláveis. Para mais detalhes, confira o exemplo completo no GitHub.