BT

Início Artigos Modernização: Jakarta NoSQL foi aprovado como um projeto EE4J

Modernização: Jakarta NoSQL foi aprovado como um projeto EE4J

Favoritos

Java Enterprise Edition (Java EE) é um guarda-chuva de especificações e API para recursos como computação distribuída e web services focado no mundo corporativo em Java. Está presente como referência em diversos microservices ou servidores de aplicação, do qual consegue gerenciar transações, segurança, escalabilidade, concorrência, gerenciamento de componentes e deploys. Essa especificação para arquitetura corporativa vem sendo utilizada largamente nas aplicações Java (sim, se utilizamos Spring, somos desenvolvedores Java EE). O Java EE está de casa nova, agora, na Eclipse Foundation e com o nome nome: Jakarta EE cujo foco é modernizar as aplicações focando em Cloud Native com microservices, modularização e agora bancos NoSQL. Para modernizar o Jakarta EE, a primeira especificação deu o primeiro passo e foi aprovado como um projeto EE4J. Esse post falará sobre essa nova especificação e ações para fazer a comunidade Jakarta EE ainda melhor e mais participativa.

Esse resultado veio após um ano de trabalho da comunidade. Assim, existem alguns posts sobre essa especificação

Opa, você disse EE4J? Não seria Jakarta EE? Resumidamente, tem um ótimo glossário sobre esses termos no post do Ivar Grimstad.

EE4J

O Eclipse Enterprise para Java (EE4J) é o projeto de nível superior na Eclipse Foundation para todos os projetos de criação de padrões que formarão a base para o Jakarta EE. O Comitê de Gerenciamento de Projetos EE4J (PMC) é responsável por manter a visão geral do projeto em um nível superior. Ele definirá os padrões e requisitos para as liberações e ajudará os projetos a se comunicarem e cooperarem.

Jakarta EE

Jakarta EE é o nome da plataforma governada pelo Jakarta EE Working Group. A primeira versão será o Jakarta EE 8, que será baseado nas tecnologias Java EE 8 transferidas da Oracle para a Eclipse Foundation.

Como a primeira especificação, esse será um novo mundo totalmente inexplorável sobre o processo e cadência de lançamento, mas existem vários artigos falando sobre a filosofia do processo do Eclipse esperam que seja mais rápido do que o JCP, o qual colocará em prova nesta especificação.

Como desenvolvedor Java, espero um processo limpo, focado e voltado para a comunidade, portanto, uma cadência de lançamento a cada três meses para que a comunidade possa testar e fornecer feedback até a versão Jakarta EE 9, 1.0.0, que se parece com uma metodologia ágil.

O primeiro passo no Jakarta NoSQL tecnicamente é fazer a API, que terá modularidade e virá do Eclipse JNoSQL, portanto, Jakarta NoSQL é a API e TCK Eclipse JNoSQL é a implementação de referência para isso.

No escopo inicial existe um processo legal para migrar para o Eclipse Foundation como Jakarta NoSQL. Basicamente, o código virá do Eclipse JNoSQL, com o novo nome do pacote, agora sendo "jakarta.nosql". No código abaixo, mostramos como a comunicação da API pode ser no futuro:

import jakarta.nosql.document.DocumentCollectionManager;
import jakarta.nosql.document.DocumentCollectionManagerFactory;
import jakarta.nosql.document.DocumentConfiguration;
import jakarta.nosql.document.DocumentDeleteQuery;
import jakarta.nosql.document.DocumentEntity;
import jakarta.nosql.document.DocumentQuery;
import java.util.Arrays;
import java.util.List;
public class App {
    public static void main(String[] args) {
        //Carregando o serviço
        DocumentConfiguration configuration = DocumentConfiguration.getConfiguration();
        try (DocumentCollectionManagerFactory managerFactory = configuration.get()) {
            final DocumentCollectionManager manager = managerFactory.get("database");
            DocumentEntity entity = DocumentEntity.of("God");
            entity.add("name", "Diana");
            entity.add("age", 10);
            entity.add("versions", Arrays.asList("0.0.1", "0.0.2", "0.0.3"));
            manager.insert(entity);
            List<DocumentEntity> entities = DocumentQuery.select().from("God")
                    .where("name").eq("Diana").execute(manager);
            DocumentDeleteQuery.delete().from("God")
                    .where("age").gte(10).execute(manager);
        }
    }
}

O Jakarta NoSQL usará as mesmas abordagens do Eclipse JNoSQL, em outras palavras, terá uma API para cada tipo NoSQL, valor-chave, coluna, documento e gráfico. No mapeamento, usará o mesmo caminho com API comuns que terão classes que serão compartilhadas em todos os bancos de dados NoSQL, por exemplo, anotações de Mapeamento, como Entity, Column, Id e assim por diante.

import jakarta.nosql.mapping.Column;
import jakarta.nosql.mapping.Entity;
import jakarta.nosql.mapping.Id;
import java.util.List;
@Entity
public class Person {
    @Id
    private Long id;
    @Column
    private String name;
    @Column
    private List<String> phones;
    //getter and setter
}
import jakarta.nosql.document.DocumentQuery;
import jakarta.nosql.mapping.document.DocumentTemplate;
import javax.enterprise.inject.se.SeContainer;
import javax.enterprise.inject.se.SeContainerInitializer;
import java.util.Arrays;
import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;
import static jakarta.nosql.document.DocumentQuery.select;
public class App2 {
    public static void main(String[] args) {
        ThreadLocalRandom random = ThreadLocalRandom.current();
        Long id = random.nextLong();
        try (SeContainer container = SeContainerInitializer.newInstance().initialize()) {
            Person person = new Person();
            person.setPhones(Arrays.asList("234", "432"));
            person.setName("Name");
            person.setId(id);
            DocumentTemplate template = container.select(DocumentTemplate.class).get();
            Person saved = template.insert(person);
            System.out.println("Person saved" + saved);
            DocumentQuery query = select().from("Person")
                    .where("_id").eq(id).build();
            Optional<Person> personOptional = template.singleResult(query);
            System.out.println("Entity found: " + personOptional);
        }
    }
}

Jakarta EE tem um futuro brilhante, tecnologia, open source e a parte mais importante, a comunidade Java. Mais transparência, afinal, é o aspecto mais poderoso de Jakarta. Não é a tecnologia em si, mas o coração da comunidade. Portanto, o sucesso está na mão de cada desenvolvedor. Esperamos fornecer as duas primeiras especificações do Jakarta.

Avalie esse artigo

Relevância
Estilo/Redação

Olá visitante

Você precisa cadastrar-se no InfoQ Brasil ou para enviar comentários. Há muitas vantagens em se cadastrar.

Obtenha o máximo da experiência do InfoQ Brasil.

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

Comentários da comunidade

  • woowww

    by Carlos Santos /

    Seu comentário está aguardando aprovação dos moderadores. Obrigado por participar da discussão!

    Excelente mudança para evolução do Java EE, ops, Jakarta EE.rsss

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

BT

Seu cadastro no InfoQ está atualizado? Poderia rever suas informações?

Nota: se você alterar seu email, receberá uma mensagem de confirmação

Nome da empresa:
Cargo/papel na empresa:
Tamanho da empresa:
País:
Estado:
Você vai receber um email para validação do novo endereço. Esta janela pop-up fechará em instantes.