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
- Java e NoSQL
- Por que não utilizar JPA no NoSQL?
- A estratégia de modularidade no projeto
- O trabalho da Oracle com NoSQL no Java EE
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.